在Go中逐行读取文件


334

file.ReadLine在Go中找不到功能。我可以弄清楚如何快速编写一个,但是我只是想知道我是否在这里忽略了一些东西。如何逐行读取文件?


7
从Go1.1开始,bufio.Scanner是执行此操作的最佳方法。
马尔科姆

Answers:


133

注意:可接受的答案在早期的Go版本中是正确的。 请参阅投票率最高的答案,其中包含更新的惯用方式。

包中有ReadLine函数bufio

请注意,如果该行不适合读取缓冲区,则该函数将返回不完整的行。如果要始终通过单次调用函数来读取程序中的整行,则需要将该ReadLine函数封装到自己的函数中,该函数ReadLine在for循环中进行调用。

bufio.ReadString('\n')之所以不完全等效,ReadLine是因为ReadString无法处理文件的最后一行不以换行符结尾的情况。


37
从文档中:“ ReadLine是低级别的行读取原语。大多数调用者应改用ReadBytes('\ n')或ReadString('\ n')或使用扫描仪。”
mdwhatcott 2014年

12
@mdwhatcott为什么它是“低级行读取原语”很重要?如何得出结论:“大多数调用者应改用ReadBytes('\ n')或ReadString('\ n')或使用Scanner。”?
查理·帕克

12
@CharlieParker-不确定,只需引用文档以添加上下文。
mdwhatcott 2014年

11
来自同一文档。“如果ReadString在找到定界符之前遇到错误,它将返回错误之前读取的数据和错误本身(通常为io.EOF)。” 因此,您只需检查io.EOF错误并知道您已完成。
eduncan911

1
请注意,由于系统调用中断,读取或写入可能会失败,导致读取或写入的字节数少于预期数量。
贾斯汀·斯旺哈特

598

在Go 1.1及更高版本中,最简单的方法是使用bufio.Scanner。这是一个从文件读取行的简单示例:

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
)

func main() {
    file, err := os.Open("/path/to/file.txt")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        fmt.Println(scanner.Text())
    }

    if err := scanner.Err(); err != nil {
        log.Fatal(err)
    }
}

这是Reader逐行读取的最干净的方法。

有一个警告:扫描程序不能处理超过65536个字符的行。如果这对您来说是个问题,那么您可能应该在上滚动Reader.Read()


40
并且由于OP要求扫描文件,因此先file, _ := os.Open("/path/to/file.csv")扫描然后再扫描文件句柄将是微不足道的:scanner := bufio.NewScanner(file)
Evan Plumlee 2013年

14
别忘了defer file.Close()
基里尔2014年

13
问题是Scanner.Scan()限制为每行4096 [] byte缓冲区大小。您会收到bufio.ErrTooLong错误消息,即bufio.Scanner: token too long行太长。在这种情况下,您将必须使用bufio.ReaderLine()或ReadString()。
eduncan911

5
只是我的0.02美元-这是页面上最正确的答案:)
sethvargo 2014年

5
您可以使用其Buffer()方法将Scanner配置为处理更长的行:golang.org/pkg/bufio/#Scanner.Buffer
Alex Robinson

78

采用:

  • reader.ReadString('\n')
    • 如果您不介意那行可能很长(即使用大量RAM)。它将保留\n在返回字符串的末尾。
  • reader.ReadLine()
    • 如果您关心限制RAM的使用并且不介意处理行大于读取器的缓冲区大小的情况,则无需进行额外的工作。

我编写了一个程序来测试在其他答案中被认为是问题的方案,从而测试了各种解决方案:

  • 带有4MB行的文件。
  • 不以换行符结尾的文件。

我找到:

  • Scanner解决方案无法处理长行。
  • ReadLine解决方案实施起来很复杂。
  • ReadString解决方案是最简单的,适用于排长队。

这是演示每种解决方案的代码,可以通过go run main.go以下方式运行:

package main

import (
    "bufio"
    "bytes"
    "fmt"
    "io"
    "os"
)

func readFileWithReadString(fn string) (err error) {
    fmt.Println("readFileWithReadString")

    file, err := os.Open(fn)
    defer file.Close()

    if err != nil {
        return err
    }

    // Start reading from the file with a reader.
    reader := bufio.NewReader(file)

    var line string
    for {
        line, err = reader.ReadString('\n')

        fmt.Printf(" > Read %d characters\n", len(line))

        // Process the line here.
        fmt.Println(" > > " + limitLength(line, 50))

        if err != nil {
            break
        }
    }

    if err != io.EOF {
        fmt.Printf(" > Failed!: %v\n", err)
    }

    return
}

func readFileWithScanner(fn string) (err error) {
    fmt.Println("readFileWithScanner - this will fail!")

    // Don't use this, it doesn't work with long lines...

    file, err := os.Open(fn)
    defer file.Close()

    if err != nil {
        return err
    }

    // Start reading from the file using a scanner.
    scanner := bufio.NewScanner(file)

    for scanner.Scan() {
        line := scanner.Text()

        fmt.Printf(" > Read %d characters\n", len(line))

        // Process the line here.
        fmt.Println(" > > " + limitLength(line, 50))
    }

    if scanner.Err() != nil {
        fmt.Printf(" > Failed!: %v\n", scanner.Err())
    }

    return
}

func readFileWithReadLine(fn string) (err error) {
    fmt.Println("readFileWithReadLine")

    file, err := os.Open(fn)
    defer file.Close()

    if err != nil {
        return err
    }

    // Start reading from the file with a reader.
    reader := bufio.NewReader(file)

    for {
        var buffer bytes.Buffer

        var l []byte
        var isPrefix bool
        for {
            l, isPrefix, err = reader.ReadLine()
            buffer.Write(l)

            // If we've reached the end of the line, stop reading.
            if !isPrefix {
                break
            }

            // If we're just at the EOF, break
            if err != nil {
                break
            }
        }

        if err == io.EOF {
            break
        }

        line := buffer.String()

        fmt.Printf(" > Read %d characters\n", len(line))

        // Process the line here.
        fmt.Println(" > > " + limitLength(line, 50))
    }

    if err != io.EOF {
        fmt.Printf(" > Failed!: %v\n", err)
    }

    return
}

func main() {
    testLongLines()
    testLinesThatDoNotFinishWithALinebreak()
}

func testLongLines() {
    fmt.Println("Long lines")
    fmt.Println()

    createFileWithLongLine("longline.txt")
    readFileWithReadString("longline.txt")
    fmt.Println()
    readFileWithScanner("longline.txt")
    fmt.Println()
    readFileWithReadLine("longline.txt")
    fmt.Println()
}

func testLinesThatDoNotFinishWithALinebreak() {
    fmt.Println("No linebreak")
    fmt.Println()

    createFileThatDoesNotEndWithALineBreak("nolinebreak.txt")
    readFileWithReadString("nolinebreak.txt")
    fmt.Println()
    readFileWithScanner("nolinebreak.txt")
    fmt.Println()
    readFileWithReadLine("nolinebreak.txt")
    fmt.Println()
}

func createFileThatDoesNotEndWithALineBreak(fn string) (err error) {
    file, err := os.Create(fn)
    defer file.Close()

    if err != nil {
        return err
    }

    w := bufio.NewWriter(file)
    w.WriteString("Does not end with linebreak.")
    w.Flush()

    return
}

func createFileWithLongLine(fn string) (err error) {
    file, err := os.Create(fn)
    defer file.Close()

    if err != nil {
        return err
    }

    w := bufio.NewWriter(file)

    fs := 1024 * 1024 * 4 // 4MB

    // Create a 4MB long line consisting of the letter a.
    for i := 0; i < fs; i++ {
        w.WriteRune('a')
    }

    // Terminate the line with a break.
    w.WriteRune('\n')

    // Put in a second line, which doesn't have a linebreak.
    w.WriteString("Second line.")

    w.Flush()

    return
}

func limitLength(s string, length int) string {
    if len(s) < length {
        return s
    }

    return s[:length]
}

我测试了:

  • go版本go1.7 Windows / amd64
  • go版本go1.6.3 linux / amd64
  • go版本go1.7.4 darwin / amd64

测试程序输出:

Long lines

readFileWithReadString
 > Read 4194305 characters
 > > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 > Read 12 characters
 > > Second line.

readFileWithScanner - this will fail!
 > Failed!: bufio.Scanner: token too long

readFileWithReadLine
 > Read 4194304 characters
 > > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 > Read 12 characters
 > > Second line.

No linebreak

readFileWithReadString
 > Read 28 characters
 > > Does not end with linebreak.

readFileWithScanner - this will fail!
 > Read 28 characters
 > > Does not end with linebreak.

readFileWithReadLine
 > Read 28 characters
 > > Does not end with linebreak.

9
defer file.Close()应该是错误检查后; 否则会出错。
mlg

如果您这样配置,扫描仪解决方案确实可以处理较长的行。请参阅:golang.org/pkg/bufio/#Scanner.Buffer
Inanc Gumus

您应该按照文档中所示正确检查错误:play.golang.org/p/5CCPzVTSj6, 即如果err == io.EOF {break} else {return err}
Chuque

53

编辑:从go1.1开始,惯用的解决方案是使用bufio.Scanner

我写了一种方法,可以轻松地从文件中读取每一行。Readln(* bufio.Reader)函数从基础bufio.Reader结构返回一行(sans \ n)。

// Readln returns a single line (without the ending \n)
// from the input buffered reader.
// An error is returned iff there is an error with the
// buffered reader.
func Readln(r *bufio.Reader) (string, error) {
  var (isPrefix bool = true
       err error = nil
       line, ln []byte
      )
  for isPrefix && err == nil {
      line, isPrefix, err = r.ReadLine()
      ln = append(ln, line...)
  }
  return string(ln),err
}

您可以使用Readln读取文件中的每一行。以下代码读取文件中的每一行,并将每一行输出到stdout。

f, err := os.Open(fi)
if err != nil {
    fmt.Printf("error opening file: %v\n",err)
    os.Exit(1)
}
r := bufio.NewReader(f)
s, e := Readln(r)
for e == nil {
    fmt.Println(s)
    s,e = Readln(r)
}

干杯!


14
我在Go 1.1发布之前就写了这个答案。Go 1.1在stdlib中有一个Scanner软件包。提供与我的答案相同的功能。由于Scanner位于stdlib中,因此我建议您使用Scanner而不是我的答案。骇客骇客!:-)
马尔科姆

30

有两种常见的方式逐行读取文件。

  1. 使用bufio.Scanner
  2. 在bufio.Reader中使用ReadString / ReadBytes / ...

在我的测试用例中,〜250MB,〜2,500,000 ,bufio.Scanner(使用时间:0.395491384s)比bufio.Reader.ReadString(使用时间:0.446867622s)更快。

源代码: https //github.com/xpzouying/go-practice/tree/master/read_file_line_by_line

使用bufio.Scanner读取文件,

func scanFile() {
    f, err := os.OpenFile(logfile, os.O_RDONLY, os.ModePerm)
    if err != nil {
        log.Fatalf("open file error: %v", err)
        return
    }
    defer f.Close()

    sc := bufio.NewScanner(f)
    for sc.Scan() {
        _ = sc.Text()  // GET the line string
    }
    if err := sc.Err(); err != nil {
        log.Fatalf("scan file error: %v", err)
        return
    }
}

使用bufio.Reader读取文件,

func readFileLines() {
    f, err := os.OpenFile(logfile, os.O_RDONLY, os.ModePerm)
    if err != nil {
        log.Fatalf("open file error: %v", err)
        return
    }
    defer f.Close()

    rd := bufio.NewReader(f)
    for {
        line, err := rd.ReadString('\n')
        if err != nil {
            if err == io.EOF {
                break
            }

            log.Fatalf("read file line error: %v", err)
            return
        }
        _ = line  // GET the line string
    }
}

请注意,如果该bufio.Reader示例不以换行符结尾,则不会读取文件的最后一行。ReadString将同时返回最后一行io.EOF
康拉德

18

这个要点的例子

func readLine(path string) {
  inFile, err := os.Open(path)
  if err != nil {
     fmt.Println(err.Error() + `: ` + path)
     return
  }
  defer inFile.Close()

  scanner := bufio.NewScanner(inFile)
  for scanner.Scan() {
    fmt.Println(scanner.Text()) // the line
  }
}

但是当一行大于扫描仪的缓冲区时,这会产生错误。

发生这种情况时,我要做的是使用reader := bufio.NewReader(inFile)create并使用ch, err := reader.ReadByte()或concat我自己的缓冲区len, err := reader.Read(myBuffer)

我使用的另一种方式(用上面的文件替换os.Stdin),当行很长(isPrefix)并忽略空行时,此连接会出现:


func readLines() []string {
  r := bufio.NewReader(os.Stdin)
  bytes := []byte{}
  lines := []string{}
  for {
    line, isPrefix, err := r.ReadLine()
    if err != nil {
      break
    }
    bytes = append(bytes, line...)
    if !isPrefix {
      str := strings.TrimSpace(string(bytes))
      if len(str) > 0 {
        lines = append(lines, str)
        bytes = []byte{}
      }
    }
  }
  if len(bytes) > 0 {
    lines = append(lines, string(bytes))
  }
  return lines
}

在乎解释为什么-1
Kokizzu 2015年

我认为,这使该解决方案有些复杂,不是吗?
Decebal

10

您还可以使用带有\ n的ReadString作为分隔符:

  f, err := os.Open(filename)
  if err != nil {
    fmt.Println("error opening file ", err)
    os.Exit(1)
  }
  defer f.Close()
  r := bufio.NewReader(f)
  for {
    path, err := r.ReadString(10) // 0x0A separator = newline
    if err == io.EOF {
      // do something here
      break
    } else if err != nil {
      return err // if you return error
    }
  }


3
// strip '\n' or read until EOF, return error if read error  
func readline(reader io.Reader) (line []byte, err error) {   
    line = make([]byte, 0, 100)                              
    for {                                                    
        b := make([]byte, 1)                                 
        n, er := reader.Read(b)                              
        if n > 0 {                                           
            c := b[0]                                        
            if c == '\n' { // end of line                    
                break                                        
            }                                                
            line = append(line, c)                           
        }                                                    
        if er != nil {                                       
            err = er                                         
            return                                           
        }                                                    
    }                                                        
    return                                                   
}                                    

1

在下面的代码中,我从CLI读取了感兴趣的内容,直到用户单击Enter并使用Readline:

interests := make([]string, 1)
r := bufio.NewReader(os.Stdin)
for true {
    fmt.Print("Give me an interest:")
    t, _, _ := r.ReadLine()
    interests = append(interests, string(t))
    if len(t) == 0 {
        break;
    }
}
fmt.Println(interests)

0

我喜欢Lzap解决方案,我是Go的新手,我想问一下lzap,但我还不能做到,我还没有50分。

package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
)

func main() {
    f, err := os.Open("archiveName")
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    defer f.Close()
    r := bufio.NewReader(f)
    line, err := r.ReadString(10)    // line defined once 
    for err != io.EOF {
        fmt.Print(line)              // or any stuff
        line, err = r.ReadString(10) //  line was defined before
    }
}

我不确定为什么我需要再次测试'err',但是无论如何我们都能做到。但是,主要问题是..为什么Go在循环内不会在句子=>行err:= r.ReadString(10)上产生错误?每次循环执行一次又一次定义。我可以通过更改来避免这种情况,对此有何评论?我也在'for'中将条件EOF设置为类似于While。谢谢


0
import (
     "bufio"
     "os"
)

var (
    reader = bufio.NewReader(os.Stdin)
)

func ReadFromStdin() string{
    result, _ := reader.ReadString('\n')
    witl := result[:len(result)-1]
    return witl
}

下面是与功能相关的例子ReadFromStdin()是像fmt.Scan(&name),但它需要有空格的所有字符串,如:“我的名字是......”

var name string = ReadFromStdin()

println(name)
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.