How add a file to an existing zip file using Golang

We can create a zip new file and add files using Go Language.

But, how to add a new file with existing zip file using GoLang?

If we can use Create function, how to get the zip.writer reference?

Bit confused.

After more analysis, i found that, it is not possible to add any files with the existing zip file.

But, I was able to add files with tar file by following the hack given in this URL.

you can:

1. copy old zip items into a new zip file;
2. add new files into the new zip file;

zipReader, err := zip.OpenReader(zipPath)
targetFile, err := os.Create(targetFilePath)
targetZipWriter := zip.NewWriter(targetFile)

for _, zipItem := range zipReader.File {
	zipItemReader, err := zipItem.Open()
	header, err := zip.FileInfoHeader(zipItem.FileInfo())
	header.Name = zipItem.Name
	targetItem, err := targetZipWriter.CreateHeader(header)
    _, err = io.Copy(targetItem, zipItemReader)
}

addNewFiles(targetZipWriter) // IMPLEMENT YOUR LOGIC

Although I have not attempted this yet with a zip file that already exists and then writing to it, I believe you should be able to add files to it.

This is code I have written to create a conglomerate zip file containing multiple files in order to expedite uploading the data to another location. I hope it helps!

type fileData struct {
    Filename string
    Body     []byte
}

func main() {
    outputFilename := "path/to/file.zip"

    // whatever you want as filenames and bodies
    fileDatas := createFileDatas()

    // create zip file
    conglomerateZip, err := os.Create(outputFilename)
	if err != nil {
	    return err
    }
	defer conglomerateZip.Close()

    zipWriter := zip.NewWriter(conglomerateZip)
	defer zipWriter.Close()

	// populate zip file with multiple files
    err = populateZipfile(zipWriter, fileDatas)
	if err != nil {
	    return err
    }

}

func populateZipfile(w *zip.Writer, fileDatas []*fileData) error {
    for _, fd := range fileDatas {
	    f, err := w.Create(fd.Filename)
	    if err != nil {
		    return err
	    }

	    _, err = f.Write([]byte(fd.Body))
	    if err != nil {
	    	return err
	    }

	    err = w.Flush()
	    if err != nil {
	    	return err
	    }
    }
    return nil
}

This is a bit old and already has an answer, but if performance isn't a key concern for you (making the zip file isn't on a hot path for example) you can do this with the archive/zip library by creating a new writer and copying the existing files into it then adding your new content. Something like this:

zw := // new zip writer from buffer or temp file
newFileName := // file name to add
reader, _ := zip.NewReader(bytes.NewReader(existingFile), int64(len(existingFile)))
for _, file := range reader.File {
	if file.Name == newFileName {
		continue // don't copy the old file over to avoid duplicates
	}
	fw, _ := zw.Create(file.Name)
	fr, _ := file.Open()
	io.Copy(fw, fr)
	fr.Close()
}

Then you would return the new writer and append files as needed. If you aren't sure which files might overlap you can turn that if check into a function with a list of file names you will eventually add. You can also use this logic to remove a file from an existing archive.

Now in 2021, there is still no support for appending files to an existing archive.
But at least it is now possible to add already-compressed files, i.e. we don't anymore have to decompress & re-compress files when duplicating them from old archive to new one.

(NOTE: this only applies to Go 1.17+)

So, based on examples by @wongoo and @Michael, here is how I would implement appending files now with the minimum performance overhead (you'll want to add error handling though):

zr, err := zip.OpenReader(zipPath)
defer zr.Close()
zwf, err := os.Create(targetFilePath)
defer zwf.Close()
zw := zip.NewWriter(zwf)
defer zwf.Close() // or not... since it will try to wrote central directory

for _, zipItem := range zrw.File {
    if isOneOfNamesWeWillAdd(zipItem.Name) {
        continue // avoid duplicate files!
    }
    zipItemReader, err := zipItem.OpenRaw()
    header := zipItem.FileHeader // clone header data
    targetItem, err := targetZipWriter.CreateRaw(&header) // use cloned data
    _, err = io.Copy(targetItem, zipItemReader)
}

addNewFiles(zw) // IMPLEMENT YOUR LOGIC