Ketahui fungsi pengendalian fail dalam bahasa Go dan laksanakan fungsi pemampatan, penyulitan, muat naik, muat turun dan penyahmampatan fail

Ketahui fungsi pengendalian fail dalam bahasa Go dan laksanakan fungsi pemampatan, penyulitan, muat naik, muat turun dan penyahmampatan fail

Dalam aplikasi komputer moden, pengendalian fail ialah fungsi yang sangat penting. Bagi pembangun, mempelajari dan menguasai fungsi pengendalian fail bukan sahaja dapat meningkatkan kecekapan pembangunan, tetapi juga menambah beberapa fungsi praktikal pada aplikasi. Artikel ini akan memperkenalkan cara menggunakan fungsi operasi fail dalam bahasa Go dan melaksanakan fungsi pemampatan, penyulitan, muat naik, muat turun dan penyahmampatan fail.

Pertama sekali, kita perlu memahami beberapa fungsi asas operasi fail dalam bahasa Go.

1. Buat fail

Untuk mencipta fail baharu, kita boleh menggunakan fungsi Cipta dalam pakej os.

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

2. Tulis data

Untuk menulis data dalam fail, kita boleh menggunakan kaedah Tulis objek fail.

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

3. Membaca data

Untuk membaca data daripada fail, kita boleh menggunakan kaedah Baca objek fail.

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

Untuk memadam fail, anda boleh menggunakan fungsi Remove dalam pakej os.

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

Sekarang kami telah menguasai fungsi operasi asas fail, kami boleh terus melaksanakan fungsi pemampatan, penyulitan, muat naik, muat turun dan penyahmampatan fail.

Mula-mula, mari lihat cara untuk memampatkan dan menyahmampat fail. Kita boleh menggunakan pakej arkib/zip untuk mencapai matlamat ini.

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)
        }
    }
}

Seterusnya, mari kita lihat cara menyulitkan dan menyahsulit fail. Kita boleh menggunakan pakej crypto/aes untuk mencapai matlamat ini.

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)
    }
}

Sekarang kami telah melaksanakan fungsi pemampatan, penyulitan dan penyahkodan fail, mari kita lihat cara melaksanakan muat naik dan memuat turun fail. Kita boleh menggunakan pakej net/http untuk mencapai ini.

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!")
}

Kini kami telah melaksanakan fungsi pemampatan, penyulitan, muat naik, muat turun dan penyahmampatan fail. Kita boleh menggunakan fungsi ini mengikut keperluan kita sendiri untuk mengendalikan operasi fail dan keperluan pemindahan fail. Dengan menggunakan fungsi ini bersama-sama, kami boleh membangunkan fungsi pengendalian fail yang lebih selamat dan cekap.

Ringkasan: Artikel ini memperkenalkan fungsi pengendalian fail dalam bahasa Go dan menyediakan kod contoh untuk pemampatan fail, penyulitan, muat naik, muat turun dan penyahmampatan. Dengan mempelajari dan menguasai fungsi ini, kami boleh menambah lebih banyak fungsi pengendalian fail yang praktikal dan berkuasa pada aplikasi kami. Saya harap artikel ini akan membantu anda dalam mempelajari dan menggunakan bahasa Go untuk mengendalikan operasi fail.

Atas ialah kandungan terperinci Ketahui fungsi pengendalian fail dalam bahasa Go dan laksanakan fungsi pemampatan, penyulitan, muat naik, muat turun dan penyahmampatan fail. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!