第一部分定义了最基本的流操作接口，包括Writer, Reader, Seeker, Closer这几个以及相关的组合接口。分别表达写入，读取， 偏移读和关闭操作处理。
全局类图以及关系如下，方便大家更直观的理解：
图片
以下对接口进行了源码摘取并进行中文注释：
type Writer interface {
Write(p []byte) (n int, err error)
}
type Reader interface {
Read(p []byte) (n int, err error)
}
type Seeker interface {
Seek(offset int64, whence int) (int64, error)
}
type Closer interface {
Close() error
}在基本的接口外， io库还提供了一些扩展的读写处理能力的接口定义，以提升更便捷的使用：
- 读相关的定义包括：ReaderAt, RuneReader, RuneScanner, ByteReader, ByteScanner, ReaderFrom
全局类图以及关系如下, 方便大家更直观的理解：
图片
以下对接口进行了源码摘取并进行中文注释：
type ReaderAt interface {
ReadAt(p []byte, off int64) (n int, err error)
}
type RuneReader interface {
ReadRune() (r rune, size int, err error)
}
type ByteReader interface {
ReadByte() (byte, error)
}
type ReaderFrom interface {
ReadFrom(r Reader) (n int64, err error)
}- 写相关的定义包括：WriterAt, WriterTo, StringWriter等
全局类图以及关系如下, 方便大家更直观的理解：
图片
以下对接口进行了源码摘取并进行中文注释：
type WriterAt interface {
WriteAt(p []byte, off int64) (n int, err error)
}
type WriterTo interface {
WriteTo(w Writer) (n int64, err error)
}
type StringWriter interface {
WriteString(s string) (n int, err error)
}io库还提供了很实用的工具方法，整理如下：
Copy：
func Copy(dst Writer, src Reader) (written int64, err error)成功的 Copy 返回 err == nil，而不是 err == EOF。因为 Copy 被定义为从 src 读取直到 EOF，所以它不会将 Read 中的 EOF 视为要报告的错误。
如果 src 实现WriterTo，则通过调用 src.WriteTo(dst) 实现复制。否则，如果 dst 实现了ReaderFrom，则通过调用 dst.ReadFrom(src) 来实现复制。
CopyBuffer：
func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error)如果 src 实现WriterTo或 dst 实现ReaderFrom，则 buf 将不会用于执行复制。
CopyN：
func CopyN(dst Writer, src Reader, n int64) (written int64, err error)如果 dst 实现ReaderFrom，则使用它来实现副本。
Pipe：
func Pipe() (*PipeReader, *PipeWriter)管道上的读取和写入是一对一匹配的，除非需要多个读取来消耗单个写入。也就是说，对 PipeWriter 的每次写入都会阻塞，直到满足来自PipeReader的一次或多次读取（完全消耗写入数据）为止。数据直接从Write复制到对应的Read（或Reads）；没有内部缓冲。
并行调用 Read 和 Write 或与 Close 一起调用是安全的。对 Read 的并行调用和对 Write 的并行调用也是安全的：各个调用将按顺序进行门控。
ReadAll：
func ReadAll(r Reader) ([]byte, error)func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error)ReadFull：
func ReadFull(r Reader, buf []byte) (n int, err error)WriteString：
func WriteString(w Writer , s string ) (n int , err error)文件操作读写示例：
// ReadFileExample 读取文件内容并输出
func ReadFileExample() {
// 打开文件，第一个参数是文件路径，第二个参数是文件打开模式
file, err := os.Open("example.txt")
if err != nil {
fmt.Println("Error:", err)
return
}
defer file.Close() // 延迟关闭文件，确保文件在函数执行完毕后被关闭
// 读取文件内容
data := make([]byte, 100) // 读取数据的缓冲区
count, err := file.Read(data)
if err != nil {
fmt.Println("Error:", err)
return
}
// 输出文件内容
fmt.Printf("Read %d bytes: %s\n", count, data[:count])
}
// WriteFileExample 函数演示如何写入数据到文件中
func WriteFileExample() {
// 创建文件，第一个参数是文件路径，如果文件已存在则会被截断清空
file, err := os.Create("example.txt")
if err != nil {
fmt.Println("Error:", err)
return
}
defer file.Close() // 延迟关闭文件，确保文件在函数执行完毕后被关闭
// 写入数据到文件
data := []byte("Hello, world!\n")
_, err = file.Write(data)
if err != nil {
fmt.Println("Error:", err)
return
}
fmt.Println("Data has been written to output.txt")
}io库的第二部分，定义了一个子包"fs"， 定义了文件操作相关的接口，包括 File， FS, DirEntry等。
全局类图以及关系如下, 方便大家更直观的理解：
图片
以下对接口进行了源码摘取并进行中文注释：
type File interface {
Stat() (FileInfo, error)
Read([]byte) (int, error)
Close() error
}
type FileInfo interface {
Name() string // 文件的基本名称
Size() int64 // 常规文件的长度（以字节为单位）; 其他系统相关
Mode() FileMode // 文件模式位
ModTime() time . Time // 修改时间
IsDir() bool // Mode().IsDir() 的缩写
Sys() any // 底层数据源（可以返回 nil）
}
type FS interface {
// Open 打开指定的文件。
//
// 当 Open 返回错误时，错误类型应为 *PathError
// Op 字段设置为“open”，Path 字段设置为 name，
// 以及 Err 字段描述问题。
//
// Open 应拒绝打开不满足// ValidPath(name) 的名称的尝试，返回 *PathError，并将 Err 设置为
// ErrInvalid 或 ErrNotExist。
Open(name string) (File, error)
}
type DirEntry interface {
// Name 返回条目描述的文件（或子目录）的名称。
// 这个名称只是路径的最后一个元素（基本名称），而不是整个路径。
// 例如，Name 将返回“hello.go”而不是“home/gopher/hello.go”。
Name() string
// IsDir 报告条目是否描述目录
IsDir() bool
// Type 返回条目的类型位。
// 类型位是通常 FileMode 位的子集，由 FileMode.Type 方法返回
Type() FileMode
// Info 返回条目描述的文件或子目录的 FileInfo。
// 返回的 FileInfo 可能来自读取原始目录的时间
// 或来自调用 Info. //如果自目录读取后文件已被删除或重命名，Info 可能会返回满足errors.Is(err, ErrNotExist) 的错误。
// 如果条目表示符号链接，则 Info 报告有关链接本身的信息，
// 而不是链接目标的信息。
Info() (FileInfo, error)
}2.OS库
至此io库的部分已经介绍结束，但应该有同学会问， 如何使用这些库，特别是文件操作？那就要是与os库联合使用了。 下面也针对os库进行了整理，并给出了相关的示例，方便大家掌握。
全局类图以及关系如下，方便大家更直观的理解：
图片
类图上，可以看到os库下也定义了File对象，与fs.File接口一样，有一个Stat方法，但返回值变成了os.FileInfo，但类型是直接使用了fs.FileInfo。
// A FileInfo describes a file and is returned by Stat and Lstat.
type FileInfo = fs.FileInfo
// A FileMode represents a file's mode and permission bits.
// The bits have the same definition on all systems, so that
// information about files can be moved from one system
// to another portably. Not all bits apply to all systems.
// The only required bit is ModeDir for directories.
type FileMode = fs.FileMode以下是最简单的文件操作示例：
file, err := os.Open("example.txt")
if err != nil {
fmt.Println("无法打开文件:", err)
return
}
defer file.Close() // 确保在函数退出时关闭文件
bs := make([]byte, s.Size())
file.Read(bs)
// 打印文件内容
log.Println(string(bs))以下是最简单的使用fs.FS操作目录的示例：
root := "/usr/local/go/bin"
fileSystem := os.DirFS(root) // 返回 fs.FS所以总结来讲， os下的File是一个独立的实现，虽然不是直接实现了fs.File接口，但是操作行为，依赖的操作与fs包下的是完全一致的类型。
GEEK TALK
3.http包
接下来再来整理一下 http包下的文件相关的定义：
图片
http包下也定义了，FileSystem与File对象，进行相应的操作处理， 这一块的使用也比较好掌握，参见一下下面的示例。
示例：使用http.FileServer实现静态文件服务发布， 使用了 http.FileSystem
root := "/local/xxx/static"
rootfs := os.DirFS(root) // 返回 fs.FS
fsstatic := http.FileServer(http.FS(rootfs))
// 设置路由
http.Handle("/static/", http.StripPrefix("/static/", fsstatic))4.embed包
最后再介绍一下 embed包。Golang1.16 版本引入的embed标准库, 支持把外部资源文件或目录直接在编译阶段打进编译包中，实现了应用打包时只需一个可执行包的效果。
embed支持把外部资源以 string, []byte或embed.FS方式使用。下面是几个使用示例：
//go:embed hello.txt
var s string
//go:embed hello.txt
var b []byte
//go:embed hello.txt
var f embed.FS这里可以看到 embed也定义了 FS对象，用于FileSystem的操作处理。
图片
从上面的类图可以看到，embed.FS提供的读取文件内容，打开文件以及读取文件目录的功能。
以下对相关的方法进行了源码摘取并进行中文注释：
func (f FS) Open(name string) (fs.File, error)
func (f FS) ReadDir(name string) ([]fs.DirEntry, error)
func (f FS) ReadFile(name string) ([]byte, error)示例代码：从embed.FS读取文件目录，发布成http静态资源服务
package main
import (
"embed"
"log"
"net/http"
)
//go:embed static/*
var staticFiles embed.FS
func main() {
// 创建文件服务器
fileServer := http.FileServer(http.FS(staticFiles))
// 设置路由
http.Handle("/static/", http.StripPrefix("/static/", fileServer))
// 启动HTTP服务器
log.Println("Server started on: http://localhost:8080")
log.Fatal(http.ListenAndServe(":8080", nil))
}GEEK TALK
5.总结
Go语言的基础库里，针对文件操作这一块，各个包都有自己的File, FS的定义，这给很多刚开始学习的同学带来了不少困惑，个人也是觉得设计上是有改进的空间的。希望上述的整理内容，可以帮助到大家更好的理解Go语言IO库的使用。
