Az Önhöz hasonló olvasók támogatják a MUO-t. Amikor a webhelyünkön található linkek használatával vásárol, társult jutalékot kaphatunk. Olvass tovább.

Az archívumok több fájlt egyesítenek egyetlen formátumba, általában zip, tar vagy rar formátumba. Az archív fájlok tömörítést is alkalmazhatnak a teljes fájlméret csökkentése érdekében.

Az archívumok segítségével szoftvereket és adatokat terjeszthet, beleértve a weboldalakat is. Archiválhatja az alkalmazást az összes fájljával és függőségével együtt, hogy a felhasználók letölthessék és telepítsék.

A Go archívumcsomagja lehetővé teszi archívumok létrehozását és kibontását tar és zip formátumban.

Go archívumcsomagja

Go biztosít archívum csomagok különféle archív formátumokkal való munkához. Használhatja a postai irányítószám és kátrány csomagok az ilyen formátumú archív fájlok létrehozásához, olvasásához és írásához. Mindkét csomag különböző tömörítési algoritmusokat támogat egy könnyen használható API-n keresztül.

A következőképpen importálhatja a zip és tar csomagokat a Go fájlokban:

instagram viewer 
import (
"archívum/zip"
"archívum/tar"
)

A csomagok importálása után használhatja őket archív fájlok létrehozására és kezelésére.

Fájlok létrehozása és hozzáadása Tar archívumokhoz

A kátrány csomag tartal működik tar és tar.gz formátumok archívuma, beleértve a fájlok olvasásának és írásának támogatását a PAX kiterjesztett fejlécekkel.

A tar csomag biztosítja a NewWriter funkció új tar archívum létrehozásához. A NewWriter bevesz egy io. Író interfész példány, amely lehet egy fájl vagy memóriapuffer, és egy mutatót ad vissza a kátrány. Író struct.

csomag fő-
import (
"archívum/tar"
"os"
)


funcfő-() {
// Hozzon létre egy új fájlt
 fájl, _ := os. Teremt("myarchive.tar")
elhalasztja fájlt. Bezárás()
// Új tar archívum létrehozása
 tarWriter := tar. NewWriter (fájl)
elhalasztja tarWriter. Bezárás()
}

A Teremt funkciója os csomag létrehoz egy új tar fájlt. A kátrány. NewWriter függvény bevesz egy fájlt, és új archívumot hoz létre.

Fájlokat adhat hozzá a tar archívumhoz a WriteHeader és Ír funkciókat. A WriteHeader függvény a kátrány. Fejléc struktúra érvként. Ez tartalmazza a fájl metaadatait, például a fájl nevét, méretét és engedélybiteket. Az Írás funkció a fájl tartalmát az archívumba írja.

import (
"archívum/tar"
"fmt"
"io"
"napló"
"os"
)
funcfő-() {
// Hozzon létre egy új fájlt
 fájl, _ := os. Teremt("myarchive.tar")
 fájl, _ = os. Teremt("üzenet.txt")
elhalasztja fájlt. Bezárás()


// Új tar archívum létrehozása
 tarWriter := tar. NewWriter (fájl)
elhalasztja tarWriter. Bezárás()
// Fájl hozzáadása az archívumhoz
 fileToAdd, _ := os. Nyisd ki("fájl1.txt")
elhalasztja fileToAdd. Bezárás()
 fileInfo, _ := fileToAdd. Statisztika()
 fejléc, _ := tar. FileInfoHeader (fileInfo, "")
 tarWriter. WriteHeader (fejléc)
 _, _ = io. Másolás (tarWriter, fileToAdd)
 fmt. Println("A TAR archiválási művelet befejeződött")
}

A program új tar és szöveges fájlokat hoz létre a Teremt funkciója os csomagot és egy új tar archívumot a NewWriter, mielőtt hozzáadná a fájlt az archívumhoz.

A Nyisd ki funkció megnyitja az archívumhoz hozzáadandó fájlt. Ne feledje, hogy szüksége lesz egy nevű fájlra fájl1.txt munkakönyvtárában a program sikeres futtatásához.

Használhatja a statisztika egy fájlpéldány függvénye a tar fejléchez szükséges metaadatok lekéréséhez. Adja át annak eredményét FileInfoHeader, majd adja át az eredményt a WriteHeader funkciót a tar fájl beállításához. Végül másolja a fájlt az archívumba a segítségével io. Másolat.

Fájlok kibontása a Tar Archívumból

Használhatja a NewReader függvényt a tar archívum fájl tartalmának olvasásához. A NewReader funkció egy io. Olvasó interfész, amely lehet fájl vagy memóriapuffer. Egy mutatót ad vissza a kátrány. Olvasó struct.

import (
"archívum/tar"
"io"
"os"
)
funcfő-() {
// Nyissa meg a tar archívumot
 fájl, _ := os. Nyisd ki("myarchive.tar")
elhalasztja fájlt. Bezárás()


// Hozzon létre egy új tar olvasót
 tarReader := tar. NewReader (fájl)


// Iteráció az archívumban lévő fájlok felett
számára {
 fejléc, err := tarReader. Következő()


ha err == io. EOF {
szünet
 }
// Bontsa ki a fájlt
 outFile, _ := os. Létrehozása (fejléc. Név)
elhalasztja outFile. Bezárás()
 _, _ = io. Másolás (outFile, tarReader)
 }
}

A végtelen ciklushoz bejárja a tar olvasó példányt, és kibontja a fájlokat úgy, hogy az egyes fájlokat a io csomagok Másolat funkció.

Fájlok létrehozása és hozzáadása Zip archívumokhoz

Új zip-archívumot hozhat létre a NewWriter funkciója postai irányítószám csomag. A NewWriter függvény egy fájlpéldányt vesz fel, és egy zip-írót ad vissza.

import (
"archívum/zip"
"os"
)
funcfő-() {
// Hozzon létre egy új fájlt
 fájl, err := os. Teremt("archive.zip")


ha hiba! = nulla {
pánik(téved)
 }


elhalasztja fájlt. Bezárás()
// Hozzon létre egy új zip-írót
 zipWriter := zip. NewWriter (fájl)
elhalasztja zipWriter. Bezárás()
}

A zipWriter változó egy újat tárol Író példa, amelyet a NewWriter visszaad.

Fájlokat adhat hozzá zip-archívumához a Teremt a Writer példány funkciója. A Create funkció beveszi a fájl nevét. Használhatja továbbá a Ír a zip fájlpéldány funkciója, amellyel adatokat írhat a zip archívumokban lévő fájlokba.

import (
"archívum/zip"
"os"
)
funcfő-() {
// Új fájlok létrehozása
 fájl, err := os. Teremt("archive.zip")
 fájl, err = os. Teremt("fájl1.txt")
 fájl, err = os. Teremt("fájl2.txt")


ha hiba! = nulla {
pánik(téved)
 }


elhalasztja fájlt. Bezárás()


// Hozzon létre egy új zip-írót
 zipWriter := zip. NewWriter (fájl)
elhalasztja zipWriter. Bezárás()


// Fájlok hozzáadása az archívumhoz
 file1, err := zipWriter. Teremt("fájl1.txt")


ha hiba! = nulla {
pánik(téved)
 }


 file2, err := zipWriter. Teremt("fájl2.txt")


ha hiba! = nulla {
pánik(téved)
 }
// Adatok írása az archívum fájljaiba
 file1.Write([]byte("Helló Világ!"))
 file2.Write([]byte("Viszlát világ!"))
 fmt. Println("zip archiválási művelet befejeződött")
}

A fő funkció a használatával kezdődik Teremt egy új zip fájl és két szövegfájl létrehozásához. Ezután létrehoz két Writert, hogy hozzáadja a két szövegfájlt az archívumhoz. A Ír Az egyes fájlpéldányok függvénye üzeneteket ír az archívumban lévő egyes fájlokhoz.

Fájlok kibontása a ZIP-archívumból

A meglévő zip-fájlt kibonthatja úgy, hogy elolvassa a OpenReader függvényt, majd végignézi a tartalmát, és átmásolja a fájlokat a io csomag.

import (
"archívum/zip"
"fmt"
"io"
"os"
)
funcfő-() {
// Nyissa meg az archívumot
 zipReader, err := zip. OpenReader("archive.zip")


ha hiba! = nulla {
pánik(téved)
 }


elhalasztja zipReader. Bezárás()


// Fájlok kibontása az archívumból
számára _, fájl := hatótávolság zipReader. fájl {
 zippedFile, err := fájl. Nyisd ki()


ha hiba! = nulla {
pánik(téved)
 }


elhalasztja zippedFile. Bezárás()


// Hozzon létre egy új fájlt a tömörített fájl névvel
 kicsomagolt fájl, err := os. Hozzon létre (fájl. Név)


ha hiba! = nulla {
pánik(téved)
 }


elhalasztja kicsomagolt fájl. Bezárás()


// Másolja át az adatokat a tömörített fájlból az új fájlba
 _, err = io. Másolás (extractedFile, zippedFile)


ha hiba! = nulla {
pánik(téved)
 }
 fmt. Printf("Kicsomagolva: %s\n", fájl. Név)
 }
}

A OpenReader funkció beolvassa a zip archívumot. A OpenReader függvény elfogadja a zip fájl nevét argumentumként, és egy zip fájl olvasó példányt ad vissza. A for-range ciklus végighalad a fájlok tartalmán az olvasó példányban. Létrehoz egy új fájlt az eredetivel megegyező néven, és a kibontott fájl tartalmát az új fájlba másolja a io. Másolat funkció.

Csomagolja ki manuálisan vagy programozottan – ez rajtad múlik

A fájlok programozott kicsomagolása kényelmes, ha sok fájlt vagy archívumot kell kicsomagolni. Lehetséges, hogy az archiválási funkciókat is integrálja a fő alkalmazásba.

Más esetekben jobb, ha meglévő alkalmazásokat használ. Használhat beépített vagy harmadik féltől származó alkalmazásokat az archívumok kicsomagolásához Windows, macOS és Linux rendszeren.