Leer el archivo de texto en la matriz de cadenas (y escribir)

Creo que la capacidad de leer (y escribir) un archivo de texto dentro y fuera de una matriz de cadenas es un requisito bastante común. También es bastante útil cuando se comienza con un idioma, eliminando la necesidad de acceder inicialmente a una base de datos. ¿Existe uno en Golang?
p.ej

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

y

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

Preferiría usar uno existente en lugar de duplicarlo.

A partir de la versión Go1.1, existe una API bufio.Scanner que puede leer fácilmente las líneas de un archivo. Considere el siguiente ejemplo de arriba, reescrito 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)
    }
}

Si el archivo no es demasiado grande, esto se puede hacer con las funciones ioutil.ReadFiley strings.Splitasí:

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

Puede leer la documentación sobre paquetes ioutil y strings .

No se puede actualizar la primera respuesta.
De todos modos, después del lanzamiento de Go1, hay algunos cambios importantes, por lo que actualicé como se muestra a continuación:

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

Puede usar os.File (que implementa la interfaz io.Reader ) con el paquete bufio para eso. Sin embargo, esos paquetes se crean teniendo en cuenta el uso de memoria fijo (sin importar qué tan grande sea el archivo) y son bastante rápidos.

Desafortunadamente, esto hace que leer todo el archivo en la memoria sea un poco más complicado. Puede usar bytes.Buffer para unir las partes de la línea si exceden el límite de la línea. De todos modos, te recomiendo que pruebes a usar el lector de líneas directamente en tu proyecto (¡especialmente si no sabes qué tan grande es el archivo de texto!). Pero si el archivo es pequeño, el siguiente ejemplo puede ser suficiente para ti:

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

Otra alternativa podría ser usar io.ioutil.ReadAll para leer el archivo completo de una vez y luego hacer el corte por línea. No le doy un ejemplo explícito de cómo volver a escribir las líneas en el archivo, pero es básicamente un os.Create()ciclo seguido de un bucle similar al del ejemplo (ver 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)
    }