Go Basic: Understanding Reading Files, Writing Files, Line Filters in Go

Let’s dive into the exciting world of Reading Files, Writing Files, Line Filters in Go. Working with file operations.

full lessons here👇:
https://programmerscareer.com/golang-basic-skill/

Generated by AI, there may be errors, for reference only

Topic: 1.1 Introduction to File Operations in Go.

Go is known for its simplicity and efficiency, and these qualities extend to how it handles file operations. Go has several packages, such as the “os” package, that offer robust functionalities for performing various file operations. These operations include file creation, reading and writing files, and many more. It’s important to note that these operations generally require proper error handling to manage potential issues.

Go is an excellent language for working with files because of its strong support for handling input/output operations, which is critical in file manipulation tasks.

For instance, let’s take a look at how you might open a file in Go:

package main  
  
import (  
    "fmt"  
    "log"  
    "os"  
)  
  
func main() {  
    file, err := os.Open("test.txt")  
    if err != nil {  
        log.Fatal(err)  
    }  
    fmt.Println("Success! The file was opened.")  
}

In this example, we’re trying to open a file called “test.txt”. The os.Openfunction tries to open the file and return two values: a pointer to the file and an error variable. We then check if there was an error while opening the file. If an error exists, we use ‘log.Fatal’ to output the error message and stop the program.

You can see how straightforward it is to open a file in Go, and how easy it is to handle any errors that may occur along the way. This exemplifies the vibe of Go: a language that is easy to read, write, and understand.

Topic: 1.2 Reading Files in Golang

Reading files in Go is straightforward thanks to the built-in os and ioutilpackage. Here are a few ways you can read files in Go.

1. ioutil.ReadFile: This is a simple method to read an entire file at once. It requires the least amount of code, making it the simplest to implement.

content, err := ioutil.ReadFile("test.txt")  
if err != nil {  
    log.Fatal(err)  
}  
  
fmt.Printf("File contents: %s", content)

1. os.File.Read: This method allows you to control how much of the file you’d like to read at a time, which can be useful for larger files.

file, err := os.Open("test.txt")  
if err != nil {  
    log.Fatal(err)  
}  
  
data := make([]byte, 64)  
  
for {  
    _, err := file.Read(data)  
  
    if err != nil {  
        if err == io.EOF {  
            break  
        }  
        fmt.Println(err)  
        os.Exit(1)  
    }  
}  
file.Close()

1. bufio.Scanner: This method is probably the most common way to read in a file line by line, which is a very common operation.

scanner := bufio.NewScanner(file)  
for scanner.Scan() {  
    fmt.Println(scanner.Text())  
}

Each of these methods has its use cases and are commonly used in Golang to perform file reading operations.

Topic: 1.3 Writing to Files in Golang.

Just like reading files, Go provides multiple ways to write to a file. Let’s discuss some of them.

1. os.Create and os.File.WriteString: This is a simple method to write a string to a file. If the file doesn’t exist, it is created, and if it does, it is truncated.

file, err := os.Create("test.txt")  
if err != nil {  
    log.Fatal(err)  
}  
file.WriteString("This is a new line of text \n")  
file.Close()

1. ioutil.WriteFile: This method is useful when you need to write similar strings to a file. Typically, you would create the file, write to it, and then close it immediately after.

content := []byte("This is line one.\nThis is line two.\nThis is line three.\n")  
err := ioutil.WriteFile("test.txt", content, 0644)

1. bufio.Writer: Similar to bufio.Scanner which helps in reading files line by line, bufio.Writer allows you to write to files with a buffer, which can be beneficial if you are writing large amounts of data.

writer := bufio.NewWriter(file)  
writer.WriteString("Buffered writer test line one\n")  
writer.Flush()

In each of these examples, error checking plays an important role. We need to check whether the functions returned any errors, which is a common paradigm in Go.

Topic: 1.4 Error Handling While Working With Files.

Working with files inevitably means working with errors. Files might be missing, they might fail to open for various reasons, we might lack permissions to write to a file, and the list goes on. Therefore, having a robust understanding of error handling is crucial when performing file operations.

In Go, errors are values and can be treated like any other types. Errors are returned by functions and methods, and it’s common practice to always inspect the error returned by a function.

Here’s an example of how we handle errors when opening a file:

file, err := os.Open("non_existent_file.txt")  
if err != nil {  
    log.Fatalf("failed opening file: %s", err)  
}  
defer file.Close()

In this code, if the file “non_existent_file.txt” does not exist, os.Open will return an error which we are capturing and printing it in a readable format.

And also remember, the use of the defer keyword. defer is used for ensuring that a function call is performed later in a program’s execution. Here, we are making sure that after opening the file, at any point in time if our function is about to exit, the file will be closed.

Furthermore, Go provides a os.IsNotExist() function in the os package. This function can take an error type and will return a boolean indicating if an error was of type ‘file does not exist’, which can sometimes be particularly useful.

And, there’s os.IsPermission(), a function to indicate whether an error is because the process does not have permission to access a file.

Remember to always check and handle errors when dealing with file operations.

Topic: 1.5 Introduction to Line Filters.

Line filters are a common type of program in UNIX. They read data from standard input, process it, then send something to standard output.

In Go, this can easily be set up with the os.Stdin and bufio package. Here’s an example of a simple line filter:

scanner := bufio.NewScanner(os.Stdin)  
for scanner.Scan() {  
    ucl := strings.ToUpper(scanner.Text())  
    fmt.Println(ucl)  
}  
if err := scanner.Err(); err != nil {  
    fmt.Fprintln(os.Stderr, "error:", err)  
    os.Exit(1)  
}

This program converts standard input to uppercase. We create a new Scanner (we introduced this in previous lessons), which will default to scanning standard input.

We use a loop to Scan(), which gives us our line-by-line text input. For each line that is scanned, we convert it to uppercase with strings.ToUpper and print that out. fmt.Println will automatically append a newline (\n).

If there are any errors during scanning, we capture them and print them to os.Stderr, then exit the program with a status code of 1.

To test it, try running this program and feed it some input, and see the program output it back in all uppercase.

Topic: 1.6 Building Line Filters in Golang

Fantastic, let’s delve further into how we can build robust line filters in Go utilizing the bufio package to dissect and process each line individually.

Line filters are essentially programs that read data from standard input line by line, process it in some manner, and then print some data out.

Let’s write a line filter that converts its input to lowercase. Go provides convenient functions for converting an entire string to lower or upper case in its strings package.

Once we set up the scanner, the code follows the pattern in the line filter program we built.

Here’s an example of a line filter that converts the text to lowercase:

package main  

import (  
    "bufio"  
    "fmt"  
    "os"  
    "strings"  
)  
func main() {  
    scanner := bufio.NewScanner(os.Stdin)  
    for scanner.Scan() {  
        line := strings.ToLower(scanner.Text())  
        fmt.Println(line)  
    }  
    if err := scanner.Err(); err != nil {  
        fmt.Fprintln(os.Stderr, "error:", err)  
        os.Exit(1)  
    }  
}

This line filter reads data from standard input, makes the conversion to lowercase, and then spits it out to standard output.

Run it, and notice that it will transform all input text from standard input to lowercase. Try typing in some text!

Remember, Go’s bufio package equips you with all the tools necessary for creating powerful, robust line filters that can handle data efficiently by reading and writing it line by line.

Topic: 1.7 Practical Exercises

that pertain to reading, writing, and processing files in Go.

Exercise 1: Reading a text file and printing its contents line by line.

In this particular scenario, the job is to read from test.txt and print its contents. It should be simple if you’ve grasped the simpler examples.

Exercise 2: Converting text file content to uppercase.

Let’s put the concept of line filters into practice. For this exercise, use your line filter to read the contents from test.txt and convert it to uppercase.

Exercise 3: Writing to a file.

Create a book directory. You are to write the names of your favorite books to a favorites.txt file. You should try to put each book on a new line.

Exercise 4: Reading and writing CSV files.

Here you’ll dive deeper into file operations by working with CSV files. The job is to read from a CSV file, process the data (you might convert the data to uppercase), and write it to a new CSV file.

Bonus Exercise: Creating a simple logging tool.

Create a simple logging tool that writes logs to a file. Each log should be on a new line and include details about the error and the timestamp of when the error occurred.

Take your time to complete these exercises. If you hit any roadblocks, don’t hesitate to ask questions. I’m here to help 🦌! And remember, practice is key to enhancing your file operations skills in Go.

Topic：1.8 Review and Assessments.

This part is designed to revisit the key topics that we’ve covered and solidify your understanding.

Review Topics:

We talked about file operations like reading and writing to files, then we discussed line filters in Go using bufio package which allows us to process data line by line from standard input and output it to standard output.

The assessments will be based on these topics and will help validate how well you have grasped the concepts.

Assessment:

Theory Questions:

1. a) What is a line filter and when is it useful?
2. b) Which Go package helps us create line filters and what functions do we use from it?
3. c) How can you handle errors during file operations in Go?

Practical Questions:

1. a) Write a line filter that translates input text into Pig Latin.
2. b) Write a Go program that takes a CSV file, reads the data, and then writes it to a new CSV file in reverse order.
3. c) Write a Go program that reads a text file and counts how many times each word appears in the text file.

I encourage you to take your time to go through these questions.

中文文章: https://programmerscareer.com/zh-cn/go-basic-08/
Author: Wesley Wei – Twitter Wesley Wei – Medium
Note: If you choose to repost or use this article, please cite the original source.

Medium

LinkedIn

Wechat(微信公众号)

X