Learn the file operation functions in Go language and implement file compression, encryption, upload, download and decompression functions

Learn the file operation functions in Go language and implement file compression, encryption, upload, download and decompression functions

In modern computer applications, file operation is a very important function. For developers, learning and mastering file operation functions can not only improve development efficiency, but also add some practical functions to applications. This article will introduce how to use the file operation functions in the Go language and implement file compression, encryption, upload, download and decompression functions.

First of all, we need to understand some basic functions of file operations in Go language.

1. Create file

To create a new file, we can use the Create function in the os package.

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

2. Write data

To write data in a file, we can use the Write method of the file object.

data := []byte("Hello, World!")
_, err = file.Write(data)
if err != nil {
    log.Fatal(err)
}

3. Reading data

To read data from a file, we can use the Read method of the file object.

data := make([]byte, 100)
n, err := file.Read(data)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Read %d bytes: %s
", n, data[:n])

4. Delete files

To delete files, you can use the Remove function in the os package.

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

Now that we have mastered the basic file operation functions, we can continue to implement file compression, encryption, upload, download and decompression functions.

First, let’s see how to compress and decompress files. We can use the archive/zip package to achieve this.

func compressFile(filename string) {
    zipfilename := filename + ".zip"
    zipFile, err := os.Create(zipfilename)
    if err != nil {
        log.Fatal(err)
    }
    defer zipFile.Close()

    zipWriter := zip.NewWriter(zipFile)
    defer zipWriter.Close()

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

    fileInfo, err := file.Stat()
    if err != nil {
        log.Fatal(err)
    }

    header, err := zip.FileInfoHeader(fileInfo)
    if err != nil {
        log.Fatal(err)
    }

    writer, err := zipWriter.CreateHeader(header)
    if err != nil {
        log.Fatal(err)
    }

    _, err = io.Copy(writer, file)
    if err != nil {
        log.Fatal(err)
    }
}

func decompressFile(zipfilename string) {
    zipFile, err := zip.OpenReader(zipfilename)
    if err != nil {
        log.Fatal(err)
    }
    defer zipFile.Close()

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

        newFile, err := os.Create(file.Name)
        if err != nil {
            log.Fatal(err)
        }
        defer newFile.Close()

        _, err = io.Copy(newFile, rc)
        if err != nil {
            log.Fatal(err)
        }
    }
}

Next, let’s take a look at how to encrypt and decrypt files. We can use the crypto/aes package to achieve this.

func encryptFile(filename string, key []byte) {
    inputFile, err := os.Open(filename)
    if err != nil {
        log.Fatal(err)
    }
    defer inputFile.Close()

    outputFile, err := os.Create(filename + ".enc")
    if err != nil {
        log.Fatal(err)
    }
    defer outputFile.Close()

    block, err := aes.NewCipher(key)
    if err != nil {
        log.Fatal(err)
    }

    iv := make([]byte, aes.BlockSize)
    outputFile.Write(iv)

    outputFileWriter := cipher.StreamWriter{
        S: cipher.NewCTR(block, iv),
        W: outputFile,
    }

    _, err = io.Copy(outputFileWriter, inputFile)
    if err != nil {
        log.Fatal(err)
    }
}

func decryptFile(filename string, key []byte) {
    inputFile, err := os.Open(filename + ".enc")
    if err != nil {
        log.Fatal(err)
    }
    defer inputFile.Close()

    outputFile, err := os.Create(filename + ".dec")
    if err != nil {
        log.Fatal(err)
    }
    defer outputFile.Close()

    block, err := aes.NewCipher(key)
    if err != nil {
        log.Fatal(err)
    }

    iv := make([]byte, aes.BlockSize)
    inputFile.Read(iv)

    inputFileReader := cipher.StreamReader{
        S: cipher.NewCTR(block, iv),
        R: inputFile,
    }

    _, err = io.Copy(outputFile, inputFileReader)
    if err != nil {
        log.Fatal(err)
    }
}

Now that we have implemented the file compression, encryption and decoding functions, let us see how to upload and download files. We can use the net/http package to achieve this.

func uploadFile(filename string, url string) {
    file, err := os.Open(filename)
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)
    part, err := writer.CreateFormFile("file", filepath.Base(filename))
    if err != nil {
        log.Fatal(err)
    }

    _, err = io.Copy(part, file)
    if err != nil {
        log.Fatal(err)
    }

    writer.Close()

    request, err := http.NewRequest("POST", url, body)
    if err != nil {
        log.Fatal(err)
    }
    request.Header.Add("Content-Type", writer.FormDataContentType())

    client := &http.Client{}
    response, err := client.Do(request)
    if err != nil {
        log.Fatal(err)
    }
    defer response.Body.Close()

    fmt.Println("Upload OK!")
}

func downloadFile(url string, filename string) {
    response, err := http.Get(url)
    if err != nil {
        log.Fatal(err)
    }
    defer response.Body.Close()

    file, err := os.Create(filename)
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    _, err = io.Copy(file, response.Body)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Download OK!")
}

Now we have implemented the file compression, encryption, upload, download and decompression functions. We can use these functions according to our own needs to handle file operations and file transfer needs. By using these functions together, we can develop more secure and efficient file operation functions.

Summary: This article introduces the file operation functions in the Go language, and provides example codes for file compression, encryption, upload, download and decompression. By learning and mastering these functions, we can add more practical and powerful file operation functions to our applications. I hope this article will be helpful to you in learning and using Go language to handle file operations.

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