Lire un fichier ligne par ligne dans Go

Je n'arrive pas à trouver de file.ReadLinefonction 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?

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 ReadLinefonction dans votre propre fonction qui appelle ReadLinedans une boucle for.

bufio.ReadString('\n')n'est pas entièrement équivalent à ReadLinecar ReadStringest 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 Readerligne à 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().

Utilisation:

• reader.ReadString('\n')
  • Si cela ne vous dérange pas que la ligne puisse être très longue (c'est-à-dire utiliser beaucoup de RAM). Il conserve le \nà la fin de la chaîne retournée.
• reader.ReadLine()
  • Si vous vous souciez de limiter la consommation de RAM et ne vous occupez pas du travail supplémentaire de gestion du cas où la ligne est supérieure à la taille de la mémoire tampon du lecteur.

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:

• Un fichier avec une ligne de 4 Mo.
• Un fichier qui ne se termine pas par un saut de ligne.

Je l'ai trouvé:

• La Scannersolution ne gère pas les longues lignes.
• La ReadLinesolution est complexe à mettre en œuvre.
• La ReadStringsolution 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:

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

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.

EDIT: À partir de go1.1, la solution idiomatique est d'utiliser bufio.Scanner

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.

1. Utilisez bufio.Scanner
2. Utilisez ReadString / ReadBytes / ... dans bufio.Reader

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

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
}

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/ioutilet stringspour 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.