¿Cómo leer / escribir desde / a un archivo usando Go?

He estado tratando de aprender Ir por mi cuenta, pero me ha sorprendido intentar leer y escribir en archivos normales.

Puedo llegar tan lejos inFile, _ := os.Open(INFILE, 0, 0), pero en realidad obtener el contenido del archivo no tiene sentido, porque la función de lectura toma []byteun parámetro.

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

Hagamos una lista compatible con Go 1 de todas las formas de leer y escribir archivos en Go.

Debido a que la API de archivo ha cambiado recientemente y la mayoría de las otras respuestas no funcionan con Go 1. También omiten lo bufioque es importante en mi humilde opinión.

En los siguientes ejemplos, copio un archivo leyéndolo y escribiendo en el archivo de destino.

Comience con lo básico

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

Aquí utilicé os.Openy os.Createque son envoltorios convenientes alrededor os.OpenFile. Por lo general, no necesitamos llamar OpenFiledirectamente.

Aviso de tratamiento de EOF. Readintenta completar bufcada llamada y devuelve un io.EOFerror si llega al final del archivo al hacerlo. En este caso bufaún se conservarán los datos. Las llamadas consiguientes a Readdevuelve cero como el número de bytes leídos e igual io.EOFque el error. Cualquier otro error provocará pánico.

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

bufiosolo está actuando como un búfer aquí, porque no tenemos mucho que ver con los datos. En la mayoría de las otras situaciones (especialmente con archivos de texto) bufioes muy útil al proporcionarnos una buena API para leer y escribir de manera fácil y flexible, mientras maneja el almacenamiento en búfer detrás de escena.

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

¡Muy fácil! Pero úselo solo si está seguro de que no está tratando con archivos grandes.

Esta es una buena versión:

package main

import (
  "io/ioutil"; 
  )


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

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

Si no tiene ganas de reinventar la rueda, el io.Copyy io.CopyNpuede servir bien. Si verifica el origen de la función io.Copy, no es más que una de las soluciones de Mostafa (la 'básica', en realidad) empaquetada en la biblioteca Go. Sin embargo, están usando un buffer significativamente más grande que él.

Con las versiones más nuevas de Go, leer / escribir en / desde el archivo es fácil. Para leer de un archivo:

package main

import (
    "fmt"
    "io/ioutil"
)

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

Para escribir en un archivo:

package main

import "os"

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

    file.WriteString("test\nhello")
}

Esto sobrescribirá el contenido de un archivo (cree un nuevo archivo si no estaba allí).

[]bytees un segmento (similar a una subcadena) de todo o parte de una matriz de bytes. Piense en el segmento como una estructura de valores con un campo de puntero oculto para que el sistema ubique y acceda a todo o parte de una matriz (el segmento), más campos para la longitud y la capacidad del segmento, a los que puede acceder utilizando las funciones len()y cap().

Aquí hay un kit de inicio que funciona para usted, que lee e imprime un archivo binario; necesitará cambiar el inNamevalor literal para referirse a un pequeño archivo en su sistema.

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

Prueba esto:

package main

import (
  "io"; 
  )


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

Simplemente mirando la documentación, parece que debería declarar un búfer de tipo [] byte y pasarlo a leer que luego leerá hasta tantos caracteres y devolverá el número de caracteres realmente leídos (y un error).

Los documentos dicen

Lecturas de lectura hasta len (b) bytes del archivo. Devuelve el número de bytes leídos y un error, si lo hay. EOF se señala mediante un conteo cero con err establecido en EOF.

¿Eso no funciona?

EDITAR: Además, creo que quizás debería usar las interfaces Reader / Writer declaradas en el paquete bufio en lugar de usar el paquete os .

El método de lectura toma un parámetro de byte porque es el búfer en el que leerá. Es un idioma común en algunos círculos y tiene sentido cuando lo piensas.

De esta manera, puede determinar cuántos bytes leerá el lector e inspeccionar el retorno para ver cuántos bytes se leyeron realmente y manejar los errores de manera adecuada.

Como otros han señalado en sus respuestas, bufio es probablemente lo que desea leer de la mayoría de los archivos.

Agregaré otra pista ya que es realmente útil. La mejor forma de leer una línea de un archivo no es mediante el método ReadLine, sino el método ReadBytes o ReadString.