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  // 如果可能，打开时清空文件
)

r ——> 004
w ——> 002
x ——> 001

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    // file, err := os.Open("./test.txt")
    file, err := os.OpenFile("./test.txt", os.O_CREATE|os.O_RDONLY, 0666)
    if err != nil {
        fmt.Println("Open file error: ", err)
        return
    }
    defer file.Close()    //关闭文件

    reader := bufio.NewReader(file)    //带缓冲区的读写
    for {
        str, err := reader.ReadString('n')    // 以n为分隔符来读取
        if err != nil {
            fmt.Println("read string failed, err: ", err)
            return
        }
        fmt.Println("read string is %s: ", str)
    }
}

package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
)

func main() {
    file, err := os.Open("./test.txt")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer file.Close()
    reader := bufio.NewReader(file)
    
    for {
  //ReadLine是一个低水平的行数据读取原语。大多数调用者应使用ReadBytes('n')或ReadString('n')代替，或者使用Scanner。

ReadLine尝试返回一行数据，不包括行尾标志的字节。如果行太长超过了缓冲，返回值isPrefix会被设为true，并返回行的前面一部分。该行剩下的部分将在之后的调用中返回。返回值isPrefix会在返回该行最后一个片段时才设为false。返回切片是缓冲的子切片，只在下一次读取操作之前有效。ReadLine要么返回一个非nil的line，要么返回一个非nil的err，两个返回值至少一个非nil。

返回的文本不包含行尾的标志字节（"rn"或"n"）。如果输入流结束时没有行尾标志字节，方法不会出错，也不会指出这一情况。在调用ReadLine之后调用UnreadByte会总是吐出最后一个读取的字节（很可能是该行的行尾标志字节），即使该字节不是ReadLine返回值的一部分。
        data, prefix, err := reader.ReadLine()
        if err == io.EOF {
            break
        }
        if !prefix {
               fmt.Printf("%sn", string(data))
        }

    }
}

package main

import (
    "fmt"
    "io/ioutil"
)

func main() {
    file := "./test.txt"
    content, err := ioutil.ReadFile(file)
    if err != nil {                                                                                                                  
        fmt.Println("read err:", err)
    }   
    fmt.Println(string(content))
}

package main

import (
    "fmt"
    "os"
)

func main() {
    fileName := "/tmp/test_write"

    file, err := os.OpenFile(fileName, os.O_CREATE|os.O_WRONLY, 0755)
    if err != nil {
        fmt.Println("error", err)
        os.Exit(1)
    }
    defer file.Close()

    fileString := "Today is very happy."
    file.Seek(0, 2)    // 最后追加
    file.WriteString(fileString)
    //file.Write([]byte(fileString))
}

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    fileName := "test.txt"

    file, err := os.OpenFile(fileName, os.O_CREATE|os.O_WRONLY, 0755)
    if err != nil {
        fmt.Println("error", err)
        os.Exit(1)
    }
    defer file.Close()

    fileWrite := bufio.NewWriter(file)
    fileString := "good.n"
    for i := 0; i < 10; i++ {
        fileWrite.WriteString(fileString)
    }
//writer是带缓存，因此在调用WrteString方法时，其实内容是先写入缓存的，所以需要调用Flush方法，将缓存中的数据真正的写入到文件中，否则文件中没有数据
    fileWrite.Flush()
}

package main

import (
    "fmt"
    "io"
    "os"
)

func CopyFile(dstName, srcName string) (writeen int64, err error) {
    src, err := os.Open(dstName)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer src.Close()

    dst, err := os.OpenFile(srcName, os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer dst.Close()

    return io.Copy(dst, src)
}

func main() {
    CopyFile("./test.txt", "/test_copy.txt")
    fmt.Println("copy done.")
}

func PathExists(path string) (bool, error) {
    /*
    判断文件或文件夹是否存在
    如果返回的错误为nil,说明文件或文件夹存在
    如果返回的错误类型使用os.IsNotExist()判断为true,说明文件或文件夹不存在
    如果返回的错误为其它类型,则不确定是否在存在
    */
    _, err := os.Stat(path)
    if err == nil {
        return true, nil
    }
    if os.IsNotExist(err) {
        return false, nil
    }
    return false, err
}