Archiwa łączą kilka plików w jeden format, zwykle zip, tar lub rar. Pliki archiwów mogą również wykorzystywać kompresję w celu zmniejszenia całkowitego rozmiaru pliku.
Archiwów można używać do dystrybucji oprogramowania i danych, w tym stron internetowych. Możesz także zarchiwizować swoją aplikację, wraz ze wszystkimi jej plikami i zależnościami, aby użytkownicy mogli ją pobrać i zainstalować.
Pakiet archiwum Go umożliwia tworzenie i rozpakowywanie archiwów w formatach tar i zip.
Pakiet archiwum Go
Go zapewnia archiwum pakiety do pracy z różnymi formatami archiwów. Możesz użyć zamek błyskawiczny I smoła pakiety do tworzenia, odczytywania i zapisywania plików archiwów w tych formatach. Oba pakiety obsługują różne algorytmy kompresji za pośrednictwem łatwego w użyciu interfejsu API.
Oto jak możesz zaimportować pakiety zip i tar w plikach Go:
import (
"archiwum/zip"
„archiwum/tar”
)
Po zaimportowaniu pakietów można ich używać do tworzenia plików archiwów i manipulowania nimi.
Tworzenie i dodawanie plików do archiwów Tar
The smoła pakiet działa z tar archiwa formatów tar i tar.gz, w tym wsparcie dla odczytu i zapisu plików z rozszerzonymi nagłówkami PAX.
Pakiet tar zapewnia NewWriter funkcja do tworzenia nowych archiwów tar. NewWriter przyjmuje ja. Pisarz instancja interfejsu, która może być plikiem lub buforem pamięci i zwraca wskaźnik do pliku smoła. Pisarz struktura.
pakiet głównyimport (
„archiwum/tar”
„os”
)funkcjagłówny() {
// Utwórz nowy plik
plik, _ := os. Tworzyć("mojearchiwum.tar")
odraczać plik. Zamknąć()
// Utwórz nowe archiwum tar
tarWriter := tar. NewWriter (plik)
odraczać tarWriter. Zamknąć()
}
The Tworzyć funkcja os package tworzy nowy plik tar. The smoła. NewWriter funkcja pobiera plik i tworzy nowe archiwum.
Możesz dodawać pliki do archiwum tar za pomocą Napisz nagłówek I Pisać Funkcje. Funkcja WriteHeader przyjmuje smoła. nagłówek struct jako argument. Zawiera metadane pliku, takie jak nazwa pliku, rozmiar i bity uprawnień. Funkcja Write zapisuje zawartość pliku do archiwum.
import (
„archiwum/tar”
"fmt"
"io"
"dziennik"
„os”
)funkcjagłówny() {
// Utwórz nowy plik
plik, _ := os. Tworzyć("mojearchiwum.tar")
plik, _ = os. Tworzyć("wiadomość.txt")
odraczać plik. Zamknąć()// Utwórz nowe archiwum tar
tarWriter := tar. NewWriter (plik)
odraczać tarWriter. Zamknąć()
// Dodaj plik do archiwum
fileToAdd, _ := os. Otwarty("plik1.txt")
odraczać plikDoDodania. Zamknąć()
plikInfo, _ := plikDoDodania. Statystyka()
nagłówek, _ := smoła. FileInfoHeader (informacje o pliku, "")
tarWriter. WriteHeader (nagłówek)
_, _ = io. Kopiuj (tarWriter, fileToAdd)
fmt. println(„Operacja archiwum TAR zakończona”)
}
Program tworzy nowe pliki tar i pliki tekstowe z rozszerzeniem Tworzyć funkcja os package i nowe archiwum tar z rozszerzeniem NewWriter, przed dodaniem pliku do archiwum.
The otwarty funkcja otwiera plik, który ma zostać dodany do archiwum. Pamiętaj, że będziesz potrzebować pliku o nazwie plik1.txt w swoim katalogu roboczym, aby pomyślnie uruchomić ten program.
Możesz użyć Stan funkcja instancji pliku do pobierania metadanych potrzebnych do nagłówka tar. Przekaż jego wynik do Nagłówek informacji o pliku, a następnie przekazać ten wynik do Napisz nagłówek funkcja, aby skonfigurować plik tar. Na koniec skopiuj plik do archiwum za pomocą ja. Kopiuj.
Wyodrębnianie plików z archiwów Tar
Możesz użyć NowyCzytnik funkcja do odczytu zawartości pliku archiwum tar. Funkcja NewReader pobiera plik ja. Czytelnik interfejs, którym może być plik lub bufor pamięci. Zwraca wskaźnik do a smoła. Czytelnik struktura.
import (
„archiwum/tar”
"io"
„os”
)funkcjagłówny() {
// Otwórz archiwum tar
plik, _ := os. Otwarty("mojearchiwum.tar")
odraczać plik. Zamknąć()// Utwórz nowy czytnik tar
Czytnik tar := tar. NewReader (plik)// Iteruj po plikach w archiwum
Do {
nagłówek, błąd: = tarReader. Następny()Jeśli błąd == tak. EOF {
przerwa
}
// Wypakuj plik
outFile, _ := os. Utwórz (nagłówek. Nazwa)
odraczać plik wyjściowy. Zamknąć()
_, _ = io. Kopiuj (plik wyjściowy, tarReader)
}
}
The nieskończona pętla for przechodzi przez instancję czytnika tar i wyodrębnia pliki, kopiując każdy plik z rozszerzeniem ja paczka Kopiuj funkcjonować.
Tworzenie i dodawanie plików do archiwów ZIP
Możesz utworzyć nowe archiwum ZIP z rozszerzeniem NewWriter funkcja zamek błyskawiczny pakiet. Funkcja NewWriter pobiera instancję pliku i zwraca program piszący zip.
import (
"archiwum/zip"
„os”
)funkcjagłówny() {
// Utwórz nowy plik
plik, błąd := os. Tworzyć("archiwum.zip")Jeśli błąd!= zero {
panika(błądzić)
}odraczać plik. Zamknąć()
// Utwórz nowy program piszący zip
zipWriter := zip. NewWriter (plik)
odraczać zipWriter. Zamknąć()
}
The zipWriter zmienna przechowuje nowy Pisarz instancja zwracana przez NewWriter.
Możesz dodawać pliki do swoich archiwów zip za pomocą rozszerzenia Tworzyć funkcja instancji Writer. Funkcja Create przyjmuje nazwę pliku. Możesz także skorzystać z tzw Pisać funkcja instancji pliku zip do zapisywania danych do plików w archiwach zip.
import (
"archiwum/zip"
„os”
)funkcjagłówny() {
// Utwórz nowe pliki
plik, błąd := os. Tworzyć("archiwum.zip")
plik, błąd = os. Tworzyć("plik1.txt")
plik, błąd = os. Tworzyć("plik2.txt")Jeśli błąd!= zero {
panika(błądzić)
}odraczać plik. Zamknąć()
// Utwórz nowy program piszący zip
zipWriter := zip. NewWriter (plik)
odraczać zipWriter. Zamknąć()// Dodaj pliki do archiwum
plik1, błąd:= zipWriter. Tworzyć("plik1.txt")Jeśli błąd!= zero {
panika(błądzić)
}plik2, błąd:= zipWriter. Tworzyć("plik2.txt")
Jeśli błąd!= zero {
panika(błądzić)
}
// Zapis danych do plików w archiwum
plik1.Write([]bajt("Witaj świecie!"))
plik2.Write([]bajt("Żegnaj świecie!"))
fmt. println(„Operacja archiwizacji zip zakończona”)
}
Główna funkcja zaczyna się od użycia Tworzyć aby utworzyć nowy plik zip i dwa pliki tekstowe. Następnie tworzy dwóch pisarzy, aby dodać dwa pliki tekstowe do archiwum. The Pisać funkcja każdej instancji pliku zapisuje komunikaty do każdego pliku w archiwum.
Wyodrębnianie plików z archiwów ZIP
Możesz wyodrębnić istniejący plik zip, czytając go z rozszerzeniem OpenReader funkcji, a następnie przeglądając jej zawartość i kopiując pliki z rozszerzeniem ja pakiet.
import (
"archiwum/zip"
"fmt"
"io"
„os”
)funkcjagłówny() {
// Otwórz archiwum
zipReader, błąd:= zip. OpenReader("archiwum.zip")Jeśli błąd!= zero {
panika(błądzić)
}odraczać Czytnik zip. Zamknąć()
// Wypakuj pliki z archiwum
Do _, plik := zakres Czytnik zip. Plik {
zipPlik, błąd:= plik. Otwarty()Jeśli błąd!= zero {
panika(błądzić)
}odraczać spakowany plik. Zamknąć()
// Utwórz nowy plik o takiej samej nazwie jak spakowany plik
wyodrębniony plik, błąd:= os. Utwórz (plik. Nazwa)Jeśli błąd!= zero {
panika(błądzić)
}odraczać wyodrębniony plik. Zamknąć()
// Skopiuj dane z spakowanego pliku do nowego pliku
_, błąd = io. Kopiuj (wyodrębniony plik, plik spakowany)Jeśli błąd!= zero {
panika(błądzić)
}
fmt. Drukujf("Wyodrębniono %s\n", plik. Nazwa)
}
}
The OpenReader funkcja odczytuje archiwa zip. The OpenReader funkcja przyjmuje nazwę pliku zip jako argument i zwraca instancję czytnika plików zip. The dla zakresu pętla przechodzi przez zawartość plików w instancji czytnika. Tworzy nowy plik o takiej samej nazwie jak oryginalny plik i kopiuje zawartość wyodrębnionego pliku do nowego pliku przy użyciu ja. Kopiuj funkcjonować.
Rozpakuj ręcznie lub programowo — to zależy od Ciebie
Programowe rozpakowywanie plików jest wygodne, jeśli masz wiele plików lub archiwów do rozpakowania. Być może integrujesz również funkcje archiwizacji ze swoją główną aplikacją.
W innych przypadkach lepiej będzie korzystać z istniejących aplikacji. Do rozpakowywania archiwów w systemach Windows, macOS i Linux można używać wbudowanych aplikacji lub aplikacji innych firm.