(Go) Chilkat Zip API Concepts

See more Zip Examples

This example demonstrates several core concepts of the Chilkat.Zip class, including how ZIP entries are added, managed, and transformed as a ZIP archive progresses from an in-memory staging object to an actual written .zip file.

The example shows how to:

• Initialize a new ZIP object using NewZip
• Add filesystem file references using AddFile
• Add in-memory text data using AddString
• Modify the stored ZIP filename independently of the source filesystem filename
• Examine ZIP entries before and after writing the ZIP archive
• Understand how ZIP entry types change during the ZIP lifecycle

The example also demonstrates the meaning of the different ZipEntry.EntryType values:

• 1 — File Entry: A reference to a filesystem file that has not yet been processed
• 2 — Data Entry: An in-memory entry containing text or binary data
• 0 — Mapped Entry: An entry already existing within the currently open ZIP archive

This example is especially useful for understanding that methods such as AddFile and AppendFiles initially add only references to filesystem files, and that the actual file reading and compression occur later when WriteZip or WriteZipAndClose is called.

Note: This example requires Chilkat v11.0.0 or greater.

Chilkat Go Downloads Go Package for Windows, MacOS, Linux, Alpine Linux, Solaris

    success := false

    zip := chilkat.NewZip()

    // ------------------------------------------------------------
    // This example demonstrates some of the fundamental concepts
    // of the Chilkat Zip class.
    // 
    // We will:
    // 
    //   1) Create a new ZIP object
    //   2) Add a filesystem file using AddFile
    //   3) Add an in-memory text entry using AddString
    //   4) Examine the ZIP entries before writing the ZIP
    //   5) Write the ZIP archive
    //   6) Examine how the entry types change after writing
    // 
    // The final ZIP archive will contain:
    // 
    //     helloWorld.txt
    //     HelloWorld2.txt
    // 

    // ------------------------------------------------------------
    // Initialize the Zip object.
    // 
    // NewZip resets the Zip object to a new and empty state.
    // It does NOT immediately create the .zip file.
    // 
    // The filename passed to NewZip becomes the default filename
    // used later when WriteZip or WriteZipAndClose is called.
    success = zip.NewZip("test.zip")
    if success == false {
        fmt.Println(zip.LastErrorText())
        zip.DisposeZip()
        return
    }

    fmt.Println("ZIP filename = ", zip.FileName())
    fmt.Println("")

    // ------------------------------------------------------------
    // Add a file from the local filesystem.
    // 
    // AddFile does NOT immediately read or compress the file.
    // Instead, it adds a reference to the filesystem file.
    // 
    // The actual file data will be read later when WriteZip
    // or WriteZipAndClose is called.
    // 
    // Note:
    // On Windows, forward slashes are equivalent to backslashes.
    saveExtraPath := false
    success = zip.AddFile("/temp/abc123/HelloWorld123.txt",saveExtraPath)

    if success == false {
        fmt.Println(zip.LastErrorText())
        zip.DisposeZip()
        return
    }

    // The ZIP object now contains one entry that references
    // the local filesystem file:
    // 
    //     /temp/abc123/HelloWorld123.txt
    // 

    // ------------------------------------------------------------
    // Change the filename that will be stored in the ZIP archive.
    // 
    // The source filesystem file remains:
    // 
    //     /temp/abc123/HelloWorld123.txt
    // 
    // But the ZIP entry will be written as:
    // 
    //     helloWorld.txt
    // 
    entry := chilkat.NewZipEntry()
    zip.EntryAt(0,entry)
    entry.SetFileName("helloWorld.txt")

    // ------------------------------------------------------------
    // Add another ZIP entry directly from in-memory text data.
    // 
    // This entry does not reference a filesystem file.
    // The text data already exists in memory.
    success = zip.AddString("HelloWorld2.txt","hello world!","utf-8")

    if success == false {
        fmt.Println(zip.LastErrorText())
        zip.DisposeZip()
        entry.DisposeZipEntry()
        return
    }

    // ------------------------------------------------------------
    // Examine the ZIP entries before writing the ZIP archive.
    // 
    // ZIP entries can have different entry types:
    // 
    // 0 -- Mapped Entry
    //      An entry already existing in an open ZIP archive.
    // 
    // 1 -- File Entry
    //      A reference to a filesystem file that has not yet
    //      been read or compressed.
    // 
    // 2 -- Data Entry
    //      An in-memory entry containing text or binary data.
    // 
    // 3 -- Null Entry
    //      An entry that no longer exists.
    // 
    // 4 -- New Directory Entry
    //      A directory entry added by AddEmpty.
    // 
    // At this point:
    // 
    //   helloWorld.txt    => type 1
    //   HelloWorld2.txt   => type 2
    // 
    fmt.Println("Entries BEFORE writing the ZIP:")
    fmt.Println("")

    var i int
    n := zip.NumEntries()

    for i = 0; i <= n - 1; i++ {
        zip.EntryAt(i,entry)
        fmt.Println("  ", entry.FileName(), ", type=", entry.EntryType())
    }

    fmt.Println("")

    // ------------------------------------------------------------
    // Write the ZIP archive.
    // 
    // During this call:
    // 
    //   * Filesystem file references are read
    //   * Data is compressed as needed
    //   * The .zip file is created and written
    // 
    success = zip.WriteZip()
    if success == false {
        fmt.Println(zip.LastErrorText())
        zip.DisposeZip()
        entry.DisposeZipEntry()
        return
    }

    // ------------------------------------------------------------
    // Examine the ZIP entries again AFTER writing.
    // 
    // Because we called WriteZip (instead of WriteZipAndClose),
    // the ZIP archive remains open.
    // 
    // The entries are automatically converted to
    // "mapped entries" (type 0), meaning they now point to
    // entries within the currently open ZIP archive.
    // 
    // At this point:
    // 
    //   helloWorld.txt    => type 0
    //   HelloWorld2.txt   => type 0
    // 
    fmt.Println("Entries AFTER writing the ZIP:")
    fmt.Println("")

    n = zip.NumEntries()

    for i = 0; i <= n - 1; i++ {
        zip.EntryAt(i,entry)
        fmt.Println("  ", entry.FileName(), ", type=", entry.EntryType())
    }

    fmt.Println("")

    // ------------------------------------------------------------
    // Close the ZIP archive and clear the Zip object.
    zip.CloseZip()

    fmt.Println("Done.")

    zip.DisposeZip()
    entry.DisposeZipEntry()