文件操作

涉及到文件、文件夹操作包

  1. os
  2. io
  3. bufio
  4. io/ioutil
  5. filepath //文件夹

文件存在判断 # 

func CheckFileExist(filename string) bool {
	_,err := os.Stat(filename);
	if  err != nil {
		if os.IsNotExist(err) {
			return false
		}
	}
	return true
}

文件读取操作 #

通过io/ioutil读取文件内容 # 

func ReadFileOne(filename string) []byte  {
	content, err := ioutil.ReadFile(filename)
	if err != nil {
		return []byte("")
	}
	return content
}

通过file打开文件 # 

fp,err := os.Open(filename)
defer fp.Close()
buf := make([]byte,1024)
//通过fp.Read读取文件
n,_ := fp.Read(buf)
return buf[:n]

//通过io.ReadAll读取文件内容
buf := make([]byte,1024)
io.ReadAll(fp)
io.ReadFull(fp,buf)

//通过bufio缓冲区读取文件
1、
reader := bufio.NewReader(fp)
str,err := reader.ReadString('\n')
2、
buf := make([]byte,1024)
reader.Read(buf)
content = append(content,buf[:n]...)

文件写入操作 #

通过ioutil包写入 # 

	err := ioutil.WriteFile(filename,[]byte(data),0666)

通过file操作文件写入 # 

fp, err = os.OpenFile(filename,os.O_APPEND|os.O_WRONLY,0666)
fp, err = os.Create(filename)
1、通过fp句柄
_, err = fp.WriteString(data)
2、通过io包
_,err = io.WriteString(fp,data)
3、通过bufio Writer
writer := bufio.NewWriter(fp)
writer.WriteString(data) //写入string
writer.Write([]byte)     //写入字节切片
writer.Flush()  //要刷新缓冲区

函数说明 #

删除文件 os.Remove(fname)

创建目录 os.Mkdir(dname, os.ModeDir|os.ModePerm)

创建完整目录路径 os.MkdirAll(dname,os.ModeDir|os.ModePerm)

以只读方式打开一个存在的文件，打开就可以读取了 func Open(name string) (file *File, err error) func OpenFile(name string, flag int, perm FileMode) (file *File, err error)

直接通过纹面创建文件 func Create(name string) (file *File, err error) func NewFile(fd uintptr, name string) *File

以只读方式打开一个存在的文件，打开就可以读取了 func Open(name string) (file *File, err error) func OpenFile(name string, flag int, perm FileMode) (file *File, err error)

管道 func Pipe() (r *File, w *File, err error)

改变当前的工作目录 func (f *File) Chdir() error

改变权限 func (f *File) Chmod(mode FileMode) error

改变所有者 func (f *File) Chown(uid, gid int) error

关闭文件 func (f *File) Close() error

返回文件句柄 func (f *File) Fd() uintptr

返回文件名 func (f *File) Name() string

读取文件 func (f *File) Read(b []byte) (n int, err error)

从off开始读取文件 func (f *File) ReadAt(b []byte, off int64) (n int, err error)

读取文件目录返回n个fileinfo func (f *File) Readdir(n int) (fi []FileInfo, err error)

读取文件目录返回n个文件名 func (f *File) Readdirnames(n int) (names []string, err error)

设置读写文件的偏移量，whence为0表示相对于文件的开始处，1表示相对于当前的位置，2表示相对于文件结尾。他返回偏移量。如果有错误返回错误 func (f *File) Seek(offset int64, whence int) (ret int64, err error)

返回当前文件fileinfo结构体 func (f *File) Stat() (fi FileInfo, err error)

把当前内容持久化，一般就是马上写入到磁盘 func (f *File) Sync() (err error)

改变当前文件的大小，他不改变当前文件读写的偏移量 func (f *File) Truncate(size int64) error

写入内容 func (f *File) Write(b []byte) (n int, err error)

在offset位置写入内容 func (f *File) WriteAt(b []byte, off int64) (n int, err error)

写入字符 func (f *File) WriteString(s string) (ret int, err error)

Path包 # 

 //返回路径的最后一个元素
    fmt.Println(path.Base("./a/b/c"));
    //如果路径为空字符串，返回.
    fmt.Println(path.Base(""));
    //如果路径只有斜线，返回/
    fmt.Println(path.Base("///"));
 
    //返回等价的最短路径
    //1.用一个斜线替换多个斜线
    //2.清除当前路径.
    //3.清除内部的..和他前面的元素
    //4.以/..开头的，变成/
    fmt.Println(path.Clean("./a/b/../"));
 
    //返回路径最后一个元素的目录
    //路径为空则返回.
    fmt.Println(path.Dir("./a/b/c"));
 
    //返回路径中的扩展名
    //如果没有点，返回空
    fmt.Println(path.Ext("./a/b/c/d.jpg"));
 
    //判断路径是不是绝对路径
    fmt.Println(path.IsAbs("./a/b/c"));
    fmt.Println(path.IsAbs("/a/b/c"));
 
    //连接路径，返回已经clean过的路径
    fmt.Println(path.Join("./a", "b/c", "../d/"));
 
    //匹配文件名，完全匹配则返回true
    fmt.Println(path.Match("*", "a"));
    fmt.Println(path.Match("*", "a/b/c"));
    fmt.Println(path.Match("\\b", "b"));
 
    //分割路径中的目录与文件
    fmt.Println(path.Split("./a/b/c/d.jpg"));

filepath包 # 

   //返回所给路径的绝对路径
    path, _ := filepath.Abs("./1.txt");
    fmt.Println(path);
 
    //返回路径最后一个元素
    fmt.Println(filepath.Base("./1.txt"));
    //如果路径为空字符串，返回.
    fmt.Println(filepath.Base(""));
    //如果路径只有斜线，返回/
    fmt.Println(filepath.Base("///"));
 
    //返回等价的最短路径
    //1.用一个斜线替换多个斜线
    //2.清除当前路径.
    //3.清除内部的..和他前面的元素
    //4.以/..开头的，变成/
    fmt.Println(filepath.Clean("C:/a/b/../c"));
    fmt.Println(filepath.Clean("./1.txt"));
 
    //返回路径最后一个元素的目录
    //路径为空则返回.
    fmt.Println(filepath.Dir("./a/b/c"));
    fmt.Println(filepath.Dir("C:/a/b/c"));
 
    //返回链接文件的实际路径
    path2, _ := filepath.EvalSymlinks("1.lnk");
    fmt.Println(path2);
 
    //返回路径中的扩展名
    //如果没有点，返回空
    fmt.Println(filepath.Ext("./a/b/c/d.jpg"));
 
    //将路径中的/替换为路径分隔符
    fmt.Println(filepath.FromSlash("./a/b/c"));
 
    //返回所有匹配的文件
    match, _ := filepath.Glob("./*.go");
    fmt.Println(match);
 
    //判断路径是不是绝对路径
    fmt.Println(filepath.IsAbs("./a/b/c"));
    fmt.Println(filepath.IsAbs("C:/a/b/c"));
 
    //连接路径，返回已经clean过的路径
    fmt.Println(filepath.Join("C:/a", "/b", "/c"));
 
    //匹配文件名，完全匹配则返回true
    fmt.Println(filepath.Match("*", "a"));
    fmt.Println(filepath.Match("*", "C:/a/b/c"));
    fmt.Println(filepath.Match("\\b", "b"));
 
    //返回以basepath为基准的相对路径
    path3, _ := filepath.Rel("C:/a/b", "C:/a/b/c/d/../e");
    fmt.Println(path3);
 
    //将路径使用路径列表分隔符分开，见os.PathListSeparator
    //linux下默认为:，windows下为;
    fmt.Println(filepath.SplitList("C:/windows;C:/windows/system"));
 
    //分割路径中的目录与文件
    dir, file := filepath.Split("C:/a/b/c/d.jpg");
    fmt.Println(dir, file);
 
    //将路径分隔符使用/替换
    fmt.Println(filepath.ToSlash("C:/a/b"));
 
    //返回分区名
    fmt.Println(filepath.VolumeName("C:/a/b/c"));
 
    //遍历指定目录下所有文件
    filepath.Walk("./", func(path string, info os.FileInfo, err error) error {
        fmt.Println(path);
        return nil;
    });