Wie kann ich mit Go aus einer Datei lesen / schreiben?

Ich habe versucht, Go alleine zu lernen, aber ich war ratlos beim Versuch, aus normalen Dateien zu lesen und in diese zu schreiben.

Ich kann so weit kommen inFile, _ := os.Open(INFILE, 0, 0), aber tatsächlich macht es keinen Sinn, den Inhalt der Datei zu erhalten, da die Lesefunktion a []byteals Parameter verwendet.

func (file *File) Read(b []byte) (n int, err Error)

Lassen Sie uns eine Go 1-kompatible Liste aller Möglichkeiten zum Lesen und Schreiben von Dateien in Go erstellen.

Da sich die Datei-API in letzter Zeit geändert hat und die meisten anderen Antworten mit Go 1 nicht funktionieren, fehlt ihnen auch, bufiowas meiner Meinung nach wichtig ist.

In den folgenden Beispielen kopiere ich eine Datei, indem ich daraus lese und in die Zieldatei schreibe.

Beginnen Sie mit den Grundlagen

package main

import (
    "io"
    "os"
)

func main() {
    // open input file
    fi, err := os.Open("input.txt")
    if err != nil {
        panic(err)
    }
    // close fi on exit and check for its returned error
    defer func() {
        if err := fi.Close(); err != nil {
            panic(err)
        }
    }()

    // open output file
    fo, err := os.Create("output.txt")
    if err != nil {
        panic(err)
    }
    // close fo on exit and check for its returned error
    defer func() {
        if err := fo.Close(); err != nil {
            panic(err)
        }
    }()

    // make a buffer to keep chunks that are read
    buf := make([]byte, 1024)
    for {
        // read a chunk
        n, err := fi.Read(buf)
        if err != nil && err != io.EOF {
            panic(err)
        }
        if n == 0 {
            break
        }

        // write a chunk
        if _, err := fo.Write(buf[:n]); err != nil {
            panic(err)
        }
    }
}

Hier habe ich verwendet os.Openund os.Createwelche sind praktische Wrapper herum os.OpenFile. Wir müssen normalerweise nicht OpenFiledirekt anrufen .

Beachten Sie die Behandlung von EOF. Readversucht bufbei jedem Aufruf zu füllen und gibt io.EOFals Fehler zurück, wenn dabei das Dateiende erreicht wird. In diesem Fall bufwerden weiterhin Daten gespeichert. Nachfolgende Aufrufe von geben ReadNull als Anzahl der gelesenen Bytes und io.EOFals Fehler zurück. Jeder andere Fehler führt zu einer Panik.

Verwenden von bufio

package main

import (
    "bufio"
    "io"
    "os"
)

func main() {
    // open input file
    fi, err := os.Open("input.txt")
    if err != nil {
        panic(err)
    }
    // close fi on exit and check for its returned error
    defer func() {
        if err := fi.Close(); err != nil {
            panic(err)
        }
    }()
    // make a read buffer
    r := bufio.NewReader(fi)

    // open output file
    fo, err := os.Create("output.txt")
    if err != nil {
        panic(err)
    }
    // close fo on exit and check for its returned error
    defer func() {
        if err := fo.Close(); err != nil {
            panic(err)
        }
    }()
    // make a write buffer
    w := bufio.NewWriter(fo)

    // make a buffer to keep chunks that are read
    buf := make([]byte, 1024)
    for {
        // read a chunk
        n, err := r.Read(buf)
        if err != nil && err != io.EOF {
            panic(err)
        }
        if n == 0 {
            break
        }

        // write a chunk
        if _, err := w.Write(buf[:n]); err != nil {
            panic(err)
        }
    }

    if err = w.Flush(); err != nil {
        panic(err)
    }
}

bufiofungiert hier nur als Puffer, weil wir nicht viel mit Daten zu tun haben. In den meisten anderen Situationen (insbesondere bei Textdateien) bufioist dies sehr nützlich, da wir eine schöne API zum einfachen und flexiblen Lesen und Schreiben haben, während die Pufferung hinter den Kulissen erfolgt.

Verwenden von ioutil

package main

import (
    "io/ioutil"
)

func main() {
    // read the whole file at once
    b, err := ioutil.ReadFile("input.txt")
    if err != nil {
        panic(err)
    }

    // write the whole body at once
    err = ioutil.WriteFile("output.txt", b, 0644)
    if err != nil {
        panic(err)
    }
}

Einfach wie Torte! Verwenden Sie es jedoch nur, wenn Sie sicher sind, dass Sie nicht mit großen Dateien zu tun haben.

Das ist eine gute Version:

package main

import (
  "io/ioutil"; 
  )


func main() {
  contents,_ := ioutil.ReadFile("plikTekstowy.txt")
  println(string(contents))
  ioutil.WriteFile("filename", contents, 0644)
}

Verwenden von io.Copy

package main

import (
    "io"
    "log"
    "os"
)

func main () {
    // open files r and w
    r, err := os.Open("input.txt")
    if err != nil {
        panic(err)
    }
    defer r.Close()

    w, err := os.Create("output.txt")
    if err != nil {
        panic(err)
    }
    defer w.Close()

    // do the actual work
    n, err := io.Copy(w, r)
    if err != nil {
        panic(err)
    }
    log.Printf("Copied %v bytes\n", n)
}

Wenn Sie das Rad nicht neu erfinden möchten, kann das io.Copyund io.CopyNIhnen gute Dienste leisten . Wenn Sie die Quelle der io.Copy-Funktion überprüfen , handelt es sich nur um eine der Mostafa-Lösungen (eigentlich die 'grundlegende'), die in der Go-Bibliothek enthalten sind. Sie verwenden jedoch einen wesentlich größeren Puffer als er.

Mit neueren Go-Versionen ist das Lesen / Schreiben in / aus einer Datei einfach. So lesen Sie aus einer Datei:

package main

import (
    "fmt"
    "io/ioutil"
)

func main() {
    data, err := ioutil.ReadFile("text.txt")
    if err != nil {
        return
    }
    fmt.Println(string(data))
}

So schreiben Sie in eine Datei:

package main

import "os"

func main() {
    file, err := os.Create("text.txt")
    if err != nil {
        return
    }
    defer file.Close()

    file.WriteString("test\nhello")
}

Dadurch wird der Inhalt einer Datei überschrieben (erstellen Sie eine neue Datei, wenn diese nicht vorhanden war).

[]byteist ein Slice (ähnlich einem Teilstring) eines gesamten oder eines Teils eines Byte-Arrays. Stellen Sie sich das Slice als eine Wertestruktur mit einem versteckten Zeigerfeld vor, mit dem das System ein Array (das Slice) ganz oder teilweise lokalisieren und darauf zugreifen kann, sowie Felder für die Länge und Kapazität des Slice, auf die Sie mit den Funktionen len()und zugreifen cap()können .

Hier ist ein funktionierendes Starter-Kit für Sie, das eine Binärdatei liest und druckt. Sie müssen den inNameLiteralwert ändern , um auf eine kleine Datei auf Ihrem System zu verweisen.

package main
import (
    "fmt";
    "os";
)
func main()
{
    inName := "file-rw.bin";
    inPerm :=  0666;
    inFile, inErr := os.Open(inName, os.O_RDONLY, inPerm);
    if inErr == nil {
        inBufLen := 16;
        inBuf := make([]byte, inBufLen);
        n, inErr := inFile.Read(inBuf);
        for inErr == nil {
            fmt.Println(n, inBuf[0:n]);
            n, inErr = inFile.Read(inBuf);
        }
    }
    inErr = inFile.Close();
}

Versuche dies:

package main

import (
  "io"; 
  )


func main() {
  contents,_ := io.ReadFile("filename");
  println(string(contents));
  io.WriteFile("filename", contents, 0644);
}

Wenn Sie sich nur die Dokumentation ansehen, sollten Sie einfach einen Puffer vom Typ [] byte deklarieren und an read übergeben, der dann bis zu so viele Zeichen liest und die Anzahl der tatsächlich gelesenen Zeichen (und einen Fehler) zurückgibt.

Die Dokumente sagen

Read liest bis zu len (b) Bytes aus der Datei. Es gibt die Anzahl der gelesenen Bytes und gegebenenfalls einen Fehler zurück. EOF wird durch einen Nullzähler signalisiert, wobei err auf EOF gesetzt ist.

Funktioniert das nicht

EDIT: Außerdem denke ich, dass Sie vielleicht die im bufio- Paket deklarierten Reader / Writer-Schnittstellen verwenden sollten , anstatt das os- Paket zu verwenden.

Die Read-Methode verwendet einen Byte-Parameter, da dies der Puffer ist, in den gelesen wird. In manchen Kreisen ist es eine gängige Redewendung und macht Sinn, wenn man darüber nachdenkt.

Auf diese Weise können Sie bestimmen, wie viele Bytes vom Reader gelesen werden, und die Rückgabe überprüfen, um festzustellen, wie viele Bytes tatsächlich gelesen wurden, und Fehler entsprechend behandeln.

Wie andere in ihren Antworten gezeigt haben, ist Bufio wahrscheinlich das, was Sie zum Lesen aus den meisten Dateien wünschen.

Ich werde noch einen Hinweis hinzufügen, da es wirklich nützlich ist. Das Lesen einer Zeile aus einer Datei erfolgt am besten nicht mit der ReadLine-Methode, sondern mit der ReadBytes- oder ReadString-Methode.