Bagaimana cara membaca / menulis dari / ke file menggunakan Go?

Saya sudah mencoba belajar Go sendiri, tetapi saya bingung mencoba membaca dari dan menulis ke file biasa.

Saya bisa mendapatkan sejauh ini inFile, _ := os.Open(INFILE, 0, 0), tetapi sebenarnya mendapatkan konten file tidak masuk akal, karena fungsi baca mengambil []bytesebagai parameter.

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

Mari kita membuat daftar Go-kompatibel semua cara untuk membaca dan menulis file di Go.

Karena file API telah berubah baru-baru ini dan sebagian besar jawaban lainnya tidak berfungsi dengan Go 1. Mereka juga ketinggalan bufio IMHO yang penting.

Dalam contoh berikut ini saya menyalin file dengan membaca darinya dan menulis ke file tujuan.

Mulailah dengan dasar-dasarnya

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

Di sini saya menggunakan os.Opendan os.Createpembungkus yang nyaman di sekitar os.OpenFile. Kami biasanya tidak perlu menelepon OpenFilelangsung.

Perhatikan merawat EOF. Readmencoba untuk mengisi bufsetiap panggilan, dan kembali io.EOFsebagai kesalahan jika mencapai akhir file dalam melakukannya. Dalam hal ini bufmasih akan menyimpan data. Panggilan konsekuen untuk Readmengembalikan nol ketika jumlah byte dibaca dan sama io.EOFdengan kesalahan. Kesalahan lainnya akan menyebabkan kepanikan.

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

bufiohanya bertindak sebagai penyangga di sini, karena kami tidak memiliki banyak hubungannya dengan data. Dalam kebanyakan situasi lain (khususnya dengan file teks) bufiosangat berguna dengan memberi kami API yang bagus untuk membaca dan menulis dengan mudah dan fleksibel, sementara itu menangani buffering di belakang layar.

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

Mudah seperti pai! Tetapi gunakan hanya jika Anda yakin tidak berurusan dengan file besar.

Ini versi bagus:

package main

import (
  "io/ioutil"; 
  )


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

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

Jika Anda merasa tidak ingin menciptakan kembali roda, itu io.Copydan io.CopyNmungkin bisa membantu Anda dengan baik. Jika Anda memeriksa sumber fungsi io.Copy, itu tidak lain adalah salah satu solusi Mostafa (yang 'dasar', sebenarnya) yang dikemas dalam Go library. Mereka menggunakan buffer yang jauh lebih besar daripada dia.

Dengan versi Go yang lebih baru, membaca / menulis ke / dari file itu mudah. Untuk membaca dari file:

package main

import (
    "fmt"
    "io/ioutil"
)

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

Untuk menulis ke file:

package main

import "os"

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

    file.WriteString("test\nhello")
}

Ini akan menimpa konten file (buat file baru jika tidak ada).

[]byteadalah slice (mirip dengan substring) dari semua atau bagian dari array byte. Pikirkan slice sebagai struktur nilai dengan bidang penunjuk tersembunyi untuk sistem untuk menemukan dan mengakses semua atau bagian dari array (slice), ditambah bidang untuk panjang dan kapasitas slice, yang dapat Anda akses menggunakan len()dan cap()fungsi .

Ini kit starter yang berfungsi untuk Anda, yang membaca dan mencetak file biner; Anda perlu mengubah nilai inNameliteral untuk merujuk ke file kecil di sistem Anda.

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

Coba ini:

package main

import (
  "io"; 
  )


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

Hanya dengan melihat dokumentasi sepertinya Anda harus mendeklarasikan buffer bertipe [] byte dan meneruskannya untuk membaca yang kemudian akan membaca hingga banyak karakter dan mengembalikan jumlah karakter yang benar-benar dibaca (dan kesalahan).

Dokumen mengatakan

Baca dibaca hingga len (b) byte dari File. Ini mengembalikan jumlah byte yang dibaca dan Kesalahan, jika ada. EOF ditandai oleh hitungan nol dengan err diatur ke EOF.

Apakah itu tidak berhasil?

EDIT: Juga, saya pikir Anda mungkin harus menggunakan antarmuka Reader / Writer yang dinyatakan dalam paket bufio daripada menggunakan paket os .

Metode Read mengambil parameter byte karena itu buffer yang akan dibaca. Ini adalah Idiom yang umum di beberapa kalangan dan masuk akal ketika Anda memikirkannya.

Dengan cara ini Anda dapat menentukan berapa banyak byte yang akan dibaca oleh pembaca dan memeriksa kembali untuk melihat berapa banyak byte yang benar-benar dibaca dan menangani kesalahan dengan tepat.

Seperti yang orang lain tunjukkan dalam jawaban mereka, bufio mungkin adalah apa yang Anda inginkan untuk membaca dari sebagian besar file.

Saya akan menambahkan satu petunjuk lain karena ini sangat berguna. Membaca satu baris dari suatu file paling baik dilakukan bukan dengan metode ReadLine tetapi metode ReadBytes atau ReadString.