la lecture du fichier ligne par ligne en aller

Il y a de la fonction ReadLine dans le paquet bufio.

Veuillez noter que si la ligne ne rentre pas dans la mémoire tampon de lecture, la fonction retournera un incomplètes ligne. Si vous voulez toujours de lire une ligne entière dans votre programme par un seul appel à une fonction, vous aurez besoin d'encapsuler le ReadLine fonction dans votre propre fonction qui appelle ReadLine dans une boucle for.

bufio.ReadString('\n') n'est pas tout à fait équivalente à ReadLine parce que ReadString est incapable de gérer le cas lors de la dernière ligne d'un fichier ne se termine pas avec le caractère de saut de ligne.

Utilisation:

• reader.ReadString('\n')
  • Si vous n'avez pas l'esprit que la ligne pourrait être très long (c'est à dire utiliser beaucoup de mémoire). Il garde le \n à la fin de la chaîne de caractères retournée.
• reader.ReadLine()
  • Si vous vous souciez de la limitation de consommation de RAM et ne me dérange pas le travail supplémentaire de traiter le cas où la ligne est plus grande que le lecteur de la taille de la mémoire tampon.

J'ai testé les différentes solutions proposées par l'écriture d'un programme pour tester les scénarios qui sont identifiés comme des problèmes dans d'autres réponses:

• Un fichier avec un 4MB ligne.
• Un fichier qui ne se terminent pas par un saut de ligne.

J'ai constaté que:

• La Scanner solution ne permet pas de gérer de longues lignes.
• La ReadLine solution est complexe à mettre en œuvre.
• La ReadString solution est la plus simple et fonctionne pour les lignes longues.

Voici le code qui démontre chaque solution, il peut être exécuté via 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]
}

J'ai testé sur:

• go version go1.7 windows/amd64
• go version go1.6.3/linux amd64
• go version go1.7.4 darwin/amd64

Le programme de test de sortie:

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.

Il y a deux façon de lire le fichier ligne par ligne.

1. Utilisation bufio.Scanner
2. Utilisation ReadString/ReadBytes/... dans bufio.Lecteur

Dans mon cas de test, ~250 MO, ~de 2 500 000 lignes, bufio.Scanner(temps utilisé: 0.395491384 s) est plus rapide que bufio.Reader.ReadString(time_used: 0.446867622 s).

Code Source: https://github.com/xpzouying/go-practice/tree/master/read_file_line_by_line

Lire fichier utiliser 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
}
}

Lire fichier utiliser bufio.Lecteur,

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
}
}

Exemple de ce gist

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
}
}

mais cela donne une erreur quand il y a une ligne de plus de Scanner de mémoire tampon.

Quand c'est arrivé, ce que je faire est d'utiliser reader := bufio.NewReader(inFile) créer et concat mon propre tampon, soit à l'aide de ch, err := reader.ReadByte() ou len, err := reader.Read(myBuffer)

//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
}

Voici un exemple avec la fonction ReadFromStdin() c'est comme fmt.Scan(&name) mais sa prend toutes les chaînes de caractères avec des espaces comme: "Bonjour, Mon Nom Est ..."

var name string = ReadFromStdin()
println(name)