脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 脚本专栏 → Golang → Go IO操作输入输出API

Go语言IO输入输出底层原理及文件操作API

 更新时间：2023年01月08日 10:41:54   作者：夏沫的梦  
这篇文章主要为大家介绍了Go语言IO输入输出底层原理及文件操作API示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪

1.输入输出的底层原理

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

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

以文件的方式操作终端:

package main
import "os"
func main() {
    var buf [16]byte
    os.Stdin.Read(buf[:])
    os.Stdin.WriteString(string(buf[:]))
}

2. 文件操作相关API

  • func Create(name string) (file *File, err Error) 根据提供的文件名创建新的文件，返回一个文件对象，默认权限是0666
  • func NewFile(fd uintptr, name string) *File 根据文件描述符创建相应的文件，返回一个文件对象
  • func Open(name string) (file *File, err Error) 只读方式打开一个名称为name的文件
  • func OpenFile(name string, flag int, perm uint32) (file *File, err Error) 打开名称为name的文件，flag是打开的方式，只读、读写等，perm是权限
  • func (file *File) Write(b []byte) (n int, err Error) 写入byte类型的信息到文件
  • func (file *File) WriteAt(b []byte, off int64) (n int, err Error) 在指定位置开始写入byte类型的信息
  • func (file *File) WriteString(s string) (ret int, err Error) 写入string信息到文件
  • func (file *File) Read(b []byte) (n int, err Error) 读取数据到b中
  • func (file *File) ReadAt(b []byte, off int64) (n int, err Error) 从off开始读取数据到b中
  • func Remove(name string) Error 删除文件名为name的文件

3. 打开和关闭文件

os.Open()函数能够打开一个文件，返回一个*File和一个err。对得到的文件实例调用close()方法能够关闭文件。

package main
import (
    "fmt"
    "os"
)
func main() {
    // 只读方式打开当前目录下的main.go文件
    file, err := os.Open("./main.go")
    if err != nil {
        fmt.Println("open file failed!, err:", err)
        return
    }
    // 关闭文件
    file.Close()
}

4. 写文件

package main
import (
    "fmt"
    "os"
)
func main() {
    // 新建文件
    file, err := os.Create("./xxx.txt")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer file.Close()
    for i := 0; i < 5; i++ {
        file.WriteString("ab\n")
        file.Write([]byte("cd\n"))
    }
}

5. 读文件

文件读取可以用file.Read()和file.ReadAt()，读到文件末尾会返回io.EOF的错误

package main
import (
    "fmt"
    "io"
    "os"
)
func main() {
    // 打开文件
    file, err := os.Open("./xxx.txt")
    if err != nil {
        fmt.Println("open file err :", err)
        return
    }
    defer file.Close()
    // 定义接收文件读取的字节数组
    var buf [128]byte
    var content []byte
    for {
        n, err := file.Read(buf[:])
        if err == io.EOF {
            // 读取结束
            break
        }
        if err != nil {
            fmt.Println("read file err ", err)
            return
        }
        content = append(content, buf[:n]...)
    }
    fmt.Println(string(content))
}

6. 拷贝文件

package main
import (
    "fmt"
    "io"
    "os"
)
func main() {
    // 打开源文件
    srcFile, err := os.Open("./xxx.txt")
    if err != nil {
        fmt.Println(err)
        return
    }
    // 创建新文件
    dstFile, err2 := os.Create("./abc2.txt")
    if err2 != nil {
        fmt.Println(err2)
        return
    }
    // 缓冲读取
    buf := make([]byte, 1024)
    for {
        // 从源文件读数据
        n, err := srcFile.Read(buf)
        if err == io.EOF {
            fmt.Println("读取完毕")
            break
        }
        if err != nil {
            fmt.Println(err)
            break
        }
        //写出去
        dstFile.Write(buf[:n])
    }
    srcFile.Close()
    dstFile.Close()
}

7. bufio

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

os.O_WRONLY //只写 os.O_CREATE //创建文件 os.O_RDONLY //只读

os.O_RDWR //读写 os.O_TRUNC //清空 os.O_APPEND //追加

  • bufio读数据
package main
import (
    "bufio"
    "fmt"
    "io"
    "os"
)
func wr() {
    // 参数2：打开模式，所有模式d都在上面
    // 参数3是权限控制
    // w写 r读 x执行   w  2   r  4   x  1
    file, err := os.OpenFile("./xxx.txt", 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 re() {
    file, err := os.Open("./xxx.txt")
    if err != nil {
        return
    }
    defer file.Close()
    reader := bufio.NewReader(file)
    for {
        line, _, err := reader.ReadLine()
        if err == io.EOF {
            break
        }
        if err != nil {
            return
        }
        fmt.Println(string(line))
    }
}
func main() {
    re()
}

以上就是Go语言IO输入输出底层原理及文件操作API的详细内容，更多关于Go IO操作输入输出API的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

相关文章

  • 特殊字符的json序列化总结大全

    特殊字符的json序列化总结大全

    这篇文章主要给大家介绍了关于特殊字符的json序列化的相关资料，通过示例代码分别给大家介绍了关于python 、 rust 、 java 和golang对特殊字符的json序列化操作，需要的朋友可以参考借鉴，下面来一起学习学习吧
    2018-09-09
  • Go语言中的字符串拼接方法详情

    Go语言中的字符串拼接方法详情

    本文介绍Go语言中的string类型、strings包和bytes.Buffer类型，介绍几种字符串拼接方法的相关资料,需要的朋友可以参考一下，希望对你有所帮助
    2021-10-10
  • golang为什么要统一错误处理

    golang为什么要统一错误处理

    这篇文章主要介绍了golang为什么要统一错误处理，统一错误处理的目的是为了前端开发接收到后端的statuscode,之后便于前端逻辑上开发以及开发，下文具体操作过程需要的小伙伴可以参考一下
    2022-04-04
  • 解读rand.Seed(time.Now().UnixNano())的作用及说明

    解读rand.Seed(time.Now().UnixNano())的作用及说明

    这篇文章主要介绍了关于rand.Seed(time.Now().UnixNano())的作用及说明，具有很好的参考价值，希望对大家有所帮助。
    2023-03-03
  • go 代码的调试---打印调用堆栈的实例

    go 代码的调试---打印调用堆栈的实例

    下面小编就为大家带来一篇go 代码的调试---打印调用堆栈的实例。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2017-10-10
  • Go语言线程安全之互斥锁与读写锁

    Go语言线程安全之互斥锁与读写锁

    这篇文章主要介绍了Go语言线程安全之互斥锁与读写锁,互斥锁是为了并发的安全,在多个goroutine共同工作的时候,对于共享的数据十分不安全,而读写锁效率革命，使用锁的时候，安全与效率往往需要互相转换，下文详细内容，需要的小伙伴可以参考一下
    2022-02-02
  • 使用go gin来操作cookie的讲解

    使用go gin来操作cookie的讲解

    今天小编就为大家分享一篇关于使用go gin来操作cookie的讲解，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
    2019-04-04
  • 深度解密 Go 语言中的 sync.Pool

    深度解密 Go 语言中的 sync.Pool

    sync.Pool 是 sync 包下的一个组件，可以作为保存临时取还对象的一个“池子”。这篇文章主要介绍了深度解密 Go 语言中的sync.Pool，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2020-04-04
  • 提升Go语言开发效率的小技巧实例(GO语言语法糖)汇总

    提升Go语言开发效率的小技巧实例(GO语言语法糖)汇总

    这篇文章主要介绍了提升Go语言开发效率的小技巧汇总,也就是Go语言的语法糖，掌握好这些可以提高我们的开发效率，需要的朋友可以参考下
    2022-11-11
  • 一文了解Go语言的并发特性

    一文了解Go语言的并发特性

    本文主要介绍了一文了解Go语言的并发特性,通过轻量级线程、通道及选择语句,使得并发编程变得既简单又高效,下面就来具体了解一下如何使用,感兴趣的可以了解一下
    2024-02-02

最新评论