Lire un fichier texte dans un tableau de chaînes (et écrire)

La possibilité de lire (et d’écrire) un fichier texte dans et hors d’un tableau de chaînes est, à mon avis, une exigence assez courante. Il est également très utile lorsque vous commencez avec un langage supprimant le besoin initial d’accéder à une firebase database. Existe-t-il à Golang?
par exemple func ReadLines(sFileName ssortingng, iMinLines int) ([]ssortingng, bool) {
et func WriteLines(saBuff[]ssortingng, sFilename ssortingng) (bool) { .
Je préférerais utiliser un existant plutôt que de le dupliquer.

A partir de la version Go1.1, il existe une API bufio.Scanner qui peut facilement lire les lignes d’un fichier. Prenons l’exemple suivant, réécrit avec Scanner:

 package main import ( "bufio" "fmt" "log" "os" ) // readLines reads a whole file into memory // and returns a slice of its lines. func readLines(path ssortingng) ([]ssortingng, error) { file, err := os.Open(path) if err != nil { return nil, err } defer file.Close() var lines []ssortingng scanner := bufio.NewScanner(file) for scanner.Scan() { lines = append(lines, scanner.Text()) } return lines, scanner.Err() } // writeLines writes the lines to the given file. func writeLines(lines []ssortingng, path ssortingng) error { file, err := os.Create(path) if err != nil { return err } defer file.Close() w := bufio.NewWriter(file) for _, line := range lines { fmt.Fprintln(w, line) } return w.Flush() } func main() { lines, err := readLines("foo.in.txt") if err != nil { log.Fatalf("readLines: %s", err) } for i, line := range lines { fmt.Println(i, line) } if err := writeLines(lines, "foo.out.txt"); err != nil { log.Fatalf("writeLines: %s", err) } } 

Si le fichier n’est pas trop volumineux, vous pouvez le faire avec les fonctions ioutil.ReadFile et ssortingngs.Split comme ioutil.ReadFile :

 content, err := ioutil.ReadFile(filename) if err != nil { //Do something } lines := ssortingngs.Split(ssortingng(content), "\n") 

Vous pouvez lire la documentation sur les packages ioutil et chaînes .

Impossible de mettre à jour la première réponse.
Quoi qu’il en soit, après la sortie de Go1, il y a quelques changements de rupture, j’ai donc mis à jour comme indiqué ci-dessous:

 package main import ( "os" "bufio" "bytes" "io" "fmt" "ssortingngs" ) // Read a whole file into the memory and store it as array of lines func readLines(path ssortingng) (lines []ssortingng, err error) { var ( file *os.File part []byte prefix bool ) if file, err = os.Open(path); err != nil { return } defer file.Close() reader := bufio.NewReader(file) buffer := bytes.NewBuffer(make([]byte, 0)) for { if part, prefix, err = reader.ReadLine(); err != nil { break } buffer.Write(part) if !prefix { lines = append(lines, buffer.Ssortingng()) buffer.Reset() } } if err == io.EOF { err = nil } return } func writeLines(lines []ssortingng, path ssortingng) (err error) { var ( file *os.File ) if file, err = os.Create(path); err != nil { return } defer file.Close() //writer := bufio.NewWriter(file) for _,item := range lines { //fmt.Println(item) _, err := file.WriteSsortingng(ssortingngs.TrimSpace(item) + "\n"); //file.Write([]byte(item)); if err != nil { //fmt.Println("debug") fmt.Println(err) break } } /*content := ssortingngs.Join(lines, "\n") _, err = writer.WriteSsortingng(content)*/ return } func main() { lines, err := readLines("foo.txt") if err != nil { fmt.Println("Error: %s\n", err) return } for _, line := range lines { fmt.Println(line) } //array := []ssortingng{"7.0", "8.5", "9.1"} err = writeLines(lines, "foo2.txt") fmt.Println(err) } 

Vous pouvez utiliser os.File (qui implémente l’interface io.Reader ) avec le package bufio pour cela. Cependant, ces packages sont conçus avec une utilisation fixe de la mémoire (quelle que soit la taille du fichier) et sont assez rapides.

Malheureusement, cela rend la lecture de tout le fichier dans la mémoire un peu plus compliquée. Vous pouvez utiliser un octet.Buffer pour joindre les parties de la ligne si elles dépassent la limite de ligne. Quoi qu’il en soit, je vous recommande d’essayer d’utiliser le lecteur de ligne directement dans votre projet (surtout si vous ne savez pas quelle est la taille du fichier texte!). Mais si le fichier est petit, l’exemple suivant peut vous suffire:

 package main import ( "os" "bufio" "bytes" "fmt" ) // Read a whole file into the memory and store it as array of lines func readLines(path ssortingng) (lines []ssortingng, err os.Error) { var ( file *os.File part []byte prefix bool ) if file, err = os.Open(path); err != nil { return } reader := bufio.NewReader(file) buffer := bytes.NewBuffer(make([]byte, 1024)) for { if part, prefix, err = reader.ReadLine(); err != nil { break } buffer.Write(part) if !prefix { lines = append(lines, buffer.Ssortingng()) buffer.Reset() } } if err == os.EOF { err = nil } return } func main() { lines, err := readLines("foo.txt") if err != nil { fmt.Println("Error: %s\n", err) return } for _, line := range lines { fmt.Println(line) } } 

Une autre alternative pourrait être d’utiliser io.ioutil.ReadAll pour lire le fichier complet en une fois et effectuer le découpage par ligne par la suite. Je ne vous donne pas un exemple explicite de la manière d’écrire les lignes dans le fichier, mais c’est fondamentalement un os.Create() suivi d’une boucle similaire à celle de l’exemple (voir main() ).

 func readToDisplayUsingFile1(f *os.File){ defer f.Close() reader := bufio.NewReader(f) contents, _ := ioutil.ReadAll(reader) lines := ssortingngs.Split(ssortingng(contents), '\n') } 

ou

 func readToDisplayUsingFile1(f *os.File){ defer f.Close() slice := make([]ssortingng,0) reader := bufio.NewReader(f) for{ str, err := reader.ReadSsortingng('\n') if err == io.EOF{ break } slice = append(slice, str) }