go标准库的学习-os

参考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' '