¿Cómo leer y escribir los archivos en Golang?

Golang ofrece una amplia biblioteca integrada que se puede utilizar para realizar operaciones de lectura y escritura en archivos. Para leer archivos en el sistema local, se utiliza el módulo io/ioutil . El módulo io/ioutil también se usa para escribir contenido en el archivo. 
El módulo fmt implementa E/S formateadas con funciones para leer la entrada de la entrada estándar e imprimir la salida en la salida estándar. El módulo de registro implementa un paquete de registro simple. Define un tipo, Logger, con métodos para formatear la salida. El módulo os brinda la capacidad de acceder a funciones nativas del sistema operativo. El módulo bufio implementa E/S en búfer que ayuda a mejorar el rendimiento de la CPU.
 

• os.Create() : El método os.Create() se usa para crear un archivo con el nombre deseado. Si ya existe un archivo con el mismo nombre, la función de creación trunca el archivo.
• ioutil.ReadFile() : el método ioutil.ReadFile() toma la ruta del archivo que se va a leer, ya que es el único parámetro. Este método devuelve los datos del archivo o un error.
• ioutil.WriteFile() : ioutil.WriteFile() se utiliza para escribir datos en un archivo. El método WriteFile() toma 3 parámetros diferentes, el primero es la ubicación del archivo que deseamos escribir, el segundo es el objeto de datos y el tercero es FileMode, que representa el modo del archivo y los bits de permiso.
• log.Fatalf: Fatalf hará que el programa finalice después de imprimir el mensaje de registro. Es equivalente a Printf() seguido de una llamada a os.Exit(1).
• log.Panicf: Panic es como una excepción que puede surgir en tiempo de ejecución. Panicln es equivalente a Println() seguido de una llamada a panic(). El argumento pasado a panic() se imprimirá cuando finalice el programa.
• bufio.NewReader(os.Stdin): este método devuelve un nuevo lector cuyo búfer tiene el tamaño predeterminado (4096 bytes).
• inputReader.ReadString(‘\n’) : este método se usa para leer la entrada del usuario desde stdin y lee hasta la primera aparición de delimitador en la entrada, devolviendo una string que contiene los datos hasta el delimitador incluido. Si se encuentra un error antes de encontrar un delimitador, devuelve los datos leídos antes del error y el error mismo.

Ejemplo 1: use el compilador fuera de línea para obtener mejores resultados. Guarde el archivo con la extensión .go . Use el siguiente comando para ejecutar el programa.
 

go run filename.go

// Golang program to read and write the files
package main
 
// importing the packages
import (
    "fmt"
    "io/ioutil"
    "log"
    "os"
)
 
func CreateFile() {
 
    // fmt package implements formatted
    // I/O and has functions like Printf
    // and Scanf
    fmt.Printf("Writing to a file in Go lang\n")
     
    // in case an error is thrown it is received
    // by the err variable and Fatalf method of
    // log prints the error message and stops
    // program execution
    file, err := os.Create("test.txt")
     
    if err != nil {
        log.Fatalf("failed creating file: %s", err)
    }
     
    // Defer is used for purposes of cleanup like
    // closing a running file after the file has
    // been written and main //function has
    // completed execution
    defer file.Close()
     
    // len variable captures the length
    // of the string written to the file.
    len, err := file.WriteString("Welcome to GeeksforGeeks."+
            " This program demonstrates reading and writing"+
                         " operations to a file in Go lang.")
 
    if err != nil {
        log.Fatalf("failed writing to file: %s", err)
    }
 
    // Name() method returns the name of the
    // file as presented to Create() method.
    fmt.Printf("\nFile Name: %s", file.Name())
    fmt.Printf("\nLength: %d bytes", len)
}
 
func ReadFile() {
 
    fmt.Printf("\n\nReading a file in Go lang\n")
    fileName := "test.txt"
     
    // The ioutil package contains inbuilt
    // methods like ReadFile that reads the
    // filename and returns the contents.
    data, err := ioutil.ReadFile("test.txt")
    if err != nil {
        log.Panicf("failed reading data from file: %s", err)
    }
    fmt.Printf("\nFile Name: %s", fileName)
    fmt.Printf("\nSize: %d bytes", len(data))
    fmt.Printf("\nData: %s", data)
 
}
 
// main function
func main() {
 
    CreateFile()
    ReadFile()
}

Producción:
 

Ejemplo 2: código del programa Golang que acepta la entrada del usuario para leer y escribir los archivos.
 

// Golang program to read and write the files
package main
 
// importing the requires packages
import (
    "bufio"
    "fmt"
    "io/ioutil"
    "log"
    "os"
)
 
func CreateFile(filename, text string) {
 
    // fmt package implements formatted I/O and
    // contains inbuilt methods like Printf
    // and Scanf
    fmt.Printf("Writing to a file in Go lang\n")
     
    // Creating the file using Create() method
    // with user inputted filename and err
    // variable catches any error thrown
    file, err := os.Create(filename)
     
    if err != nil {
        log.Fatalf("failed creating file: %s", err)
    }
     
    // closing the running file after the main
    // method has completed execution and
    // the writing to the file is complete
    defer file.Close()
     
    // writing data to the file using
    // WriteString() method and the
    // length of the string is stored
    // in len variable
    len, err := file.WriteString(text)
    if err != nil {
        log.Fatalf("failed writing to file: %s", err)
    }
 
    fmt.Printf("\nFile Name: %s", file.Name())
    fmt.Printf("\nLength: %d bytes", len)
}
 
func ReadFile(filename string) {
 
    fmt.Printf("\n\nReading a file in Go lang\n")
     
    // file is read using ReadFile()
    // method of ioutil package
    data, err := ioutil.ReadFile(filename)
     
    // in case of an error the error
    // statement is printed and
    // program is stopped
    if err != nil {
        log.Panicf("failed reading data from file: %s", err)
    }
    fmt.Printf("\nFile Name: %s", filename)
    fmt.Printf("\nSize: %d bytes", len(data))
    fmt.Printf("\nData: %s", data)
 
}
 
// main function
func main() {
 
    // user input for filename
    fmt.Println("Enter filename: ")
    var filename string
    fmt.Scanln(&filename)
 
    // user input for file content
    fmt.Println("Enter text: ")
    inputReader := bufio.NewReader(os.Stdin)
    input, _ := inputReader.ReadString('\n')
     
    // file is created and read
    CreateFile(filename, input)
    ReadFile(filename)
}

Producción: