Textdatei in String-Array lesen (und schreiben)

Die Fähigkeit, eine Textdatei in ein String-Array hinein und aus diesem heraus zu lesen (und zu schreiben), ist meines Erachtens eine recht häufige Anforderung. Dies ist auch sehr nützlich, wenn Sie mit einer Sprache beginnen, bei der zunächst kein Zugriff auf eine Datenbank erforderlich ist. Existiert man in Golang?
z.B

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

und

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

Ich würde es vorziehen, eine vorhandene zu verwenden, anstatt sie zu duplizieren.

Ab Go1.1 gibt es eine bufio.Scanner- API, mit der Zeilen aus einer Datei problemlos gelesen werden können. Betrachten Sie das folgende Beispiel von oben, das mit dem Scanner neu geschrieben wurde:

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

Wenn die Datei nicht zu groß ist, kann dies mit der getan werden , ioutil.ReadFileund strings.SplitFunktionen wie folgt:

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

Sie können die Dokumentation zu ioutil- und Strings- Paketen lesen .

Erste Antwort kann nicht aktualisiert werden.
Wie auch immer, nach der Veröffentlichung von Go1 gibt es einige wichtige Änderungen, daher habe ich wie folgt aktualisiert:

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

Sie können dafür os.File (das die io.Reader- Schnittstelle implementiert ) mit dem bufio- Paket verwenden. Diese Pakete werden jedoch unter Berücksichtigung der festen Speichernutzung erstellt (egal wie groß die Datei ist) und sind recht schnell.

Leider macht das Einlesen der gesamten Datei in den Speicher etwas komplizierter. Sie können einen Bytes.Buffer verwenden , um die Teile der Zeile zu verbinden, wenn sie das Zeilenlimit überschreiten. Auf jeden Fall empfehle ich Ihnen, den Zeilenleser direkt in Ihrem Projekt zu verwenden (insbesondere, wenn Sie nicht wissen, wie groß die Textdatei ist!). Wenn die Datei jedoch klein ist, kann das folgende Beispiel für Sie ausreichend sein:

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

Eine andere Alternative könnte darin bestehen, io.ioutil.ReadAll zu verwenden, um die vollständige Datei sofort einzulesen und anschließend das zeilenweise Schneiden durchzuführen . Ich gebe Ihnen kein explizites Beispiel dafür, wie Sie die Zeilen zurück in die Datei schreiben, aber im Grunde os.Create()folgt eine Schleife ähnlich der im Beispiel (siehe main()).

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

oder

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