golang file 10

不念不忘少年蓝@ 2022-12-10 07:27 95阅读 0赞

### 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:/")
    }