File processing and IO operation skills in Go language

As a popular programming language in recent years, Go language has powerful functions and excellent performance in file processing and IO operations. File processing and IO operations are important means of interaction between developers and computers, and are also basic skills necessary for developing high-quality programs. This article will introduce some commonly used file processing and IO operation techniques in the Go language to help readers quickly master relevant knowledge.

1. File processing

1. Opening files

Opening files in Go language is implemented through the Open function of the os package:

func Open(name string) (*File, error)

This function returns a file object and an error object. The file object is an interface type with read and write methods. It has three methods: Read, Write and Close. The error object is an error type interface that represents the error message that occurred.

Sample code:

file, err := os.Open("test.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

The above code can open a file named test.txt and automatically close the file after the file processing is completed.

2. Read the file content

Reading the file content is achieved by reading the file object. To read the file content, you can use the Read and ReadAt methods of the file object. Read reads the file contents sequentially and returns the number of bytes read. When the end of the file is read, an io.EOF error is returned. ReadAt starts reading the file content at the specified offset. The file can be read out of order and the number of bytes read is returned.

Sample code:

package main

import (
    "fmt"
    "io/ioutil"
    "log"
)

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

With the above code, you can use the ioutil package to read the file content.

3. Writing file content

Writing file content is also implemented through the file object. The Write and WriteAt methods of the file object can write sequentially and according to the offset respectively. Write, these output functions will return the number of bytes written.

Sample code:

package main

import (
    "log"
    "os"
)

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

    file.Write([]byte("Hello, world"))
}

The above code can create a test.txt file and write "Hello, World" into it.

4. Delete files

Files can be deleted through the os package of Go language. The way to delete files is to use the Remove function and take the file name as a parameter.

Sample code:

package main

import (
    "log"
    "os"
)

func main() {
    err := os.Remove("test.txt")
    if err != nil {
        log.Fatal(err)
    }
}

The file named test.txt can be deleted through the above code.

2. IO operation skills

1. Operation standard input and output streams

In Go language, use the standard input and output streams (stdin, stdout) in the os package and stderr), you can use the standard input and output method of the os package to operate them. The method is as follows:

os.Stdin         // 标准输入
os.Stdout        // 标准输出
os.Stderr        // 标准错误输出

Sample code:

package main

import (
    "fmt"
    "os"
)

func main() {
    fmt.Fprintln(os.Stdout, "Hello, world")
    fmt.Fprintln(os.Stderr, "This is an error")
}

Through the above code, you can output to standard output and standard error respectively. Output a piece of text.

2. String input and output stream

In the Go language, there is a type called bytes.Buffer, which can be used to save strings and provide input for them Output Interface. Through the bytes.Buffer type, we can convert the input and output streams into byte stream processing to process the input and output of strings.

Sample code:

package main

import (
    "bytes"
    "fmt"
)

func main() {
    buf := bytes.NewBufferString("Hello, world")
    fmt.Println(buf.String())
}

Through the above code, we "write" a sentence in buf, and then use the String() method to output it, which can be viewed on the console The string "Hello, world" is reached.

3. Read the input stream into a byte array

The io/ioutil package in the Go language can easily perform data reading and writing operations. Among them, the ioutil package in the ReadAll reads the input stream into a byte array and returns it.

Sample code:

package main

import (
    "fmt"
    "io/ioutil"
)

func main() {
    data, err := ioutil.ReadAll(os.Stdin)
    if err != nil {
        fmt.Println("ERROR reading STDIN: ", err)
        return
    }
    fmt.Println("STDIN = ", string(data))
}

The above code can read the standard input stream into data and print it out.

This article describes some common file processing and IO operation techniques in Go language, such as opening, reading, writing and deleting files, as well as operating standard input and output streams, string input and output streams and reading input Streaming to byte array medium trick. These techniques are very useful for developing high-quality programs, and readers can get rid of troubles and improve work efficiency according to their own needs.

The above is the detailed content of File processing and IO operation skills in Go language. For more information, please follow other related articles on the PHP Chinese website!