github.com/gogf/gf@v1.16.9/encoding/gcompress/gcompress_gzip.go (about)

     1  // Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
     2  //
     3  // This Source Code Form is subject to the terms of the MIT License.
     4  // If a copy of the MIT was not distributed with this file,
     5  // You can obtain one at https://github.com/gogf/gf.
     6  
     7  package gcompress
     8  
     9  import (
    10  	"bytes"
    11  	"compress/gzip"
    12  	"github.com/gogf/gf/os/gfile"
    13  	"io"
    14  )
    15  
    16  // Gzip compresses <data> using gzip algorithm.
    17  // The optional parameter <level> specifies the compression level from
    18  // 1 to 9 which means from none to the best compression.
    19  //
    20  // Note that it returns error if given <level> is invalid.
    21  func Gzip(data []byte, level ...int) ([]byte, error) {
    22  	var (
    23  		writer *gzip.Writer
    24  		buf    bytes.Buffer
    25  		err    error
    26  	)
    27  	if len(level) > 0 {
    28  		writer, err = gzip.NewWriterLevel(&buf, level[0])
    29  		if err != nil {
    30  			return nil, err
    31  		}
    32  	} else {
    33  		writer = gzip.NewWriter(&buf)
    34  	}
    35  	if _, err = writer.Write(data); err != nil {
    36  		return nil, err
    37  	}
    38  	if err = writer.Close(); err != nil {
    39  		return nil, err
    40  	}
    41  	return buf.Bytes(), nil
    42  }
    43  
    44  // GzipFile compresses the file <src> to <dst> using gzip algorithm.
    45  func GzipFile(src, dst string, level ...int) error {
    46  	var (
    47  		writer *gzip.Writer
    48  		err    error
    49  	)
    50  	srcFile, err := gfile.Open(src)
    51  	if err != nil {
    52  		return err
    53  	}
    54  	defer srcFile.Close()
    55  	dstFile, err := gfile.Create(dst)
    56  	if err != nil {
    57  		return err
    58  	}
    59  	defer dstFile.Close()
    60  
    61  	if len(level) > 0 {
    62  		writer, err = gzip.NewWriterLevel(dstFile, level[0])
    63  		if err != nil {
    64  			return err
    65  		}
    66  	} else {
    67  		writer = gzip.NewWriter(dstFile)
    68  	}
    69  	defer writer.Close()
    70  
    71  	_, err = io.Copy(writer, srcFile)
    72  	if err != nil {
    73  		return err
    74  	}
    75  	return nil
    76  }
    77  
    78  // UnGzip decompresses <data> with gzip algorithm.
    79  func UnGzip(data []byte) ([]byte, error) {
    80  	var buf bytes.Buffer
    81  	reader, err := gzip.NewReader(bytes.NewReader(data))
    82  	if err != nil {
    83  		return nil, err
    84  	}
    85  	if _, err = io.Copy(&buf, reader); err != nil {
    86  		return nil, err
    87  	}
    88  	if err = reader.Close(); err != nil {
    89  		return buf.Bytes(), err
    90  	}
    91  	return buf.Bytes(), nil
    92  }
    93  
    94  // UnGzip decompresses file <src> to <dst> using gzip algorithm.
    95  func UnGzipFile(src, dst string) error {
    96  	srcFile, err := gfile.Open(src)
    97  	if err != nil {
    98  		return err
    99  	}
   100  	defer srcFile.Close()
   101  	dstFile, err := gfile.Create(dst)
   102  	if err != nil {
   103  		return err
   104  	}
   105  	defer dstFile.Close()
   106  
   107  	reader, err := gzip.NewReader(srcFile)
   108  	if err != nil {
   109  		return err
   110  	}
   111  	defer reader.Close()
   112  
   113  	if _, err = io.Copy(dstFile, reader); err != nil {
   114  		return err
   115  	}
   116  	return nil
   117  }