עבודה עם ארכיונים ב-Go

ארכיונים מאגדים מספר קבצים יחד לפורמט אחד, בדרך כלל zip, tar או rar. קבצי ארכיון עשויים להשתמש גם בדחיסה כדי להקטין את גודל הקובץ הכולל.

אתה יכול להשתמש בארכיונים כדי להפיץ תוכנות ונתונים, כולל דפי אינטרנט. אתה יכול גם לאחסן את האפליקציה שלך, עם כל הקבצים והתלות שלה, כדי שהמשתמשים יוכלו להוריד ולהתקין.

חבילת הארכיון של Go מאפשרת לך ליצור ולחלץ ארכיונים בפורמטים של tar ו-zip.

חבילת הארכיון של Go

גו מספקת ארכיון חבילות לעבודה עם פורמטים שונים של ארכיון. אתה יכול להשתמש ב רוכסן ו זֶפֶת חבילות ליצירה, קריאה וכתיבה של קובצי ארכיון בפורמטים אלה. שתי החבילות תומכות באלגוריתמי דחיסה שונים על פני ממשק API קל לשימוש.

כך תוכל לייבא את חבילות ה-zip ו-tar בקבצי ה-Go שלך:

יְבוּא (
"ארכיון/zip"
"ארכיון/זפת"
)

לאחר ייבוא ​​החבילות, תוכל להשתמש בהן כדי ליצור ולתפעל קבצי ארכיון.

יצירה והוספה של קבצים לארכיוני Tar

ה זֶפֶת החבילה עובדת עם זפת ארכיונים של תבניות tar ו-tar.gz, כולל תמיכה בקריאה וכתיבה של קבצים עם כותרות מורחבות של PAX.

חבילת הזפת מספקת א NewWriter פונקציה ליצירת ארכיוני tar חדשים. NewWriter לוקח ב- io. סוֹפֵר מופע ממשק שעשוי להיות מאגר קובץ או זיכרון ומחזיר מצביע ל- זֶפֶת. סוֹפֵר struct.

חֲבִילָה רָאשִׁי
יְבוּא (
"ארכיון/זפת"
"os"
)
funcרָאשִׁי() {
// צור קובץ חדש
 קובץ, _ := os. לִיצוֹר("myarchive.tar")
לִדחוֹת קוֹבֶץ. סגור()
// צור ארכיון tar חדש
 tarWriter := tar. NewWriter (קובץ)
לִדחוֹת tarWriter. סגור()
}

ה לִיצוֹר פונקציה של OS החבילה יוצרת קובץ tar חדש. ה זֶפֶת. NewWriter הפונקציה קולטת קובץ ויוצרת ארכיון חדש.

אתה יכול להוסיף קבצים לארכיון tar עם ה- WriteHeader ו לִכתוֹב פונקציות. הפונקציה WriteHeader לוקחת א זֶפֶת. כּוֹתֶרֶת struct כטיעון. זה מכיל את המטא נתונים של הקובץ, כגון שם הקובץ, גודלו וסיביות ההרשאה. הפונקציה Write כותבת את תוכן הקובץ לארכיון.

יְבוּא (
"ארכיון/זפת"
"fmt"
"io"
"עֵץ"
"os"
)
funcרָאשִׁי() {
// צור קובץ חדש
 קובץ, _ := os. לִיצוֹר("myarchive.tar")
 קובץ, _ = os. לִיצוֹר("message.txt")
לִדחוֹת קוֹבֶץ. סגור()
// צור ארכיון tar חדש
 tarWriter := tar. NewWriter (קובץ)
לִדחוֹת tarWriter. סגור()
// הוסף קובץ לארכיון
 fileToAdd, _ := os. לִפְתוֹחַ("file1.txt")
לִדחוֹת fileToAdd. סגור()
 fileInfo, _ := fileToAdd. סטט()
 כותרת, _ := tar. FileInfoHeader (fileInfo, "")
 tarWriter. WriteHeader (כותרת)
 _, _ = io. העתק (tarWriter, fileToAdd)
 fmt. Println("פעולת ארכיון TAR הושלמה")
}

התוכנית יוצרת קובצי tar וטקסט חדשים עם ה- לִיצוֹר פונקציה של OS חבילה וארכיון זפת חדש עם ה NewWriter, לפני הוספת הקובץ לארכיון.

ה לִפְתוֹחַ הפונקציה פותחת את הקובץ להוספה לארכיון. שים לב שאתה צריך קובץ בשם file1.txt בספריית העבודה שלך כדי להפעיל תוכנית זו בהצלחה.

אתה יכול להשתמש ב סטט פונקציה של מופע קובץ כדי להביא את המטא נתונים שתזדקק לכותרת tar. להעביר את התוצאה שלו ל FileInfoHeader, ואז להעביר את התוצאה הזו ל WriteHeader פונקציה להגדרת קובץ tar. לבסוף, העתק את הקובץ לארכיון באמצעות io. עותק.

חילוץ קבצים מארכיון Tar

אתה יכול להשתמש ב NewReader פונקציה לקריאת התוכן של קובץ ארכיון tar. הפונקציה NewReader לוקחת ב-an io. קוֹרֵא ממשק שעשוי להיות קובץ או מאגר זיכרון. זה מחזיר מצביע ל-a זֶפֶת. קוֹרֵא struct.

יְבוּא (
"ארכיון/זפת"
"io"
"os"
)
funcרָאשִׁי() {
// פתח את ארכיון tar
 קובץ, _ := os. לִפְתוֹחַ("myarchive.tar")
לִדחוֹת קוֹבֶץ. סגור()
// צור קורא tar חדש
 tarReader := tar. NewReader (קובץ)
// חזור על הקבצים בארכיון
ל {
 header, err := tarReader. הַבָּא()
אם שגיאה == io. EOF {
לשבור
 }
// חלץ את הקובץ
 outFile, _ := os. צור (כותרת. שֵׁם)
לִדחוֹת outFile. סגור()
 _, _ = io. העתק (outFile, tarReader)
 }
}

ה אינסופי עבור לולאה חוצה את מופע קורא tar ומחלץ את הקבצים על ידי העתקת כל קובץ עם io של החבילה עותק פוּנקצִיָה.

יצירה והוספה של קבצים לארכיוני Zip

אתה יכול ליצור ארכיון zip חדש עם NewWriter פונקציה של רוכסן חֲבִילָה. הפונקציה NewWriter לוקחת מופע של קובץ ומחזירה כותב zip.

יְבוּא (
"ארכיון/zip"
"os"
)
funcרָאשִׁי() {
// צור קובץ חדש
 קובץ, שגיאה := os. לִיצוֹר("archive.zip")
אם טעות != אֶפֶס {
בהלה(לִטְעוֹת)
 }
לִדחוֹת קוֹבֶץ. סגור()
// צור כותב zip חדש
 zipWriter := zip. NewWriter (קובץ)
לִדחוֹת zipWriter. סגור()
}

ה zipWriter משתנה מאחסן חדש סוֹפֵר מופע ש-NewWriter מחזיר.

אתה יכול להוסיף קבצים לארכיון ה-zip שלך עם ה- לִיצוֹר הפונקציה של מופע Writer. הפונקציה Create מקבלת את שם הקובץ. אתה יכול גם להשתמש ב לִכתוֹב הפונקציה של מופע קובץ ה-zip לכתוב נתונים לקבצים בארכיוני zip.

יְבוּא (
"ארכיון/zip"
"os"
)
funcרָאשִׁי() {
// צור קבצים חדשים
 קובץ, שגיאה := os. לִיצוֹר("archive.zip")
 קובץ, err = os. לִיצוֹר("file1.txt")
 קובץ, err = os. לִיצוֹר("file2.txt")
אם טעות != אֶפֶס {
בהלה(לִטְעוֹת)
 }
לִדחוֹת קוֹבֶץ. סגור()
// צור כותב zip חדש
 zipWriter := zip. NewWriter (קובץ)
לִדחוֹת zipWriter. סגור()
// הוסף קבצים לארכיון
 file1, err := zipWriter. לִיצוֹר("file1.txt")
אם טעות != אֶפֶס {
בהלה(לִטְעוֹת)
 }
 file2, error := zipWriter. לִיצוֹר("file2.txt")
אם טעות != אֶפֶס {
בהלה(לִטְעוֹת)
 }
// כתוב נתונים לקבצים בארכיון
 file1.Write([]בייט("שלום עולם!"))
 file2.Write([]בייט("להתראות עולם!"))
 fmt. Println("פעולת אחסון הארכיון הושלמה")
}

הפונקציה העיקרית מתחילה בשימוש לִיצוֹר כדי ליצור קובץ zip חדש ושני קובצי טקסט. לאחר מכן הוא יוצר שני כותבים כדי להוסיף את שני קבצי הטקסט לארכיון. ה לִכתוֹב הפונקציה של כל מופע קובץ כותבת הודעות לכל אחד מהקבצים בארכיון.

חילוץ קבצים מארכיון Zip

אתה יכול לחלץ קובץ zip קיים על ידי קריאתו באמצעות ה OpenReader פונקציה, ולאחר מכן עוברים בלולאה בתוכן שלה ומעתיקים קבצים עם ה- io חֲבִילָה.

יְבוּא (
"ארכיון/zip"
"fmt"
"io"
"os"
)
funcרָאשִׁי() {
// פתח את הארכיון
 zipReader, שגיאה := zip. OpenReader("archive.zip")
אם טעות != אֶפֶס {
בהלה(לִטְעוֹת)
 }
לִדחוֹת zipReader. סגור()
// חלץ קבצים מהארכיון
ל _, קובץ := טווח zipReader. קובץ {
 zippedFile, קובץ שגיאה :=. לִפְתוֹחַ()
אם טעות != אֶפֶס {
בהלה(לִטְעוֹת)
 }
לִדחוֹת zippedFile. סגור()
// צור קובץ חדש באותו שם כמו הקובץ הדחוס
 extractedFile, שגיאה := os. צור (קובץ. שֵׁם)
אם טעות != אֶפֶס {
בהלה(לִטְעוֹת)
 }
לִדחוֹת extractedFile. סגור()
// העתק את הנתונים מהקובץ הדחוס לקובץ החדש
 _, שגיאה = io. העתק (extractedFile, zippedFile)
אם טעות != אֶפֶס {
בהלה(לִטְעוֹת)
 }
 fmt. Printf("חולץ %s\n", קובץ. שֵׁם)
 }
}

ה OpenReader הפונקציה קוראת ארכיון zip. ה OpenReader הפונקציה מקבלת את שם קובץ ה-zip כארגומנט ומחזירה מופע קורא קובץ zip. ה לטווח לולאה חוצה את תוכן הקבצים במופע הקורא. הוא יוצר קובץ חדש באותו שם כמו הקובץ המקורי, ומעתיק את תוכן הקובץ שחולץ לקובץ החדש באמצעות io. עותק פוּנקצִיָה.

פתח את הדחוס באופן ידני או פרוגרמטי - זה תלוי בך

פתיחת קבצים באופן תכנותי נוחה אם יש לך הרבה קבצים או ארכיונים לפתיחה. ייתכן שאתה גם משלב פונקציונליות ארכיון באפליקציה הראשית שלך.

במקרים אחרים, אולי עדיף לך להשתמש ביישומים קיימים. אתה יכול להשתמש באפליקציות מובנות או של צד שלישי כדי לפתוח ארכיונים ב-Windows, macOS ו-Linux.