fs

文件操作	描述
os.Create	创建文件
os.IsNotExist	判断文件是否存在
os.MkdirAll	创建目录
os.OpenFile	文件读取
os.Remove	删除文件
os.RemoveAll	删除文件

文件信息

os.Stat

os.Stat函数用于获取文件属性，返回描述文件信息的fs.FileInfo类型值，通过它可以获取对应接口信息。错误底层类型为*PathError。

func Stat(name string) (FileInfo, error)

若指定的文件对象是一个符号链接，则返回的FileInfo会描述改符号链接指向文件的信息。

os.FileInfo

os.FileInfo接口用来描述一个文件对象，实际是fs包中fs.FileInfo的别名。

type FileInfo = fs.FileInfo

fs包的fs.FileInfo接口

// A FileInfo describes a file and is returned by Stat.
type FileInfo interface {
    Name() string       // base name of the file
    Size() int64        // length in bytes for regular files; system-dependent for others
    Mode() FileMode     // file mode bits
    ModTime() time.Time // modification time
    IsDir() bool        // abbreviation for Mode().IsDir()
    Sys() interface{}   // underlying data source (can return nil)
}

接口	描述
Name() string	获取文件名称
Size() int64	文件字节大小
Mode() FileMode	文件的模式位
ModTime() time.Time	文件修改时间
IsDir() bool	是否为文件夹，等同于Mode().IsDir()
Sys() interface{}	地城数来源

例如：获取当前脚本信息

//获取当前文件
_,file,_,_ := runtime.Caller(0)
fmt.Println(file)
//获取文件信息
fi,err := os.Stat(file)
if err!=nil {
    log.Fatalln(err)
}
fmt.Printf("filename: %s\n", fi.Name())
fmt.Printf("filesize: %d\n", fi.Size())
fmt.Printf("filemode: %v\n", fi.Mode())
fmt.Printf("modtime: %v\n", fi.ModTime())
fmt.Printf("isdir: %v\n", fi.IsDir())
fmt.Printf("sys: %v\n", fi.Sys())

F:/Go/project/test/main.go
filename: main.go
filesize: 455
filemode: -rw-rw-rw-
modtime: 2021-12-26 12:57:25.0439303 +0800 CST
isdir: false
sys: &{32 {557161308 30931096} {322441693 30931477} {318463111 30931477} 0 455}

文件存在 os.IsNotExist

os.IsNotExists()接收一个错误对象来判断一个文件或目录是否不存在，最终返回布尔值。

func IsNotExist(err error) bool

例如：判断文件是否存在

//判断文件是否存在
func FileExists(file string) bool {
    _,err := os.Stat(file)
    if os.IsNotExist(err) {
        return false
    }
    return true
}

文件存在 os.IsExist

os.IsExists()接收一个错误对象来判断一个文件或目录是否存在，最终返回布尔值。

func IsExist(err error) bool

例如：判断文件是否存在

//判断文件是否存在
func FileExists(file string) bool {
    if _,err := os.Stat(file); os.IsExist(err) {
        return true
    }
    return false
}

创建目录

os.Mkdir

os.Mkdir()用于创建单级目录，该目录具有FileMode权限，当创建一个已存在的目录时会报错。

func Mkdir(name string, perm FileMode) error

fs包中的FileMode对应的是一个uint32类型

package os
type FileMode = fs.FileMode

package fs
type FileMode uint32

package os
ModePerm = fs.ModePerm // Unix permission bits, 0o777

package fs
ModePerm FileMode = 0777 // Unix permission bits

例如：在当前目录下创建名为tmp的临时目录，并设置权限位0777。

var pathSeparator string
if os.IsPathSeparator('\\') {
    pathSeparator = "\\"
}else {
    pathSeparator = "/"
}

pwd,err := os.Getwd()
if err!=nil{
    log.Fatalln(err)
    return
}

pwdPath := pwd + pathSeparator
dirPath := pwdPath + "tmp"

err = os.Mkdir(dirPath, os.ModePerm)
if err!=nil {
    log.Fatalln(err)
    return
}

若待创建的目录已经存在则会出现错误

2021/12/26 16:30:04 mkdir F:\Go\project\test\tmp: Cannot create a file when that file already exists.

因此创建前必须判断目录是否存在，若存在则修改权限，否则创建。

_,err = os.Stat(dirPath)
if err!=nil {
    if os.IsNotExist(err) {
        if err:=os.Mkdir(dirPath, os.ModePerm); err!=nil{
            log.Println(err)
        }
    }
}else{
    if err = os.Chmod(dirPath, os.ModePerm); err!=nil{
        log.Println(err)
    }
}

os.MkdirAll

os.MkdirAll()用于循环创建多级目录，作用类似命令mkdir -p。

例如：创建多级目录

var ps string
if os.IsPathSeparator('\\') {
    ps = "\\"
}else {
    ps = "/"
}

pwd,err := os.Getwd()
if err!=nil{
    log.Fatalln(err)
    return
}

dirPath := pwd + ps + "tmp" + ps + time.Now().Format("20060102") + ps

_,err = os.Stat(dirPath)
if err!=nil {
    if os.IsNotExist(err) {
        if err:=os.MkdirAll(dirPath, os.ModePerm); err!=nil{
            log.Println(err)
        }
    }
}else{
    if err = os.Chmod(dirPath, os.ModePerm); err!=nil{
        log.Println(err)
    }
}

文件打开

os.Open

os.Open会打开一个文件用来读取。若打开成功则会返回文件对象，对应的文件描述符具有O_RDONLY只读模式，使用返回的文件对象可用于读取数据。若打开出错，返回的错误对象底层类型为*PathError。

func Open(name string) (*File, error) {
    return OpenFile(name, O_RDONLY, 0)
}

os.OpenFile

os.OpenFile是相对底层的文件打开函数，使用时建议优先采用os.Open或os.Create。os.OpenFile支持使用指定模式和权限打开文件，打开成功则返回文件描述符可用于I/O，

func OpenFile(name string, flag int, perm FileMode) (*File, error) {
    testlog.Open(name)
    f, err := openFileNolog(name, flag, perm)
    if err != nil {
        return nil, err
    }
    f.appendMode = flag&O_APPEND != 0

    return f, nil
}

参数	描述
name	文件名称，若不在当前路径下运行则需添加具体路径。
flag	打开标记/打开方式/文件处理参数
perm	权限控制，Windows无效。

打开标记 flag

打开标记	描述
O_RDONLY	以只读模式打开文件
O_WRONLY	以只写模式打开文件
O_RDWR	以读写模式打开文件
O_APPEND	以追加模式打开文件，即写操作时将数据附加到文件末尾。
O_CREATE	若文件不存在则创建
O_EXCL	与O_CREATE配合用于新建文件，文件必须不存在有效，若文件存在则出错。
O_SYNC	以同步方式打开，不使用缓存直接写入磁盘，在一系列写操作时每次都要等待上次I/O操作完成后才能再继续。
O_TRUNC	打开时清空文件

• 若文件已存在则打开失败

os.O_WRONLY|os.O_CREATE|os.O_EXCL

• 若文件已存在则覆盖式写入，不会清空原文件，而是从头直接覆盖写入。

os.O_WRONLY|os.O_CREATE

• 若文件已存在则向尾部添加来写入

os.O_WRONLY|os.O_CREATE|os.O_APPEND

权限控制 perm

os.FileMode代表文件模式和权限位，不同字位在所有操作系统中都具有相同的含义，因此文件信息可以在不同操作系统之间安全移植。但并不是所有位都能用于所有的操作系统，唯一共有的是用于表示目录的ModeDir位。

文件权限	描述
os.ModeDir	文件夹模式
os.ModeAppend	追加模式
os.ModeExclusive	单独使用
os.ModeTemporary	临时文件
os.ModeSymlink	象征性的关联
os.ModeDevice	设备文件
os.NamePipe	命令管道
os.ModeSocket	UNIX主机套接字
os.ModeSetuid	设置uid
os.ModeSetgid	设置gid
os.ModeCharDevice	UNIX字符设备，当设备模式为set时。
os.ModeSticky	粘性模式
os.Irregular	非常规模式
os.ModeType	比特位覆盖
os.ModePerm	权限位

例如：创建文件并追加内容

//创建文件并追加内容
func FileAppend(name string, content string) (int, error){
    f,err := os.OpenFile(name, os.O_CREATE|os.O_RDWR|os.O_APPEND, os.ModeAppend | os.ModePerm)
    if err!=nil {
        return 0,err
    }
    defer f.Close()

    n,err := f.WriteString(content)
    if err!=nil{
        return 0, err
    }
    return n, nil
}

func main(){
    n,err := FileAppend("file.txt", "hello world")
    if err!=nil {
        fmt.Println(err)
        return
    }
    fmt.Println(n)
}

例如：同时创建多级目录和其下的文件

//同时创建多级目录及其下文件
func Mkfile(dirpath string, filename string, content string) error {
    err := os.MkdirAll(dirpath, os.ModePerm)
    log.Println(1, err)
    if err!=nil {
        return err
    }

    filename = path.Join(dirpath, filename)
    f,err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
    log.Println(2, err)
    defer f.Close()
    if err!=nil {
        return err
    }

    _,err = f.WriteString(content)
    log.Println(3, err)
    if err!=nil {
        return err
    }

    return nil
}

os.File

• os.File代表一个打开的文件对象句柄，即文件描述符。

type File struct {
    *file // os specific
}

关闭文件 os.Close

os.Close()用于关闭文件描述符，使文件不能读写。

func (f *File) Close() error {
    if f == nil {
        return ErrInvalid
    }
    return f.file.close()
}

创建文件 os.Create

os.Create()采用0666(任何人都可读可写但不可执行)权限模式来创建文件，若文件存在则会截断，若文件存在且已有内存则文件会被清空。

• 创建成功，会返回文件对象用于I/O操作，对应的文件描述符具有O_RDWR模式。
• 创建失败，错误原因可能是路径不存在、权限不足、打开文件数量超过上限、磁盘空间不足等，错误底层类型为*PathError。

func Create(name string) (*File, error) {
    return OpenFile(name, O_RDWR|O_CREATE|O_TRUNC, 0666)
}

例如：

f,err := os.Create("file.txt")
defer f.Close()
if err!=nil {
    fmt.Println(err)
    return
}
fmt.Println(f)