2018年5月

Golang进阶-io操作

1. I/O操作也叫输入输出操作。I指Input,O指Output;用于读写数据的，有些语言也叫流操作，是指数据通信的通道；

2. io包里最重要的是两个接口：Reader和Writer接口

3. Reader接口

type Reader interface {
    Read(p []byte) (n int, err error)
}
它返回读取的字节数（0 <= n <= len（p））和遇到的任何错误

4. 读取本地aa.txt文件的数据 (asdfgryuio)

  • 打开文件
fileName := "E:/GoPath/src/a/aa.txt"
    file, err := os.Open(fileName)
    if err != nil {
        fmt.Println("err: ", err)
        return
    }
  • 读取数据
//读取数据
    bs := make([]byte, 4, 4)
    //第一次读取
    n, err := file.Read(bs)
    fmt.Println(err)//<nil>
    fmt.Println(n)//4
    fmt.Println(bs)//[97 115 100 102]返回的是每个元素的字节编码数值
    fmt.Println(string(bs))//asdf

    //第二次读取
    n, err = file.Read(bs)
    fmt.Println(err)//<nil>
    fmt.Println(n)//4
    fmt.Println(bs)//[103 114 121 117]返回的是每个元素的字节编码数值
    fmt.Println(string(bs))//gryu

    //第三次读取
    n, err = file.Read(bs)
    fmt.Println(err)//<nil>
    fmt.Println(n)//2
    fmt.Println(bs)//[105 111 121 117]返回的是每个元素的字节编码数值
    fmt.Println(string(bs))//ioyu


    //第四次读取
    n, err = file.Read(bs)
    fmt.Println(err)//EOF
    fmt.Println(n)//0

//读取数据
    bs := make([]byte, 4, 4)
    n := -1
    for  {
        n, err = file.Read(bs)
        if  n == 0 || err == io.EOF{
            fmt.Println("到了文件末尾，结束读取...")
            break
        }
        fmt.Println(string(bs[:n]))

    }
  • 关闭文件
//可以用defer先关闭掉，以防漏写，造成资源泄露
    defer file.Close()

5. Writer接口

type Writer interface {
    Write(p []byte) (n int, err error)
}

6. 写入到本地文件ab.txt

  • 打开文件（已存在的文件用open，不存在的用openFile）
//file, err := os.Open(fileName)
    file, err := os.OpenFile(fileName, os.O_CREATE|os.O_WRONLY|os.O_APPEND, os.ModePerm)


    if err != nil {
        fmt.Println("err: ", err)
        return
    }
  • 关闭文件 (以防忘掉，造成资源泄露)
defer file.Close()
  • 写入内容
//写入数据
    //bs := []byte{65,66,67,68,69,70}
    bs := []byte{97,98,99,100}
    //n,err := file.Write(bs)
    n,err := file.Write(bs[:2])
    fmt.Println(n)
    HandleErr(err)
    file.WriteString("\n")

    //直接写出字符串
    n,err = file.WriteString("Hello world")
    fmt.Println(n)
    HandleErr(err)
    file.WriteString("\n")

    //切片也可以直接写入字符串
    n,err = file.Write([]byte("totay"))
    fmt.Println(n)
    HandleErr(err)

func HandleErr(err error){
    if err != nil {
        log.Fatal(err)
    }
}

7. writeAt方法指定从什么位置开始写，对应readAt从什么位置开始读

Golang进阶-file文件操作

1.file类是在os包中，封装了底层的文件描述符和相关信息，同时封装了Read和Write的实现;

2.文件信息通过一个接口来实现：FileInfo；如何操作这个接口的方法呢：os.Stat获取fileinfo的返回值

type FileInfo interface {
    Name() string       // base name of the file 文件名. 扩展名
    Size() int64        // 文件大小
    Mode() FileMode     // 文件权限
    ModTime() time.Time // 修改时间
    IsDir() bool        // 是否是文件
    Sys() interface{}   // 基础数据源接口(can return nil)
}

fileinfo, err := os.Stat("E:/GoPath/src/a/aa.txt")
if err != nil {
    fmt.Println("err: ", err)
}
fmt.Printf("%T\n",fileinfo)

//文件名
fmt.Println(fileinfo.Name())
//大小
fmt.Println(fileinfo.Size())
//是否是目录
fmt.Println(fileinfo.IsDir())
//修改时间
fmt.Println(fileinfo.ModTime())
//权限
fmt.Println(fileinfo.Mode())

3文件操作

  • 路径操作
fileName1 := "E:/GoPath/src/a/aa.txt"
//路径：是否是绝对路径
fmt.Println(filepath.IsAbs(fileName1))

//绝对路径
fmt.Println(filepath.Abs(fileName1))

//上级路径
fmt.Println(path.Join(fileName1,".."))
  • 创建目录
//Mkdir只能创建一层目录
err := os.Mkdir("E:/GoPath/src/b", os.ModePerm)
if err != nil {
    fmt.Println("err: ", err)
    return
}
fmt.Println("创建b目录成功")

//MkdirAll能创建多层
err := os.MkdirAll("E:/GoPath/src/a/cc/dd/ee", os.ModePerm)
if err != nil {
    fmt.Println("err: ", err)
    return
}
fmt.Println("多层目录创建成功")
  • 创建文件
//创建文件: create采用模式06666（任何人可读写，不可执行），已存在的文件会截断（内容清空），不存在则新建
file1, err := os.Create("E:/GoPath/src/a/ab.txt")
if err != nil {
    fmt.Println("err: ", err)
}
fmt.Println(file1)
  • 打开文件
//文件权限
const (
    // Exactly one of O_RDONLY, O_WRONLY, or O_RDWR must be specified.
    O_RDONLY int = syscall.O_RDONLY // open the file read-only.
    O_WRONLY int = syscall.O_WRONLY // open the file write-only.
    O_RDWR   int = syscall.O_RDWR   // open the file read-write.
    // The remaining values may be or'ed in to control behavior.
    O_APPEND int = syscall.O_APPEND // append data to the file when writing.
    O_CREATE int = syscall.O_CREAT  // create a new file if none exists.
    O_EXCL   int = syscall.O_EXCL   // used with O_CREATE, file must not exist.
    O_SYNC   int = syscall.O_SYNC   // open for synchronous I/O.
    O_TRUNC  int = syscall.O_TRUNC  // truncate regular writable file when opened.
)

//只读
file3, err := os.Open("E:/GoPath/src/a/ab.txt")
if err != nil {
    fmt.Println("err: ", err)
}
fmt.Println(file3)

//指定权限: (文件名称，文件的打开方式，文件的的权限：打开的文件如果不存在，so需要指定权限)
file4, err := os.OpenFile("E:/GoPath/src/a/ab.txt", os.O_RDONLY|os.O_WRONLY, os.ModePerm)
if err != nil {
    fmt.Println("err: ", err)
}
fmt.Println(file4)
  • 关闭文件：文件名称.Close()
  • 删除文件或文件夹
err := os.Remove("E:/GoPath/src/a/aa.txt")
    if err != nil {
        fmt.Println("err: ", err)
        return
    }

fmt.Println("删除文件成功")

//强制删除，所有
err := os.RemoveAll("E:/GoPath/src/a/cc/dd")
    if err != nil {
        fmt.Println("err: ", err)
        return
    }

fmt.Println("删除多层文件夹成功")