File I/O in Go

When it comes to reading from or writing to files using the Go programming language, you have several options at your disposal. In this guide, we will explore different techniques for file input and output operations in Go.

Reading from a File

To read data from a file in Go, you need to follow these steps:

1. Open the file: Use the os.Open function to open the file in read-only mode.
2. Create a reader: Wrap the opened file with a bufio.NewReader object for efficient reading.
3. Read line by line: Use the ReadString('\n') method on your reader object to read each line of text from the file.
4. Close the file: Finally, close the opened file with defer f.Close().

Here's an example that demonstrates how to read from a text file named "input.txt":

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    // Step 1: Open the file
    f, err := os.Open("input.txt")
    if err != nil {
        fmt.Println(err)
        return
    }

    // Step 2: Create a reader
    r := bufio.NewReader(f)

    // Step 3: Read line by line
    for {
        line, err := r.ReadString('\n')
        if err != nil {
            break
        }

        fmt.Print(line)
    }

    // Step 4: Close the file
    defer f.Close()
}

Make sure you replace "input.txt" with your desired filename or path.

Writing to a File

If you want to write data into a new or existingfile with Go, follow these steps:

1. Create/Open an output-file using os.Create or os.OpenFile.
2. Convert the data into []byte to facilitate file writing.
3. Write the data: Use the Write or WriteString method on a file handler to write your data.
4. Close the file: Don't forget to defer closing the opened file with defer f.Close().

Below is an example that demonstrates how to write text into a new or existing file named "output.txt":

package main

import (
    "fmt"
    "os"
)

func main() {
    // Step 1: Create/Open output-file
    f, err := os.Create("output.txt")
    if err != nil {
        fmt.Println(err)
        return
    }

    // Step 2: Convert data to []byte
    data := []byte("Hello, World!")

    // Step 3: Write the data
    _, err = f.Write(data)
    if err != nil {
        fmt.Println(err)
        f.Close()
        return
    }

    fmt.Println("Data written successfully!")

    // Step 4: Close the file
    defer f.Close()
}

Remember to replace "output.txt" with your desired filename or path.

Conclusion

Working with files in Go is straightforward and efficient using its built-in functionalities for File I/O operations. You can read from files line by line or write data directly into them. The examples provided above should give you a good starting point for performing File I/O tasks in Go. Happy coding!