Как читать / писать из / в файл с помощью Go?

Я пытался изучать Go самостоятельно, но я был в тупике, пытаясь читать и записывать в обычные файлы.

Я могу так далеко inFile, _ := os.Open(INFILE, 0, 0), но на самом деле получить содержимое файла не имеет смысла, потому что функция чтения принимает []byteв качестве параметра.

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

Давайте создадим Go 1-совместимый список всех способов чтения и записи файлов в Go.

Поскольку файловый API недавно изменился, и большинство других ответов не работают с Go 1. Они также пропускают, bufioчто важно, ИМХО.

В следующих примерах я копирую файл, читая его и записывая в файл назначения.

Начните с основ

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

Здесь я использовал os.Openи os.Createкоторые являются удобными обертками вокруг os.OpenFile. Нам обычно не нужно звонить OpenFileнапрямую.

Обратите внимание на лечение EOF. Readпытается заполнить bufкаждый вызов и возвращает io.EOFкак ошибку, если при этом он достигает конца файла. В этом случае bufвсе равно будут храниться данные. Последующие вызовы Readвозвращают ноль как количество прочитанных байтов и io.EOFкак ошибку. Любая другая ошибка приведет к панике.

С помощью 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)
    }
}

bufioпросто выступает в качестве буфера здесь, потому что мы не имеем ничего общего с данными. В большинстве других ситуаций (особенно с текстовыми файлами) bufioэто очень полезно, предоставляя нам хороший API для простого и гибкого чтения и записи, в то время как он обрабатывает буферизацию за кулисами.

С помощью 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)
    }
}

Проще простого! Но используйте его, только если вы уверены, что не имеете дело с большими файлами.

Это хорошая версия:

package main

import (
  "io/ioutil"; 
  )


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

С помощью 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)
}

Если вы не хотите изобретать велосипед, то io.Copyи io.CopyNможет служить вам хорошо. Если вы проверите источник функции io.Copy, это не что иное, как одно из решений Mostafa (собственно, «базовое»), упакованное в библиотеку Go. Они используют значительно больший буфер, чем он.

В новых версиях Go чтение / запись в / из файла становится проще. Чтобы прочитать из файла:

package main

import (
    "fmt"
    "io/ioutil"
)

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

Для записи в файл:

package main

import "os"

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

    file.WriteString("test\nhello")
}

Это перезапишет содержимое файла (создайте новый файл, если его там не было).

[]byteявляется срезом (похожим на подстроку) всего или части байтового массива. Думайте о срезе как о структуре значений со скрытым полем указателя, чтобы система могла найти и получить доступ ко всему или части массива (среза), а также к полям для длины и емкости среза, к которым вы можете получить доступ, используя len()иcap() функции ,

Вот вам рабочий стартовый комплект, который читает и печатает двоичный файл; вам нужно изменить inNameбуквальное значение, чтобы ссылаться на небольшой файл в вашей системе.

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

Попробуй это:

package main

import (
  "io"; 
  )


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

Просто просматривая документацию, кажется, что вы должны просто объявить буфер типа [] byte и передать его для чтения, который затем прочитает до такого количества символов и вернет количество фактически прочитанных символов (и ошибку).

Документы говорят

Read читает до len (b) байтов из файла. Он возвращает количество прочитанных байтов и ошибку, если таковая имеется. EOF сигнализируется нулевым счетом с ошибкой, установленной в EOF.

Это не работает?

РЕДАКТИРОВАТЬ: Кроме того, я думаю, что вы, возможно, следует использовать интерфейсы Reader / Writer, объявленные в пакете bufio , вместо использования пакета os .

Метод Read принимает параметр байта, потому что это буфер, в который он будет читать. Это распространенная идиома в некоторых кругах, и она имеет смысл, когда вы думаете об этом.

Таким образом, вы можете определить, сколько байтов будет прочитано читателем, и просмотреть возвращаемый результат, чтобы увидеть, сколько фактически было прочитано байтов, и соответствующим образом обработать любые ошибки.

Как указали другие в своих ответах, bufio - это, вероятно, то, что вы хотите прочитать из большинства файлов.

Я добавлю еще одну подсказку, поскольку она действительно полезна. Чтение строки из файла лучше всего выполнять не методом ReadLine, а методом ReadBytes или ReadString.