1. zip

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
package main

import (
	"archive/zip"
	"fmt"
	"io"
	"log"
	"os"
	"path/filepath"
	"strings"
)

func new_zip(files []string) {
	// 创建压缩文件
	fout, err2 := os.OpenFile("test2.zip", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
	if err2 != nil {
		log.Fatal(err2)
	}
	defer fout.Close()

	// 创建zip writer
	w := zip.NewWriter(fout)
	defer w.Close()

	// 压缩指定文件
	for _, file := range files {
		// 打开被压缩文件
		fin, err := os.Open(file)
		if err != nil {
			log.Fatal(err)
		}
		defer fin.Close()

		f, _ := w.Create(file)
		for {
			buf := make([]byte, 4096)
			n, err2 := fin.Read(buf)
			if err2 == io.EOF {
				break
			}
			f.Write(buf[:n])
		}
	}

}

func unzip(zipfile string) {
	// 打开一个zip格式文件
	r, err := zip.OpenReader(zipfile)
	if err != nil {
		log.Fatal(err)
	}
	defer r.Close()
	// 解压目录
	dest_dir := strings.Trim(zipfile, ".zip")
	err2 := os.Mkdir(dest_dir, 0755)
	if err2 != nil {
		log.Fatal(err2)
	}
	// 迭代解压缩文件中的文件
	for _, f := range r.File {
		// 跳过目录
		if f.Mode().IsDir() {
			fmt.Println("跳过目录", f.Name)
			continue
		}
		f2, err3 := os.Create(filepath.Join(dest_dir, f.Name))
		if err3 != nil {
			log.Fatal(err3)
		}
		// 打开压缩文件
		rc, err := f.Open()
		defer rc.Close()
		if err != nil {
			log.Fatal(err)
		}
		io.Copy(f2, rc)

	}
}

func main() {
	// files := []string{"test2.txt", "go.mod", "go.sum"}
	// new_zip(files)
	unzip("test2.zip")
}

2. gzip

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
package main

import (
	"compress/gzip"
	"io"
	"log"
	"os"
)

func new_gzip(infile, outfile string) {
	// 打开被压缩文件
	// fin, err := os.Open("D:\\ISO\\ubuntu-16.04.7-server-amd64.iso")
	fin, err := os.Open(infile)
	if err != nil {
		log.Fatal(err)
	}
	// 创建压缩文件
	fout, err2 := os.OpenFile(outfile, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
	if err2 != nil {
		log.Fatal(err2)
	}
	defer fin.Close()
	defer fout.Close()
	// 创建zip writer
	w := gzip.NewWriter(fout)
	defer w.Close()
	for {
		bs := make([]byte, 4096)
		n, err2 := fin.Read(bs)
		if err2 == io.EOF {
			break
		}
		w.Write(bs[:n])
	}
}

func ungzip(infile, outfile string) {
	fin, err := os.Open(infile)
	if err != nil {
		log.Fatal(err)
	}
	fout, err2 := os.OpenFile(outfile, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
	if err2 != nil {
		log.Fatal(err2)
	}
	defer fin.Close()
	defer fout.Close()
	// 创建gzip reader
	r, err3 := gzip.NewReader(fin)
	defer r.Close()
	if err3 != nil {
		log.Fatal(err3)
	}

	io.Copy(fout, r)
	// for {
	// 	bs := make([]byte, 1024)
	// 	n, err4 := r.Read(bs)
	// 	if err4 != nil {
	// 		if err4 == io.EOF {
	// 			break
	// 		} else {
	// 			log.Fatal(err4)
	// 		}
	// 	}
	// 	fout.Write(bs[:n])
	// }
}

func main() {
	// new_gzip("test2.txt", "test2.txt.gz")
	ungzip("test2.txt.gz", "test2_new.txt")
}

3. base64编码/解码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package main

import (
	"encoding/base64"
	"fmt"
	"io/ioutil"
	"log"
	"os"
)

func base64Encode(file string) (encodestr string) {
	f, err := os.Open(file)
	if err != nil {
		log.Fatal(err)
	}
	b, err2 := ioutil.ReadAll(f)
	if err2 != nil {
		log.Fatal(err2)
	}
	s := base64.StdEncoding.EncodeToString(b)
	return s
}

func base64Decode(encodestr, destfile string) {
	f, err := os.OpenFile(destfile, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()
	b, err2 := base64.StdEncoding.DecodeString(encodestr)
	if err2 != nil {
		log.Fatal(err2)
	}
	f.Write(b)
}
func main() {
	s := base64Encode(".\\O1CN01lzzceP1HxtQVhXvl4_!!2934640825.jpg")
	fmt.Printf("s: %v\n", s)
	base64Decode(s, "./new.jpg")
}