go学习笔记04

文件

打开文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

//OpenFile能够提供细粒度的控制
func OpenFile(name string, flag int, perm FileMode) (*File, error)

// Open函数返回值一个文件指针和一个错误,是对OpenFile函数的一个简单封装。
//对文件只读
func Open(name string) (*File, error)

// 获取文件信息,不读取内容
func Stat(string)

// 关闭文件
defer file.Close()
 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

// 文件描述符
const (
   // 只读,只写,读写 三种必须指定一个
   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   // 以同步IO的方式打开文件
   O_TRUNC  int = syscall.O_TRUNC  // 当打开的时候截断可写的文件
)

// 文件权限
const (
   ModeDir        = fs.ModeDir        // d: 目录
   ModeAppend     = fs.ModeAppend     // a: 只能添加
   ModeExclusive  = fs.ModeExclusive  // l: 专用
   ModeTemporary  = fs.ModeTemporary  // T: 临时文件
   ModeSymlink    = fs.ModeSymlink    // L: 符号链接
   ModeDevice     = fs.ModeDevice     // D: 设备文件
   ModeNamedPipe  = fs.ModeNamedPipe  // p: 具名管道 (FIFO)
   ModeSocket     = fs.ModeSocket     // S: Unix 域套接字
   ModeSetuid     = fs.ModeSetuid     // u: setuid
   ModeSetgid     = fs.ModeSetgid     // g: setgid
   ModeCharDevice = fs.ModeCharDevice // c: Unix 字符设备, 前提是设置了 ModeDevice
   ModeSticky     = fs.ModeSticky     // t: 黏滞位
   ModeIrregular  = fs.ModeIrregular  // ?: 非常规文件

   // 类型位的掩码. 对于常规文件而言,什么都不会设置.
   ModeType = fs.ModeType

   ModePerm = fs.ModePerm // Unix 权限位, 0o777
)

读取文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
// 将文件读进传入的字节切片
func (f *File) Read(b []byte) (n int, err error)

// 相较于第一种可以从指定偏移量读取
func (f *File) ReadAt(b []byte, off int64) (n int, err error)

// os包,提供文件路径
func ReadFile(name string) ([]byte, error)

// io包
func ReadAll(r Reader) ([]byte, error)

写文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// os.Write 写入字节切片
func (f *File) Write(b []byte) (n int, err error)

// os.WriteString 写入字符串
func (f *File) WriteString(s string) (n int, err error)

// os.WriteAt 从指定位置开始写,当以os.O_APPEND模式打开时,会返回错误
func (f *File) WriteAt(b []byte, off int64) (n int, err error)

// os.WriteFile
func WriteFile(name string, data []byte, perm FileMode) error

// io.WriteString
func WriteString(w Writer, s string) (n int, err error)

重命名

1
func Rename(oldpath, newpath string) error

删除

1
2
3
4
5
// 删除单个文件或者空目录,当目录不为空时会返回错误
func Remove(name string) error

// 删除指定目录的所有文件和目录包括子目录与子文件
func RemoveAll(path string) error

反射

并发

go 对于并发的支持是纯天然的。

协程(coroutine)是一种轻量级的用户态线程,不受操作系统直接调度,由 Go 语言自身的调度器进行运行时调度,因此上下文切换开销非常小。

不要通过共享内存来通信,而要通过通信来共享内存,go并发哲学核心是channel。

comments powered by Disqus
使用 Hugo 构建
主题 StackJimmy 设计