パッケージbufioには関数 ReadLine があります。
その行が読み取りバッファに収まらない場合、この関数は不完全な行を返します。関数を1回呼び出すだけでプログラムの1行全体を読みたい場合は、ReadLine関数をforループ内でReadLineを呼び出す独自の関数にカプセル化する必要があります。
ファイルの最後の行が改行文字で終わっていない場合、ReadLineは大文字と小文字の区別を処理できないため、bufio.ReadString('\n')はReadStringと完全に同等ではありません。
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を1行ずつ読み込む最もクリーンな方法です。
注意点が1つあります。スキャナは、65536文字を超える行をうまく処理しません。それがあなたにとって問題であるならば、あなたはおそらくReader.Read()の上にあなた自身を転がすべきです。
つかいます：
reader.ReadString('\n')- ラインが非常に長くなる可能性があることを気にしないのであれば（つまり、大量のRAMを使用してください）。返された文字列の末尾に
\nを保持します。
- ラインが非常に長くなる可能性があることを気にしないのであれば（つまり、大量のRAMを使用してください）。返された文字列の末尾に
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]
}
私はテストしました：
- バージョンgo1.7 windows/AMD64に行く
- go version go1.6.3 linux/AMD64
- go version go1.7.4ダーウィン/ 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.
編集：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)
}
乾杯！
ファイルを1行ずつ読み込む一般的な方法は2つあります。
- Bufio.Scannerを使う
- Bufio.ReaderでReadString/ReadBytes/...を使用します。
私のテストケースでは、〜250MB、〜2,500,000行、bufio.Scanner（使用時間：0.395491384s）はbufio.Reader.ReadString（time_used：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
}
}
区切り文字として\ 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
}
}
これからの例 要旨
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
}
}
しかし、これはScannerのバッファよりも大きい行があるとエラーになります。
それが起こったとき、私がすることはreader := bufio.NewReader(inFile)またはch, err := reader.ReadByte()のどちらかを使用して私の自身のバッファを作成し連結するlen, err := reader.Read(myBuffer)を使用することです
bufio.Reader.ReadLine（） はうまく機能します。ただし、各行を文字列で読みたい場合は、 ReadString（ '\ n'） を使用してみてください。それは車輪を再発明する必要はありません。
// 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
}
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)の例ですが、 "Hello My Name Is ..."のように空白文字ですべての文字列を取ります。
var name string = ReadFromStdin()
println(name)
以下のコードでは、ユーザーがenterを押してReadlineを使用するまで、CLIからインタレストを読みます。
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)
私は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）でエラーを生成しないのはなぜですか？ループが実行されるたびに繰り返し定義されます。私は私の変更でそのような状況を避けています、何かコメント？ Whileの場合と同様に、 'for'に条件EOFを設定します。ありがとう