Leggi il file di testo nell'array di stringhe (e scrivi)

La capacità di leggere (e scrivere) un file di testo dentro e fuori un array di stringhe è credo un requisito abbastanza comune. È anche molto utile quando si inizia con una lingua che elimina la necessità iniziale di accedere a un database. Ne esiste uno a Golang?
per esempio

func ReadLines(sFileName string, iMinLines int) ([]string, bool) {

e

func WriteLines(saBuff[]string, sFilename string) (bool) { 

Preferirei usarne uno esistente piuttosto che duplicare.

A partire dalla versione Go1.1, esiste un'API bufio.Scanner che può leggere facilmente le righe da un file. Considera il seguente esempio dall'alto, riscritto con 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 string) ([]string, error) {
    file, err := os.Open(path)
    if err != nil {
        return nil, err
    }
    defer file.Close()

    var lines []string
    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 []string, path string) 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)
    }
}

Se il file non è troppo grande, questo può essere fatto con le funzioni ioutil.ReadFilee in questo strings.Splitmodo:

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

Puoi leggere la documentazione sui pacchetti ioutil e strings .

Impossibile aggiornare la prima risposta.
Ad ogni modo, dopo il rilascio di Go1, ci sono alcune modifiche sostanziali, quindi ho aggiornato come mostrato di seguito:

package main

import (
    "os"
    "bufio"
    "bytes"
    "io"
    "fmt"
    "strings"
)

// Read a whole file into the memory and store it as array of lines
func readLines(path string) (lines []string, 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.String())
            buffer.Reset()
        }
    }
    if err == io.EOF {
        err = nil
    }
    return
}

func writeLines(lines []string, path string) (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.WriteString(strings.TrimSpace(item) + "\n"); 
        //file.Write([]byte(item)); 
        if err != nil {
            //fmt.Println("debug")
            fmt.Println(err)
            break
        }
    }
    /*content := strings.Join(lines, "\n")
    _, err = writer.WriteString(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 := []string{"7.0", "8.5", "9.1"}
    err = writeLines(lines, "foo2.txt")
    fmt.Println(err)
}

Puoi usare os.File (che implementa l' interfaccia io.Reader ) con il pacchetto bufio per questo. Tuttavia, questi pacchetti sono creati tenendo conto dell'utilizzo fisso della memoria (indipendentemente dalle dimensioni del file) e sono abbastanza veloci.

Sfortunatamente questo rende la lettura dell'intero file nella memoria un po 'più complicata. È possibile utilizzare un byte.Buffer per unire le parti della linea se superano il limite della linea. Ad ogni modo, ti consiglio di provare ad utilizzare il line reader direttamente nel tuo progetto (soprattutto se non sai quanto è grande il file di testo!). Ma se il file è piccolo, il seguente esempio potrebbe essere sufficiente per te:

package main

import (
    "os"
    "bufio"
    "bytes"
    "fmt"
)

// Read a whole file into the memory and store it as array of lines
func readLines(path string) (lines []string, 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.String())
            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)
    }
}

Un'altra alternativa potrebbe essere quella di usare io.ioutil.ReadAll per leggere il file completo in una volta e fare lo slicing per riga in seguito. Non ti do un esempio esplicito di come riscrivere le righe nel file, ma è fondamentalmente os.Create()seguito da un ciclo simile a quello nell'esempio (vedi main()).

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

o

func readToDisplayUsingFile1(f *os.File){
    defer f.Close()
    slice := make([]string,0)

    reader := bufio.NewReader(f)

    for{

    str, err := reader.ReadString('\n')
    if err == io.EOF{
        break
    }

        slice = append(slice, str)
    }