参考https://studygolang.com/pkgdoc
导入方式：
import "os"
os包提供了操作系统函数的不依赖平台的接口
一开始简单举个例子：
package main
import(
"fmt"
"os"
"log"
)
func main() {
file, err := os.Open("test.txt")
if err != nil{
log.Fatal(err)
}
data := make([]byte, )
count, err := file.Read(data)
if err != nil {
log.Fatal(err)
}
fmt.Printf("read %d bytes: %q\n", count, data[:count])
}
因为没有file.txt这个文件，所以会返回：
userdeMBP:go-learning user$ go run test.go
// :: open test.txt: no such file or directory
exit status
在当前目录生成一个test.txt文件：
hello
what do you want
no thanks
然后再运行返回：
userdeMBP:go-learning user$ go run test.go
read bytes: "hello\nwhat do you want\nno thanks"
1.const常量
1）
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 // 打开文件用于同步I/O
O_TRUNC int = syscall.O_TRUNC // 如果可能，打开时清空文件
)
作为参数flag传输，用于包装底层系统的参数，说明使用什么模式打开文件
Open()函数默认使用的是flag == O_RDONLY，即只读模式，相当于OpenFile(name,O_RDONLY,0)
但是不是所有flag都能在特定系统中使用的
1》func Open
func Open(name string) (file *File, err error)
Open打开一个文件用于读取。如果操作成功，返回的文件对象的方法可用于读取数据；对应的文件描述符具有O_RDONLY模式。如果出错，错误底层类型是*PathError。如上面的例子所示
2》func OpenFile
func OpenFile(name string, flag int, perm FileMode) (file *File, err error)
OpenFile是一个更一般性的文件打开函数，大多数调用者都应用Open或Create代替本函数。它会使用指定的选项（如O_RDONLY等）、指定的模式FileMode（如0666,即可读写，但是不可执行）打开指定名称的文件。如果操作成功，返回的文件对象可用于I/O。如果出错，错误底层类型是*PathError。
参数flag可以结合使用：
os.O_WRONLY | os.O_CREATE | O_EXCL //如果已经存在，则失败
os.O_WRONLY | os.O_CREATE //如果已经存在，会覆盖写，不会清空原来的文件，而是从头直接覆盖写
os.O_WRONLY | os.O_CREATE | os.O_APPEND //如果已经存在，则在尾部添加写
参数perm：
linux中的权限rwx分别对应4 2 1，相加的值为7。如0666,即可读写，但是不可执行
下面的例子设置为不可写，然后进行写操作时会出错：
package main
import(
"fmt"
"os"
"log"
)
func main() {
file, err := os.OpenFile("test.txt", os.O_RDONLY, ) //只可读、执行，不可写
if err != nil{
log.Fatal(err)
}
defer file.Close() data1 := []byte("add something to test.txt")
number, err := file.Write(data1)
if err != nil{
log.Fatal(err)
}
fmt.Printf("successfully add %d bytes: %q\n", number, data1[:number]) data := make([]byte, )
count, err := file.Read(data)
if err != nil {
log.Fatal(err)
}
fmt.Printf("read %d bytes: %q\n", count, data[:count]) }
出错：
userdeMBP:go-learning user$ go run test.go
// :: write test.txt: bad file descriptor
exit status
改权限：
file, err := os.OpenFile("test.txt", os.O_RDWR | os.O_APPEND, ) //可读写，且写的内容添加在末尾返回：
userdeMBP:go-learning user$ go run test.go
successfully add bytes: "add something to test.txt"
// :: EOF
exit status
返回EOF(end-of-file)的原因是上面的Write()运行完后指针指在文件终端，这个时候读取就读取不到数据
所以写完后想读应该重新调用一个Open()：
package main
import(
"fmt"
"os"
"log"
)
func main() {
file, err := os.OpenFile("test.txt", os.O_RDWR | os.O_APPEND, ) //可读写，且写的内容添加在末尾
if err != nil{
log.Fatal(err)
}
defer file.Close() data1 := []byte("add something to test.txt")
number, err := file.Write(data1)
if err != nil{
log.Fatal(err)
}
fmt.Printf("successfully add %d bytes: %q\n", number, data1[:number]) file1, err := os.Open("test.txt") //只读
data := make([]byte, )
count, err := file1.Read(data)
if err != nil {
log.Fatal(err)
}
fmt.Printf("read %d bytes: %q\n", count, data[:count])
defer file1.Close() }
返回：
userdeMBP:go-learning user$ go run test.go
successfully add bytes: "add something to test.txt"
read bytes: "hello\nwhat do you want\nno thanksadd something to test.txt"
3》func Create
func Create(name string) (file *File, err error)
Create采用模式0666（任何人都可读写，不可执行）创建一个名为name的文件，如果文件已存在会截断它（为空文件）。如果成功，返回的文件对象可用于I/O；对应的文件描述符具有O_RDWR模式。如果出错，错误底层类型是*PathError。举例说明：
package main
import(
"fmt"
"os"
"log"
)
func main() {
file, err := os.Create("testCreate.txt") //可读写，且写的内容添加在末尾
if err != nil{
log.Fatal(err)
}
defer file.Close() data1 := []byte("write something to testCreate.txt")
number, err := file.Write(data1)
if err != nil{
log.Fatal(err)
}
fmt.Printf("successfully write %d bytes: %q\n", number, data1[:number]) }
返回：
userdeMBP:go-learning user$ ls
hello.go test.go test.txt
userdeMBP:go-learning user$ go run test.go
successfully write bytes: "write something to testCreate.txt"
userdeMBP:go-learning user$ ls
hello.go test.go test.txt testCreate.txt
可见生成了一个testCreate.txt文件，并将相应的内容写入
2）
const (
SEEK_SET int = // 相对于文件起始位置seek
SEEK_CUR int = // 相对于文件当前位置seek
SEEK_END int = // 相对于文件结尾位置seek
)
用于Seek(offset int64, whence int)函数，指定从何处开始搜索（即相对位置whence）
func (*File) Seek
func (f *File) Seek(offset int64, whence int) (ret int64, err error)
Seek设置下一次读/写的位置。offset为相对偏移量，而whence决定相对位置：0为相对文件开头，1为相对当前位置，2为相对文件结尾。它返回新的偏移量（相对开头）和可能的错误。
举例说明：
package main
import(
"fmt"
"os"
"log"
)
func main() {
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close() set_offset, _ := file.Seek(, os.SEEK_SET)//从文件的起始位置偏移5
fmt.Println(set_offset) data := make([]byte, )
count, err := file.Read(data)
if err != nil{
log.Fatal(err)
}
fmt.Printf("Read %d bytes: %q\n", count, data[:count]) cur_offset, _ := file.Seek(, os.SEEK_CUR) //获得文件指针当前位置
fmt.Println(cur_offset)
}
返回：
userdeMBP:go-learning user$ go run test.go Read bytes: "\nwhat do y"
3）
const (
PathSeparator = '/' // 操作系统指定的路径分隔符
PathListSeparator = ':' // 操作系统指定的表分隔符
)
举例：
const DevNull = "/dev/null"
DevNull是操作系统空设备的名字。在类似Unix的操作系统中，是"/dev/null"；在Windows中，为"NUL"。
package main
import(
"fmt"
"os"
)
func main() {
fmt.Println(os.PathSeparator) //
fmt.Printf("%q\n", os.PathSeparator) //'/'
fmt.Println(os.PathListSeparator) //
fmt.Printf("%q\n", os.PathListSeparator) //':'
}
2.var变量
1）
var (
ErrInvalid = errors.New("invalid argument")
ErrPermission = errors.New("permission denied")
ErrExist = errors.New("file already exists")
ErrNotExist = errors.New("file does not exist")
)
一些可移植的、共有的系统调用错误。
package main
import(
"fmt"
"os"
)
func main() {
fmt.Println(os.ErrInvalid) //invalid argument
fmt.Println(os.ErrPermission) //permission denied
fmt.Println(os.ErrExist) //file already exists
fmt.Println(os.ErrNotExist) //file does not exist
}
2)
var (
Stdin = NewFile(uintptr(syscall.Stdin), "/dev/stdin")
Stdout = NewFile(uintptr(syscall.Stdout), "/dev/stdout")
Stderr = NewFile(uintptr(syscall.Stderr), "/dev/stderr")
)
syscall的额外知识：
var (
Stdin =
Stdout =
Stderr =
)
Stdin、Stdout和Stderr是指向标准输入、标准输出、标准错误输出的文件描述符。
package main
import(
"fmt"
"os"
)
func main() {
fmt.Println(os.Stdin) //&{0xc42008c000}
fmt.Println(os.Stdout) //&{0xc42008c050}
fmt.Println(os.Stderr) //&{0xc42008c0a0}
}
其中os.Stdout 和 os.Stderr实现了io.Writer,所以其可以使用Write();os.Stdin 实现了io.Reader,所以可以使用Read()
1》uintptr
uintptr是一种无符号的整数类型，没有指定具体的bit大小但是足以容纳指针,是能存储指针的整形。
uintptr类型只有在底层编程时才需要，特别是Go语言和C语言函数库或操作系统接口相交互的地方
2》func NewFile
func NewFile(fd uintptr, name string) *File
NewFile使用给出的Unix文件描述符和名称创建一个文件
这个函数并不是真正创建了一个文件，是新建一个文件，但是不保存，然后返回文件的指针
参数fd其实可以通过os.Fd()函数得到
3》func (*File) Fd
func (f *File) Fd() uintptr
Fd返回与文件f对应的整数类型的Unix文件描述符
Fd()举例：
package main
import(
"fmt"
"os"
"log"
"syscall"
)
func main() {
file, err := os.Open("test.txt")
if err != nil {
log.Fatal(err)
}
defer file.Close()
fmt.Printf("%q\n", file.Fd()) //'\x03'
fmt.Printf("%q\n", uintptr(syscall.Stdin)) //'\x00'
fmt.Printf("%q\n", uintptr(syscall.Stdout)) //'\x01'
fmt.Printf("%q\n", uintptr(syscall.Stderr)) //'\x02'
}
Fd()和NewFile():
package main
import(
"fmt"
"os"
"syscall"
"log"
)
func main() {
file := os.NewFile(uintptr(syscall.Stdin), "testNewFile.txt")
fmt.Printf("%q\n", file.Fd())
fmt.Printf("%q\n", file.Name())
fileInfo, err := file.Stat()
if err != nil{
log.Fatal(err)
}
fmt.Printf("%q\n", fileInfo)
}
返回：
userdeMBP:go-learning user$ go run test.go
'\x00'
"testNewFile.txt"
&{"testNewFile.txt" '\x00' %!q(os.FileMode=) {%!q(uint64=) %!q(int64=) %!q(*time.Location=&{ [] [] <nil>})} {%!q(int32=) '←' '\x01' 'ʍ' 'ǵ' '\x04' %!q(int32=) "\x00\x00\x00\x00" {%!q(int64=) %!q(int64=)} {%!q(int64=) %!q(int64=)} {%!q(int64=) %!q(int64=)} {'\x00' '\x00'} '\x00' '\x00' '