GO系列-IO 文件操作

os io

判断文件是否存在

func fileExist(filePath string) (bool, error) {
    _, err := os.Stat(filePath)
    if err == nil {
       return true, nil
    }

    if os.IsNotExist(err) {
       return false, nil
    }
    return false, &CheckFileExistError{filePath}
}

读取文件内容

func readFileContext(file *os.File) (string, error) {
    if file == nil {
       return "", nil
    }

    var buf [1024]byte
    var content []byte
    for {
       n, err := file.Read(buf[:])
       if err == io.EOF {
          //结尾
          break
       } else if err != nil {
          log.Println("Read file error", file.Name())
          return "", err
       }

       content = append(content, buf[:n]...)
    }
    return string(content), nil
}

创建文件&写入文件内容

// 如果不存在 则创建
if !exist {
    log.Println("create file:", filePath)
    newFile, err := os.Create(filePath)
    if err != nil {
       log.Panicln(err.Error())
    }
    // 写入文件
    newFile.WriteString("Hello word !!!\n")
    newFile.Write([]byte("happy every day\n"))
    newFile.Close()
}

打开文件

// 打开这个文件
file1, err := os.Open(filePath)
if err != nil {
    log.Panicln(err.Error())
}

关闭和删除文件

// 删除前关闭文件，否则报错
file1.Close()

// 删除文件
stat1, _ := file1.Stat()
if stat1 != nil {
    log.Println("file is not closed")
}
err = os.Remove(filePath)
if err != nil {
    log.Println("remove file error", filePath, err.Error())
}
log.Println("remove file success", filePath)

copy文件

func copyFile(filePath1 string, filePath2 string) error {
    exist, err := fileExist(filePath1)
    if err != nil {
       return err
    }

    if !exist {
       log.Println("file1 must exist ")
       return nil
    }

    file1, err := os.Open(filePath1)
    if err != nil {
       log.Println("open file1 error")
       return err
    }
    defer file1.Close()

    // 如果存在则删除
    exist, err = fileExist(filePath2)
    if err != nil {
       return err
    }
    if exist {
       os.Remove(filePath2)
    }

    file2, err := os.Create(filePath2)
    if err != nil {
       log.Println("create file2 error")
       return err
    }
    defer file2.Close()

    var buffer [1024]byte
    for {
       n, err := file1.Read(buffer[:])
       if err == io.EOF {
          log.Println("copy complete")
          break
       }
       if err != nil {
          log.Println("copy error")
          return err
       }
       file2.Write(buffer[:n])
    }

    return nil
}

综合示例

package main

import (
    "io"
    "log"
    "os"
)

type CheckFileExistError struct {
    FilePath string
}

func (err CheckFileExistError) Error() string {
    return "Check File[" + err.FilePath + "] Exist Error"
}

func fileExist(filePath string) (bool, error) {
    _, err := os.Stat(filePath)
    if err == nil {
       return true, nil
    }

    if os.IsNotExist(err) {
       return false, nil
    }
    return false, &CheckFileExistError{filePath}
}

func readFileContext(file *os.File) (string, error) {
    if file == nil {
       return "", nil
    }

    var buf [1024]byte
    var content []byte
    for {
       n, err := file.Read(buf[:])
       if err == io.EOF {
          //结尾
          break
       } else if err != nil {
          log.Println("Read file error", file.Name())
          return "", err
       }

       content = append(content, buf[:n]...)
    }
    return string(content), nil
}

func copyFile(filePath1 string, filePath2 string) error {
    exist, err := fileExist(filePath1)
    if err != nil {
       return err
    }

    if !exist {
       log.Println("file1 must exist ")
       return nil
    }

    file1, err := os.Open(filePath1)
    if err != nil {
       log.Println("open file1 error")
       return err
    }
    defer file1.Close()

    // 如果存在则删除
    exist, err = fileExist(filePath2)
    if err != nil {
       return err
    }
    if exist {
       os.Remove(filePath2)
    }

    file2, err := os.Create(filePath2)
    if err != nil {
       log.Println("create file2 error")
       return err
    }
    defer file2.Close()

    var buffer [1024]byte
    for {
       n, err := file1.Read(buffer[:])
       if err == io.EOF {
          log.Println("copy complete")
          break
       }
       if err != nil {
          log.Println("copy error")
          return err
       }
       file2.Write(buffer[:n])
    }

    return nil
}

func main() {
    log.Println("main ...")

    filePath := "./test.txt"
    filePath2 := "./test2.txt"

    exist, err := fileExist(filePath)
    log.Println("file ", filePath, "exist:", exist)
    if err != nil {
       log.Println(err.Error())
    }

    // 如果不存在 则创建
    if !exist {
       log.Println("create file:", filePath)
       newFile, err := os.Create(filePath)
       if err != nil {
          log.Panicln(err.Error())
       }
       // 写入文件
       newFile.WriteString("Hello word !!!\n")
       newFile.Write([]byte("happy every day\n"))
       newFile.Close()
    }

    // 打开这个文件
    file1, err := os.Open(filePath)
    if err != nil {
       log.Panicln(err.Error())
    }

    // 读取文件原始内容
    context, err := readFileContext(file1)
    if err != nil {
       log.Panicln(err.Error())
    }
    log.Println("context:", context)

    // 删除前关闭文件，否则报错
    file1.Close()

    // copy文件
    copyFile(filePath, filePath2)

    // 删除文件
    stat1, _ := file1.Stat()
    if stat1 != nil {
       log.Println("file is not closed")
    }
    err = os.Remove(filePath)
    if err != nil {
       log.Println("remove file error", filePath, err.Error())
    }
    log.Println("remove file success", filePath)

    log.Println("success ..")
}

bufio

bufio包实现了带缓冲区的读写，是对文件读写的封装

bufio缓冲写数据

模式含义

os.O_WRONLY 只写

os.O_CREATE 创建文件

os.O_RDONLY 只读

os.O_RDWR 读写

os.O_TRUNC 清空

os.O_APPEND 追加

package main

import (
    "bufio"
    "io"
    "log"
    "os"
)

// 写文件
func write(filePath string) {
    // 参数2：打开模式，所有模式d都在上面
    // 参数3是权限控制
    // w写 r读 x执行   w  2   r  4   x  1
    file, err := os.OpenFile(filePath, os.O_CREATE|os.O_WRONLY, 0666)
    if err != nil {
       return
    }
    defer file.Close()
    // 获取writer对象
    writer := bufio.NewWriter(file)
    for i := 0; i < 10; i++ {
       writer.WriteString("hello\n")
    }
    // 刷新缓冲区，强制写出
    writer.Flush()
}

// 读取文件
func read(filePath string) string {
    file, err := os.Open(filePath)
    if err != nil {
       return ""
    }
    defer file.Close()
    var content []byte
    reader := bufio.NewReader(file)
    for {
       line, _, err := reader.ReadLine()
       if err == io.EOF {
          break
       }
       if err != nil {
          return ""
       }
       content = append(content, []byte(string(line)+"\n")...)
    }
    return string(content)
}

func main() {
    log.Println("main ...")

    filePath := "./test1.txt"
    write(filePath)
    content := read(filePath)
    log.Println(content)

    log.Println("success ..")
}

ioutil

package main

import (
    "io/ioutil"
    "log"
)

func main() {
    log.Println("main ...")

    filePath := "./test1.txt"
    // 写文件
    err := ioutil.WriteFile(filePath, []byte("hello word"), 0666)
    if err != nil {
       log.Println(err)
       return
    }

    // 读取文件
    content, err := ioutil.ReadFile(filePath)
    if err != nil {
       log.Println(err)
       return
    }
    log.Println(string(content))

    log.Println("success ..")
}

控制台输入输出

终端其实是一个文件，相关实例如下：

os.Stdin：标准输入的文件实例，类型为*File

os.Stdout：标准输出的文件实例，类型为*File

os.Stderr：标准错误输出的文件实例，类型为*File

以文件的方式操作终端:

package main

import (
    "log"
    "os"
)

func main() {
    log.Println("main ...")

    var buf [16]byte
    // 从控制台读取一行数据
    os.Stdin.Read(buf[:])
    log.Println("read context:", string(buf[:]))

    // 写入到控制台
    os.Stdout.WriteString("hello word\n")

    log.Println("success ..")
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/975059.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！