func ExampleWriter() { // Create a buffer to write our archive to. buf := new(bytes.Buffer) // Create a new zip archive. w := zip.NewWriter(buf) // Add some files to the archive. var files = []struct { Name, Body string }{ {"readme.txt", "This archive contains some text files."}, {"gopher.txt", "Gopher names:\nGeorge\nGeoffrey\nGonzo"}, {"todo.txt", "Get animal handling licence.\nWrite more examples."}, } for _, file := range files { f, err := w.Create(file.Name) if err != nil { log.Fatal(err) } _, err = f.Write([]byte(file.Body)) if err != nil { log.Fatal(err) } } // Make sure to check the error on Close. err := w.Close() if err != nil { log.Fatal(err) } }
func ExampleWriter_RegisterCompressor() { // Override the default Deflate compressor with a higher compression // level. // Create a buffer to write our archive to. buf := new(bytes.Buffer) // Create a new zip archive. w := zip.NewWriter(buf) var fw *flate.Writer // Register the deflator. w.RegisterCompressor(zip.Deflate, func(out io.Writer) (io.WriteCloser, error) { var err error if fw == nil { // Creating a flate compressor for every file is // expensive, create one and reuse it. fw, err = flate.NewWriter(out, flate.BestCompression) } else { fw.Reset(out) } return fw, err }) // Proceed to add files to w. }
// Zip creates a .zip file in the location zipPath containing // the contents of files listed in filePaths. func Zip(zipPath string, filePaths []string) error { out, err := os.Create(zipPath) if err != nil { return err } defer out.Close() w := zip.NewWriter(out) for _, fpath := range filePaths { infile, err := os.Open(fpath) if err != nil { return err } outfile, err := w.Create(filepath.Base(fpath)) if err != nil { w.Close() infile.Close() return err } _, err = io.Copy(outfile, infile) if err != nil { w.Close() infile.Close() return err } infile.Close() } return w.Close() }
func makeZip(source, target string, omitRootFolder bool) { zipfile, err := os.Create(target) check(err) defer zipfile.Close() archive := zip.NewWriter(zipfile) defer archive.Close() info, err := os.Stat(source) check(err) var baseDir string if info.IsDir() { baseDir = filepath.Base(source) } filepath.Walk(source, func(path string, info os.FileInfo, err error) error { check(err) header, err := zip.FileInfoHeader(info) check(err) if baseDir != "" { if omitRootFolder { header.Name = strings.TrimPrefix(path, source+"/") } else { header.Name = filepath.Join(baseDir, strings.TrimPrefix(path, source)) } } if info.IsDir() { header.Name += "/" } else { header.Method = zip.Deflate } writer, err := archive.CreateHeader(header) check(err) if info.IsDir() { return nil } file, err := os.Open(path) check(err) defer file.Close() _, err = io.Copy(writer, file) return err }) }