Bagaimana untuk menggunakan bahasa Go untuk memampatkan dan menyahmampat fail?

Dengan perkembangan teknologi komputer yang berterusan, pemprosesan fail telah menjadi bahagian penting dalam kerja harian pengguna komputer. Memandangkan jumlah storan fail terus meningkat, memampatkan fail telah menjadi operasi yang sangat diperlukan. Dalam proses ini, menggunakan bahasa Go untuk pemampatan dan penyahmampatan fail telah menjadi topik yang sangat membimbangkan.

Bahasa Go itu sendiri menyediakan perpustakaan standard yang kaya, yang termasuk fungsi alat yang berkaitan untuk memproses operasi fail. Oleh sebab itu, operasi pemampatan dan penyahmampatan fail menggunakan bahasa Go adalah sangat mudah berbanding dengan bahasa lain. Artikel ini akan memperkenalkan cara menggunakan bahasa Go untuk pemampatan dan penyahmampatan fail.

1. Pemampatan fail

Bahasa Go mempunyai dua cara untuk memampatkan fail: menggunakan pustaka standard untuk pemampatan fail dan menggunakan pustaka pihak ketiga untuk pemampatan fail.

1. Gunakan pustaka standard untuk pemampatan fail

Dalam pustaka standard Go, terdapat pakej "compress", yang mengandungi pelaksanaan format pemampatan fail biasa, termasuk gzip, gzip, bz2, lzma, zstd, dsb. Pelaksanaan format mampatan ini dibungkus dalam subpakej berbeza dalam pakej "mampat". Subpakej yang berbeza melaksanakan format pemampatan yang berbeza. Pelaksanaan khusus adalah seperti berikut:

package main

import (
    "compress/gzip"
    "fmt"
    "os"
)

func main() {
    f, err := os.Create("test.txt.gz")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer f.Close()

    gz := gzip.NewWriter(f)
    defer gz.Close()

    _, err = gz.Write([]byte("hello, world!"))
    if err != nil {
        fmt.Println(err)
        return
    }
}

Dalam kod di atas, kami mencipta fail termampat bernama "test.txt.gz" dan menulis rentetan "hello, world!" Keseluruhan proses menggunakan fungsi "NewWriter" dan fungsi "Write" dalam subpakej gzip. Perlu diingat bahawa selepas mengendalikan fail, anda perlu menggunakan kata kunci tangguh untuk menutup fail, jika tidak, pemegang fail mungkin bocor.

2. Gunakan perpustakaan pihak ketiga untuk pemampatan fail

Berbanding dengan perpustakaan standard, perpustakaan pihak ketiga menyediakan lebih banyak pelaksanaan format pemampatan fail dan lebih fleksibiliti . Pustaka pihak ketiga biasa termasuk "zip" dan "rar". Perpustakaan ini digunakan dengan cara yang sama seperti perpustakaan standard, kecuali nama pakej yang diimport adalah berbeza. Ambil pakej "zip" sebagai contoh:

package main

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

func main() {
    f, err := os.Create("test.zip")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer f.Close()

    zw := zip.NewWriter(f)
    defer zw.Close()

    files := []struct {
        name, body string
    }{
        {"test.txt", "hello, world!"},
    }

    for _, file := range files {
        w, err := zw.Create(file.name)
        if err != nil {
            fmt.Println(err)
            return
        }
        _, err = w.Write([]byte(file.body))
        if err != nil {
            fmt.Println(err)
            return
        }
    }
}

Dalam kod di atas, kami mencipta fail termampat bernama "test.zip" dan menambah fail bernama "test.txt" pada fail itu dan menulis rentetan "hello, dunia!" Proses ini dilaksanakan menggunakan fungsi "NewWriter" dan fungsi "Create" dalam pakej "zip".

2. Penyahmampatan fail

Bahasa Go menyediakan berbilang pakej yang berkaitan dengan pemampatan fail, dengan itu merealisasikan fungsi penyahmampatan fail dalam pelbagai format. Proses asas penyahmampatan ialah:

1. Buka fail yang dimampatkan.
2. Buat strim baca yang sepadan.
3. Buat penyahmampat yang sepadan.
4. Tulis data dibaca ke dalam strim kepada penyahmampat dan keluarkannya.
5. Tutup fail dan sumber lain.
6. Gunakan pustaka standard untuk penyahmampatan fail

Pakej "mampat" dalam pustaka standard melaksanakan penyahmampatan berbilang format pemampatan dan pustaka gzip sebelumnya ialah satu contoh. Dalam erti kata lain, ia bukan sahaja menyokong pemampatan fail, tetapi juga mempunyai fungsi penyahmampatan fail. Kaedah khusus adalah seperti berikut:

package main

import (
    "compress/gzip"
    "fmt"
    "io"
    "os"
)

func main() {
    f, err := os.Open("test.txt.gz")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer f.Close()

    gz, err := gzip.NewReader(f)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer gz.Close()

    data := make([]byte, 1024)
    for {
        n, err := gz.Read(data)
        if err != nil && err != io.EOF {
            fmt.Println(err)
            return
        }
        if n == 0 {
            break
        }
        fmt.Print(string(data[:n]))
    }
}

Dalam kod di atas, kami mula-mula membuka fail termampat bernama "test.txt.gz", dan kemudian gunakan fungsi "NewReader" dalam sub-pakej gzip untuk mencipta peranti nyahmampat. Fungsi "Baca" membaca data yang akan dikeluarkan dalam penyahmampat, menetapkannya kepada "data", dan mengeluarkannya melalui fungsi "fmt.Print".

2. Gunakan perpustakaan pihak ketiga untuk penyahmampatan fail

Menggunakan perpustakaan pihak ketiga untuk penyahmampatan fail adalah serupa dengan pemampatan fail Anda hanya perlu mengimport pustaka penyahmampatan yang sepadan dengannya format fail yang sepadan. Ambil pakej "zip" sebagai contoh:

package main

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

func main() {
    r, err := zip.OpenReader("test.zip")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer r.Close()

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

        _, err = io.CopyN(os.Stdout, rc, int64(f.UncompressedSize64))
        if err != nil {
            fmt.Println(err)
            return
        }
    }
}

Dalam kod di atas, kami mula-mula menggunakan fungsi "OpenReader" dalam pakej "zip" untuk membuka fail termampat bernama "test.zip" dan kemudian membaca dalam Senarai fail di dalamnya. Fungsi "Buka" mengembalikan jenis antara muka "io.ReadCloser", yang mewakili fail terbuka. Kita boleh menggunakan fungsi "Baca" jenis antara muka ini untuk membaca data yang dinyahmampat, dan kemudian mengeluarkannya terus melalui fungsi "io.CopyN".

Ringkasan

Seperti yang dapat dilihat daripada pengenalan di atas, proses menggunakan bahasa Go untuk memampatkan dan menyahmampat fail adalah sangat mudah dan boleh dilaksanakan menggunakan perpustakaan standard dan perpustakaan pihak ketiga. Sudah tentu, terdapat juga perbezaan prestasi tertentu dan perbezaan format antara fail mampat dan nyahmampat, yang memerlukan pembangun membuat pertukaran dan pilihan. Walau bagaimanapun, secara amnya, bahasa Go sangat mudah digunakan dan boleh memenuhi kebanyakan keperluan aplikasi.

Atas ialah kandungan terperinci Bagaimana untuk menggunakan bahasa Go untuk memampatkan dan menyahmampat fail?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!