Golang——IO操作

原创 已于 2025-05-09 20:24:22 修改
· 1.1k 阅读 · 19 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#golang

于 2024-05-08 17:40:05 首次发布

        1. 输入输出的底层原理

        终端其实是一个文件(Linux下一切皆文件)，相关实例如下：

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

        以文件方式操作终端：

package main

import (
	"os"
)

func main() {
	var buf []byte
	os.Stdin.Read(buf[:])             //从标准输入中读取
	os.Stdin.WriteString(string(buf)) //写入标准输入
}

        2. 文件操作相关API 

        根据提供的文件名创建新的文件，返回一个文件对象，默认权限0666，任何人可读可写，不可执行，如果文件存在，则会截断它(为空文件)，如果成功，返回的文件对象可用于I/O；对应的文件描述符具有O_RDWR模式。如果出错，错误底层类型是*PathError。

func Create(name string) (file *File, err error)

        NewFile使用给出的Unix文件描述符和名称创建一个文件。 

func NewFile(fd uintptr, name string) *File

        只读方式打开一个名称为name文件。

func Open(name string) (file *File, err error)

        打开一个名为name的文件，flag是打开方式，只读或只写，不存在创建等，perm文件权限。 

func OpenFile(name string, flag int, perm FileMode) (file *File, err error)

        在指定位置(相对于文件起始位置)，写入byte类型的数据到文件，它返回写入的字节数和可能遇到的任何错误。如果返回值n!=len(b)，本方法会返回一个非nil的错误。

func (f *File) WriteAt(b []byte, off int64) (n int, err error)

        向文件中写入string类型的信息到文件。

func (f *File) WriteString(s string) (ret int, err error)

        从f中读取最多len(b)字节数的数据到b。

func (f *File) Read(b []byte) (n int, err error)

        从f的指定位置(相对于文件起始位置)，读取len(b)字节数并写入b。

func (f *File) ReadAt(b []byte, off int64) (n int, err error)

       删除name指定的文件或目录。

func Remove(name string) error

 3. 打开和关闭文件

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

package main

import (
	"log"
	"os"
)

func main() {
	//只读的方式打开文件
	f, err := os.Open("./main.go")
	if err != nil {
		log.Println("open main.go file fail")
		return
	}
	//关闭文件
	defer f.Close()
}

4. 写文件

package main

import (
	"log"
	"os"
)

func main() {
	//可读可写的方式创建一个文件
	f, err := os.Create("./xx.txt")
	if err != nil {
		log.Println("create file fail")
		return
	}
	defer f.Close()

	for i := 0; i < 5; i++ {
		f.Write([]byte("ab\n"))
		f.WriteString("ab\n")
	}
}

5. 读文件

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

package main

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

func main() {
	f, err := os.Open("./xx.txt")
	if err != nil {
		log.Println("open file fail")
		return
	}
	defer f.Close()

	var content []byte
	for {
		var buf [128]byte
		n, err := f.Read(buf[:])
		if err == io.EOF {
			//读到文件末尾
			break
		}
		if err != nil {
			log.Println("Read file fail", err)
			return
		}
		content = append(content, buf[:n]...) //buf[:n]切片被打散传入
	}
	fmt.Println(string(content))
}

 “…”的用法：三个点“...”其实是go的一种语法糖（糖衣语法）

●　第一个用法主要是用于函数有多个不定参数的情况，表示为可变参数，可以接受任意个数但相同类型的参数。

●　第二个用法是slice可以被打散进行传递。

 6. 拷贝文件

package main

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

func main() {
	f1, err := os.Open("./xx.txt")
	if err != nil {
		log.Println("open xx.txt file fail", err)
		return
	}
	defer f1.Close()
	f2, err := os.Create("./abc.txt")
	if err != nil {
		log.Println("create file fail ", err)
		return
	}
	defer f2.Close()

	for {
		var buf [128]byte
		n, err := f1.Read(buf[:])
		if err == io.EOF {
			log.Println("读取完毕")
			break
		}
		if err != nil {
			return
		}

		f2.Write(buf[:n])
	}
}

7. bufio

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

  • bufio读数据 ，bufio先把数据读/写到缓冲区，达到某一上限，会刷新到文件中，也可以强制刷新。
package main

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

func wr() {
	f, err := os.OpenFile("./xxx.txt", os.O_CREATE|os.O_WRONLY, 0664)
	if err != nil {
		log.Println("open file fail ", err)
		return
	}
	defer f.Close()
    //获取writer对象
	writer := bufio.NewWriter(f)
	for i := 0; i < 5; i++ {
		writer.WriteString("hello\n")
	}
	//刷新缓冲区，强制写入
	writer.Flush()
}

func rd() {
	f, err := os.Open("./xxx.txt")
	if err != nil {
		log.Println("open file fail")
		return
	}
	defer f.Close()

    //获取reader对象
	reader := bufio.NewReader(f)
	var content []byte
	for {
		line, _, err := reader.ReadLine()
		if err == io.EOF {
			log.Println("读取完毕")
			break
		}
		if err != nil {
			return
		}
		content = append(content, line...)
	}
	fmt.Println(string(content))
}

func main() {
	wr()
	rd()
}

8. ioutil工具包

  • 工具包写文件
  • 工具包读文件
package main

import (
	"fmt"
	"io/ioutil"
	"log"
)

func wr() {
	err := ioutil.WriteFile("./xxxx.txt", []byte("hello world!"), 0666)
	if err != nil {
		log.Println("err")
		return
	}
}

func rd() {
	data, err := ioutil.ReadFile("./xxxx.txt")
	if err != nil {
		log.Println("err")
		return
	}
	fmt.Println(string(data))
}

func main() {
	wr()
	rd()
}

9. 例子

        实现cat命令

package main

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

func cat(reader *bufio.Reader) {
	for {
		buf, err := reader.ReadBytes('\n') //注意是字符
		if err == io.EOF {
			break
		}
		fmt.Fprintf(os.Stdout, "%s", string(buf))
	}
}

func main() {
	flag.Parse()
	if flag.NArg() == 0 {
		cat(bufio.NewReader(os.Stdin))
	} else {
		for i := 0; i < flag.NArg(); i++ {
			f, err := os.Open(flag.Arg(i))
			if err != nil {
				log.Printf("open file %s fail, err %v\n", flag.Arg(i), err)
				continue
			}
			cat(bufio.NewReader(f))
			f.Close()
		}
	}
}

10. bufio与ioutil区别

核心区别

特性bufioioutil（Go 1.16+ 由 os/io 替代）
功能定位带缓冲的 I/O 操作（提升性能、逐行处理）简单的文件 / 数据流操作（一次性读取 / 写入）
主要用途- 大文件逐行读取
- 高效读写数据流		- 小文件一次性读取
- 临时文件操作
核心类型bufio.Reader、bufio.Writeros.ReadFile、os.WriteFile、io.ReadAll
性能高（缓冲减少系统调用）低（频繁系统调用）
内存占用可控（自定义缓冲区大小）不可控（一次性加载整个文件）
适用场景大文件处理、网络流处理配置文件读取、临时数据写入

  1. 优先使用 bufio 的场景：

    • 处理大文件（如日志分析、CSV 解析）。
    • 网络 I/O（如 HTTP 请求 / 响应处理）。
    • 需要控制内存使用（避免一次性加载整个文件）。
    • 示例：逐行读取 1GB 的日志文件，使用 bufio.Scanner 内存占用稳定在几十 MB。

  2. 优先使用 os/io（替代 ioutil）的场景：

    • 文件小于 1MB 且需要快速操作。
    • 临时数据读写（如配置文件、小工具）。
    • 示例：读取 10KB 的 JSON 配置文件，直接用 os.ReadFile 更简单。
【Golang】关于Go语言中的IO操作
景天科技苑
10-09 3万+
在现代软件开发中，高效的输入输出（I/O）操作是提高程序性能的关键之一。Go语言提供了丰富的I/O操作接口，使得文件读写、网络通信等任务变得简单而高效。 Go语言的I/O操作主要通过标准库中的io包和os包实现。o包提供了一系列用于输入和输出操作的基本接口和原语。这些接口和原语构成了Go语言中处理I/O操作的基础，支持多种I/O设备的读写操作，包括文件、网络连接、内存缓冲区等。而os包则提供了对操作系统功能的封装，包括文件操作、进程管理等。
Golang微服务实践——用Golang开发一个商品推荐系统
AI天才研究院
08-07 1413
本文将会通过构建一个基于Golang开发的商品推荐系统，深入阐述Golang微服务化开发模式及相关技术方案。我们在本系列教程中，只从工程角度进行讨论，主要关注Golang提供的各种优秀特性及编程模式，以及这些特性和模式如何帮助我们更加高效地开发出可靠、可伸缩、可扩展的微服务应用。因此，读者需要对Go语言有一定了解，对容器、云原生等概念有基本了解。随着互联网的快速发展，网站流量越来越多，用户行为也在不断变化。作为电商网站的忠实用户，每一次交易都意味着一笔交易金额。
关于golang的io操作
席万里的博客
02-19 784
关于golang的io操作
golang--IO操作
weixin_42282999的博客
02-08 242
1、IO操作 package main import ( "fmt" "io" "os" "strings" ) func ReadForm(reader io.Reader,num int)([]byte,error){ buf := make([]byte,num) n,err := reader.Read(buf) if n>0 { return buf[:n],nil } return buf,err } // 字符串读取 func StringReadForm()
【Go语言学习系列14】标准库探索（一）：io与文件操作
最新发布
GopherTribe的博客
03-24 634
深入讲解Go语言io包与文件操作，从Reader/Writer接口到实际文件处理案例，全面掌握Go的IO处理机制
Golang之IO操作
qq_36261130的博客
11-16 996
格式化 IO 操作 package main import ( "fmt" "os" ) // 格式化 IO // fmt 包 func main() { // 输出到终端 // 带有换行符, 支持多个参数 fmt.Println("hello world", "china", 2021) // 不带换行符, 单纯输出 fmt.Print("你好", 666, "\n") // 格式化输出, 不换行 fmt.Printf("hello %s %d\n", "chao", 202.
Golang IO 操作
wgchen
02-15 403
Golang IO 操作
【菜鸟进击】初学golang——发送post请求/json
duke1237的博客
02-21 2681
import ( "fmt" "encoding/json" "bytes" "io/ioutil" "net/http" "github.com/angrygiraffe/go-log" "context" ) type Foo struct{ Size int
golang笔记——Go堆内存管理
qq_24428851的博客
08-27 1938
本文主要记录个人学习Golang堆内存管理，涉及到的相关内容，算是对个人所学知识点的梳理与总结。从非常宏观的角度看，Go的堆内存管理就是下图这个样子学习内存管理，肯定首先需要了解内存管理的基本知识，我会按照内存管理基础知识-->TCMalloc-->Go堆内存管理基础概念-->Go堆内存分配流程，这样的顺序来逐步梳理相关知识。
Golang专题——fsnotify 文件及目录监控
GoppViper的博客
09-15 4599
Golang 的 fsnotify 库很方便对文件、目录做监控，这里的充满了想象力，因为一切皆文件，这代表着一切可监控。童鞋们，这里的想象空间非常大哦；通过 fsnotify 我们映证了 vim 的秘密；Golang 的 fsnotify 其实操作系统能力的浅层封装，Linux 本质就是对 inotify 机制；inotify 也是一个特殊句柄，属于匿名句柄之一，这个句柄用于文件的事件监控；
golang学习笔记——grom连接mysql
e891377的专栏
08-25 1373
Golang的ORM库旨在对开发人员友好。
golang标准库io相关操作解读
xiangxiang258的博客
05-13 349
作为一个golang新手，对go的读写相关的操作一直都没有理解透彻，尤其是很多的方法都需要传入一个read或者write的操作，对于这种一直都不理解，而且对于读写也是不太会使用。所以希望通过自己整理标准库io相关的的数据来帮助自己理解这方面的知识。下面开始正文首先，io操作，或者io流，其实也就是读写操作和读写流，就是对数据的读或者写，都可以称之为io操作。
GoLang 文件IO操作（一）
zzzsss123333的博客
05-02 790
GoLang 文件IO操作（一） 1.file操作 func LearnFileMain() { fileInfo, err := os.Stat("C:\\Users\\31927\\Desktop\\aa.txt") if err != nil { fmt.Println(err) return } fmt.Println(fileInfo) fmt.Println(fileInfo.Name()) fmt.Println(fileInfo.Mode()) fmt.Println
go语言io常用操作
小小城的博客
09-15 265
//普通形式，基本操作 func TestFileReadWriter(t *testing.T) { open, err := os.Open("E:\\log2\\mmcloudxwskillfm_2020061716.log") if err != nil { fmt.Println("打开文件失败") return } defer open.Close() file, err := os.OpenFile("E:\\log2\\TestFileReadWriter.log", o
golang IO流
m0_63573177的博客
07-15 685
快速上手go
Golang简单实现IO操作
青玉白露的博客
12-30 866
在任何语言的开发中，输入/输出 (I/O) 操作都是非常关键的一部分。Golang 提供了io和io/ioutil标准库，帮助我们进行方便、高效的I/O操作。通过这篇文章，你将了解io库如何提供了对IO原语的基本接口，而io/ioutil库则提供了一些更高级的函数。
go-IO操作(一)
weixin_34352005的博客
11-15 328
格式化输入输出 从终端获取用户的输入，go提供了三个函数： //格式化输入，空格作为分隔符，占位符和格式化输出一致 fmt.Scanf(format string, a ...interface{}) //从终端获取用户输入，存储在Scan的参数里，空格和换行符作为分隔符 fmt.Scan(a ...interface{}) //从终端获取用户输入，存储在Scanln的参数里，空格作为分隔符，遇...
GO语言IO操作
h363659487的博客
11-10 1532
GO语言IO操作
golang标准库 io
Willian
01-26 2692
Go 语言中，为了方便开发者使用，将 IO 操作封装在了如下几个包中： - io 为 IO 原语（I/O primitives）提供基本的接口 - io/ioutil 封装一些实用的 I/O 函数 - fmt 实现格式化 I/O，类似 C 语言中的 printf 和 scanf - bufio 实现带缓冲I/O1.1 io — 基本的 IO 接口 在 io 包中最重要的是两个接口：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值