Je n'arrive pas à trouver de file.ReadLine
fonction dans Go. Je peux comprendre comment en écrire rapidement un, mais je me demande simplement si j'oublie quelque chose ici. Comment lire un fichier ligne par ligne?
Je n'arrive pas à trouver de file.ReadLine
fonction dans Go. Je peux comprendre comment en écrire rapidement un, mais je me demande simplement si j'oublie quelque chose ici. Comment lire un fichier ligne par ligne?
Réponses:
REMARQUE: la réponse acceptée était correcte dans les premières versions de Go. Voir la réponse la plus votée contient la manière idiomatique la plus récente d'y parvenir.
Il y a la fonction ReadLine dans le package bufio
.
Veuillez noter que si la ligne ne rentre pas dans le tampon de lecture, la fonction renverra une ligne incomplète. Si vous voulez toujours lire une ligne entière dans votre programme par un seul appel à une fonction, vous devrez encapsuler la ReadLine
fonction dans votre propre fonction qui appelle ReadLine
dans une boucle for.
bufio.ReadString('\n')
n'est pas entièrement équivalent à ReadLine
car ReadString
est incapable de gérer le cas lorsque la dernière ligne d'un fichier ne se termine pas par le caractère de nouvelle ligne.
Dans Go 1.1 et plus récent, le moyen le plus simple de le faire est d'utiliser a bufio.Scanner
. Voici un exemple simple qui lit les lignes d'un fichier:
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)
}
}
C'est la façon la plus propre de lire d'une Reader
ligne à l'autre.
Il y a une mise en garde: le scanner ne gère pas bien les lignes de plus de 65 536 caractères. Si c'est un problème pour vous, alors vous devriez probablement lancer le vôtre Reader.Read()
.
file, _ := os.Open("/path/to/file.csv")
puis de numériser le descripteur de fichier:scanner := bufio.NewScanner(file)
defer file.Close()
.
bufio.ErrTooLong
erreur, c'est-à-dire bufio.Scanner: token too long
si la ligne est trop longue. Dans ce cas, vous devrez utiliser bufio.ReaderLine () ou ReadString ().
Utilisation:
reader.ReadString('\n')
\n
à la fin de la chaîne retournée.reader.ReadLine()
J'ai testé les différentes solutions proposées en écrivant un programme pour tester les scénarios identifiés comme problèmes dans d'autres réponses:
Je l'ai trouvé:
Scanner
solution ne gère pas les longues lignes.ReadLine
solution est complexe à mettre en œuvre.ReadString
solution est la plus simple et fonctionne pour les longues lignes.Voici le code qui illustre 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:
Le programme de test produit:
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.
defer file.Close()
devrait être après la vérification des erreurs; sinon, en cas d'erreur, cela paniquera.
J'ai écrit un moyen de lire facilement chaque ligne d'un fichier. La fonction Readln (* bufio.Reader) renvoie une ligne (sans \ n) à partir de la structure bufio.Reader sous-jacente.
// 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
}
Vous pouvez utiliser Readln pour lire chaque ligne d'un fichier. Le code suivant lit chaque ligne d'un fichier et envoie chaque ligne à 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)
}
À votre santé!
Il existe deux façons courantes de lire le fichier ligne par ligne.
Dans mon testcase, ~ 250 Mo, ~ 2 500 000 lignes , bufio.Scanner (temps utilisé: 0,395491384s) est plus rapide que bufio.Reader.ReadString (time_used: 0,446867622s).
Code source: https://github.com/xpzouying/go-practice/tree/master/read_file_line_by_line
Lire le fichier, utilisez 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 le fichier utilise 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
exemple ne lira pas la dernière ligne d'un fichier s'il ne se termine pas par une nouvelle ligne. ReadString
retournera à la fois la dernière ligne et io.EOF
dans ce cas.
Exemple de cet essentiel
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 lorsqu'il y a une ligne plus grande que la mémoire tampon du scanner.
Lorsque cela s'est produit, ce que je fais est d'utiliser la reader := bufio.NewReader(inFile)
création et la concaténation de mon propre tampon en utilisant ch, err := reader.ReadByte()
oulen, err := reader.Read(myBuffer)
Une autre façon que j'utilise (remplacez os.Stdin par un fichier comme ci-dessus), celle-ci concatène lorsque les lignes sont longues (isPrefix) et ignore les lignes vides:
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
?
Vous pouvez également utiliser ReadString avec \ n comme séparateur:
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
}
}
bufio.Reader.ReadLine () fonctionne bien. Mais si vous souhaitez lire chaque ligne par une chaîne, essayez d'utiliser ReadString ('\ n') . Il n'a pas besoin de réinventer la roue.
// 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
}
Dans le code ci-dessous, je lis les intérêts de la CLI jusqu'à ce que l'utilisateur frappe et j'utilise 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)
J'aime la solution Lzap, je suis nouveau dans Go, j'aimerais demander à lzap mais je n'ai pas pu le faire je n'ai pas encore 50 points .. Je change un peu votre solution et complète le code ...
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
}
}
Je ne sais pas pourquoi je dois tester à nouveau 'err', mais de toute façon nous pouvons le faire. Mais, la question principale est .. pourquoi Go ne produit pas d'erreur avec la phrase => ligne, err: = r.ReadString (10), à l'intérieur de la boucle? Il est défini encore et encore à chaque exécution de la boucle. J'évite cette situation avec mon changement, un commentaire? J'ai également défini la condition EOF dans le «pour» comme pour un While. Merci
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 à laquelle ReadFromStdin()
il ressemble, fmt.Scan(&name)
mais il prend toutes les chaînes avec des espaces vides comme: "Bonjour, mon nom est ..."
var name string = ReadFromStdin()
println(name)
Une autre méthode consiste à utiliser les bibliothèques io/ioutil
et strings
pour lire l'intégralité des octets du fichier, les convertir en chaîne et les diviser en utilisant un caractère " \n
" (nouvelle ligne) comme délimiteur, par exemple:
import (
"io/ioutil"
"strings"
)
func main() {
bytesRead, _ := ioutil.ReadFile("something.txt")
file_content := string(bytesRead)
lines := strings.Split(file_content, "\n")
}
Techniquement, vous ne lisez pas le fichier ligne par ligne, mais vous pouvez analyser chaque ligne en utilisant cette technique. Cette méthode est applicable aux fichiers plus petits. Si vous essayez d'analyser un fichier volumineux, utilisez l'une des techniques de lecture ligne par ligne.