golang file 10

1.终端读写

/*
终端读写  (就是控制台操作)
os.Stdin：标准输入
os.Stdout: 标准输出
os.Stderr：标准错误输出
*/
func DayRun() {
	buffer := bufio.NewReader(os.Stdin)
	s, err := buffer.ReadString('\n')
	if err == nil{
		fmt.Println("s",s)
	}else {
		fmt.Println("err",err)
	}
}

2.文件读写Open

func main() {
	file, e := os.Open("C:\\object\\码云库\\go_study\\base\\imput.dat")
	if e != nil {
		fmt.Println(e)
	}
	buf := make([]byte,1024)
	for {
		len, _ := file.Read(buf)
		if len == 0 {
			break
		}
		fmt.Println(string(buf))
	}

	buf1 := make([]byte,1024)
	offset := 0
	for {
		len1, _ := file.ReadAt(buf1, int64(offset))
		offset = offset + len1
		if len1 == 0 {
			break
		}
		fmt.Println(string(buf1))
	}
	file.Close()
}

3.OpenFile

O_RDONLY int = syscall.O_RDONLY // 只读模式
O_WRONLY int = syscall.O_WRONLY //只写模式
O_RDWR   int = syscall.O_RDWR   // 读写混合模式
O_APPEND int = syscall.O_APPEND // 写模式的时候将数据附加到文件末尾
O_CREATE int = syscall.O_CREAT  // 文件如果不存在就新建
O_EXCL   int = syscall.O_EXCL   // 和 O_CREATE模式一起使用, 文件必须不存在
O_SYNC   int = syscall.O_SYNC   //打开文件用于同步 I/O.
O_TRUNC  int = syscall.O_TRUNC  // 打开文件时清空文件

OpenFile函数的第三个参数是文件的权限，跟linux文件权限一致：
r ——> 004
w ——> 002
x ——> 001

func read()  {
	//以读写方式打开文件，如果不存在，则创建
	openFile, e := os.OpenFile("C:\\object\\码云库\\go_study\\base\\imput.dat", os.O_RDWR|os.O_CREATE, 777)
	if e != nil {
		fmt.Println(e)
	}
	buf := make([]byte,1024)
	for {
		len, _ := openFile.Read(buf)
		if len == 0 {
			break
		}
		fmt.Println(string(buf))
	}
	openFile.Close()
}

func write()  {
	openFile, e := os.OpenFile("C:\\object\\码云库\\go_study\\base\\imput.dat", os.O_RDWR|os.O_CREATE|os.O_TRUNC, 777)
	if e != nil {
		fmt.Println(e)
	}
	str := "overwrite to file"
	openFile.WriteString(str)
	openFile.Close()
}

/*
创建写
*/
func creat() {
	f, err := os.Create("C:\\object\\码云库\\go_study\\base\\imputNew.dat")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer f.Close()

	content := map[string]string{
		"hello": "111",
		"world": "222",
		"world1": "333",
		"world2": "444",
	}
	bw := bufio.NewWriter(f)
	for k, v := range content {
		bw.WriteString(k + ":" + v + "\n")
	}
	bw.Flush()
}

/*
Go还提供了一个io缓冲区：bufio,可以先将文件读取到缓冲区中，然后从缓冲区读取数据
*/
func bufio_r(){
	openFile, e := os.OpenFile("c:/1.txt", os.O_RDWR|os.O_CREATE, 777)
	if e != nil {
		fmt.Println(e)
	}
	reader := bufio.NewReader(openFile)
	//按行读取
	for {
		line, _, e := reader.ReadLine()
		if e == io.EOF {
			break
		}
		if e != nil {
			fmt.Println(e)
		}
		fmt.Println(string(line))
	}
	//按照指定分隔符读取
	for{
		s, e := reader.ReadString('\n')
		fmt.Println(s)
		if e == io.EOF {
			break
		}
		if e != nil {
			fmt.Println(e)
		}
	}
	openFile.Close()
}

4.ioutil

func main() {
	//读取文件
	bytes, e := ioutil.ReadFile("c:/1.txt")
	if e != nil {
		fmt.Println(e)
	}
	fmt.Println(string(bytes))

	//读取文件夹
	infos, e := ioutil.ReadDir("c:/1")
	if e != nil {
		fmt.Println(e)
	}
	for _,v := range infos {
		fmt.Println(v.Name())
	}

	//向指定文件写入数据，如果文件不存在，则创建文件，写入数据之前清空文件
	ioutil.WriteFile("c:/1.txt", []byte("xxxxxxxxx"), 666)

	//在当前目录下，创建一个以test为前缀的临时文件夹，并返回文件夹路径
	name, e := ioutil.TempDir("c:/2", "tmp")
	fmt.Println(name)

	//在当前目录下，创建一个以test为前缀的文件，并以读写模式打开文件，并返回os.File指针
	f, e := ioutil.TempFile("c:/2", "tmpFile")
	f.WriteString("tmp word")
	f.Close()

}

5.压缩文件

/*
compress包提供了读取压缩文件的功能，支持的压缩文件格式为：bzip2、flate、gzip、lzw 和 zlib。
archive包提供了tar，zip格式的压缩解压缩功能。
*/

//压缩文件
//files 文件数组，可以是不同dir下的文件或者文件夹
//dest 压缩文件存放地址
func Compress(files []*os.File, dest string) error {
	d, _ := os.Create(dest)
	defer d.Close()
	w := zip.NewWriter(d)
	defer w.Close()
	for _, file := range files {
		err := compress(file, "", w)
		if err != nil {
			return err
		}
	}
	return nil
}

func compress(file *os.File, prefix string, zw *zip.Writer) error {
	info, err := file.Stat()
	if err != nil {
		return err
	}
	if info.IsDir() {
		prefix = prefix + "/" + info.Name()
		fileInfos, err := file.Readdir(-1)
		if err != nil {
			return err
		}
		for _, fi := range fileInfos {
			f, err := os.Open(file.Name() + "/" + fi.Name())
			if err != nil {
				return err
			}
			err = compress(f, prefix, zw)
			if err != nil {
				return err
			}
		}
	} else {
		header, err := zip.FileInfoHeader(info)
		header.Name = prefix + "/" + header.Name
		if err != nil {
			return err
		}
		writer, err := zw.CreateHeader(header)
		if err != nil {
			return err
		}
		_, err = io.Copy(writer, file)
		file.Close()
		if err != nil {
			return err
		}
	}
	return nil
}

//解压
func DeCompress(zipFile, dest string) error {
	reader, err := zip.OpenReader(zipFile)
	if err != nil {
		return err
	}
	defer reader.Close()
	for _, file := range reader.File {
		rc, err := file.Open()
		if err != nil {
			return err
		}
		defer rc.Close()
		filename := dest + file.Name
		err = os.MkdirAll(getDir(filename), 0666)
		if err != nil {
			return err
		}
		w, err := os.Create(filename)
		if err != nil {
			return err
		}
		defer w.Close()
		_, err = io.Copy(w, rc)
		if err != nil {
			return err
		}
		w.Close()
		rc.Close()
	}
	return nil
}

func getDir(path string) string {
	return subString(path, 0, strings.LastIndex(path, "/"))
}

func subString(str string, start, end int) string {
	rs := []rune(str)
	length := len(rs)

	if start < 0 || start > length {
		panic("start is wrong")
	}

	if end < start || end > length {
		panic("end is wrong")
	}

	return string(rs[start:end])
}

func main() {
	DeCompress("c:/1.zip","c:/")

	f1, err := os.Open("c:/1.txt")
	if err != nil {
		fmt.Println(err)
	}
	defer f1.Close()
	f2, err := os.Open("c:/2.txt")
	if err != nil {
		fmt.Println(err)
	}
	files := []*os.File{f1,f2}
	Compress(files,"c:/")
}