Learn the file operation functions in Go language and implement file compression and decompression functions

With the continuous development of computer technology, file processing has become a very important link in program development. In the Go language, there are many file operation functions that can meet various needs. This article will introduce the file operation functions in the Go language, and demonstrate through sample code how to use these functions to achieve file compression and decompression functions.

First of all, we need to understand some common file operation functions. In the Go language, there are mainly the following functions for file operations:

1. os.Create(name string) (*os.File, error): used Create a file. The parameter name is the name of the file to be created, and the function returns a pointer of type *os.File and a value of type error.
2. os.Open(name string) (*os.File, error): Used to open a file. The parameter name is the name of the file to be opened, and the function returns a pointer of type *os.File and a value of type error.
3. os.OpenFile(name string, flag int, perm FileMode) (*os.File, error): Used to open a file or create a file. The parameter name is the name of the file to be opened or created, flag is the flag to open the file, perm is the file permission, and the function returns a *os. A pointer of type File and a value of type error.
4. os.Remove(name string) error: Used to delete a file. The parameter name is the name of the file to be deleted, and the function returns a value of type error.
5. io.Copy(dst Writer, src Reader) (written int64, err error): Used to copy data of type Reader to a Writer type data. Parameter dst is the target Writer, src is the source Reader, the function returns the number of bytes copied and an errorType value.

After understanding these file operation functions, we can start to implement file compression and decompression functions. First, we need to introduce the archive/zip package and the archive/tar package, which are used to process files in zip format and tar format respectively.

The following is a sample code that implements the file compression function:

package main

import (
    "archive/zip"
    "io"
    "os"
)

func zipFiles(filename string, files []string) error {
    zipfile, err := os.Create(filename)
    if err != nil {
        return err
    }
    defer zipfile.Close()

    zipwriter := zip.NewWriter(zipfile)
    defer zipwriter.Close()

    for _, file := range files {
        src, err := os.Open(file)
        if err != nil {
            return err
        }
        defer src.Close()

        dst, err := zipwriter.Create(file)
        if err != nil {
            return err
        }

        _, err = io.Copy(dst, src)
        if err != nil {
            return err
        }
    }

    return nil
}

func main() {
    files := []string{"file1.txt", "file2.txt", "file3.txt"}
    filename := "archive.zip"
    err := zipFiles(filename, files)
    if err != nil {
        panic(err)
    }
}

The above code implements the function of compressing multiple files into a zip format file. First, we create a *os.File type pointer zipfile for creating compressed files. Then, we create a *zip.Writer type pointer zipwriter through zip.NewWriter(zipfile), which is used to write data to the compressed file. Next, we traverse the list of files to be compressed, open each file in turn, create a file with the same name as the source file through zipwriter.Create(file), and copy the data to the file. Finally, we close zipwriter and zipfile.

The following is a sample code to implement the file decompression function:

package main

import (
    "archive/zip"
    "io"
    "os"
)

func unzipFiles(filename string, dest string) error {
    r, err := zip.OpenReader(filename)
    if err != nil {
        return err
    }
    defer r.Close()

    for _, file := range r.File {
        rc, err := file.Open()
        if err != nil {
            return err
        }
        defer rc.Close()

        path := filepath.Join(dest, file.Name)
        if file.FileInfo().IsDir() {
            os.MkdirAll(path, file.Mode())
        } else {
            f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, file.Mode())
            if err != nil {
                return err
            }
            defer f.Close()

            _, err = io.Copy(f, rc)
            if err != nil {
                return err
            }
        }
    }

    return nil
}

func main() {
    filename := "archive.zip"
    dest := "./"
    err := unzipFiles(filename, dest)
    if err != nil {
        panic(err)
    }
}

The above code implements the function of decompressing a zip format file. First, we open the file to be decompressed through zip.OpenReader(filename) and create a *zip.ReadCloser type pointer r for reading the file content . Then, we iterate through each file in the compressed file and determine whether it is a directory or a file based on the file information. If it is a directory, create the corresponding directory; if it is a file, create a file with the same name as the source file and copy the data to the file.

The above is a code example that implements file compression and decompression functions through the file operation functions in the Go language. Through these sample codes, we can learn how to use the file operation functions provided by the Go language to process files to achieve more functions.

The above is the detailed content of Learn the file operation functions in Go language and implement file compression and decompression functions. For more information, please follow other related articles on the PHP Chinese website!