Tek başıma öğrenmeye çalışıyorum, ama okuma çalışırken şaşkın ve sıradan dosyalar için yazıyorum.

Okuma fonksiyonu parametre olarak []byte alır çünkü bildiğim kadarıyla inFile,_ := os.Open(INFILE,0,0); ama aslında dosyanın içeriği mantıklı değil almak olarak alabilirim.

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

Hadi Gidin, dosyaları okumak ve yazmak için tüm yolları 1-Uyumlu bir listesini yapın.

Dosya API son zamanlarda değişti ve çoğu diğer cevaplara 1 ile çalışmıyor çünkü. Onlar da önemli IMHO olan bufio Bayan.

Aşağıdaki örneklerde bunu okuma ve hedef dosyaya yazarak dosyayı kopyalayın.

Temelleri ile başlar

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

Burada os.Open os.OpenFile etrafında uygun sarıcıları os.Create kullandım. Biz genelde OpenFile doğrudan çağırmak için gerek yok.

Tedavi EOF dikkat edin. Read Her arama buf doldurmak için çalışır, ve eğer bunu yaparken dosyanın sonuna ulaşırsa io.EOF olarak hata verir. Bu durumda buf hala veri tutar. Read döner ve Sos çağrı bayt ve hata olarak io.EOF okuma aynı sayısı sıfır. Başka bir hata paniğe yol açacaktır.

bufio kullanarak

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

bufio sadece veri ile ne çok şey yok çünkü bir tampon olarak burada oyunculuk. Perde arkasında tampon işleme sırasında kolayca okuma ve yazma için bize a nice API vererek en diğer durumlar (özel metin dosyaları ile) bufio çok kullanışlı ve esnek.

ioutil kullanarak

package main

import (
    "io/ioutil"
)

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

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

Çok kolay iş. Ama eğer büyük dosyaları ile ilgili olmadığına emin iseniz sadece bunu kullanın.