io

在 Go 语言中，io 包提供了基本的输入输出功能。以下是一些常用的 io 包的 API 及其详细说明：

1. 读取数据

io.Reader

io.Reader 是一个基本的接口，用于表示数据的读取。它只有一个方法 Read。

type Reader interface {
    Read(p []byte) (n int, err error)
}

io.ReadFull

从 io.Reader 中精确读取 len(buf) 字节的数据。

package main

import (
    "fmt"
    "io"
    "strings"
)

func main() {
    reader := strings.NewReader("Hello, World!")
    buf := make([]byte, 5)
    n, err := io.ReadFull(reader, buf)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Printf("Read %d bytes: %s\n", n, string(buf))
}

io.Copy

将数据从一个 io.Reader 拷贝到一个 io.Writer。

package main

import (
    "io"
    "os"
)

func main() {
    src := strings.NewReader("Hello, World!")
    dst := os.Stdout
    n, err := io.Copy(dst, src)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("\nCopied %d bytes\n", n)
}

2. 写入数据

io.Writer

io.Writer 是一个基本的接口，用于表示数据的写入。它只有一个方法 Write。

type Writer interface {
    Write(p []byte) (n int, err error)
}

io.WriteString

向 io.Writer 写入字符串。

package main

import (
    "io"
    "os"
)

func main() {
    _, err := io.WriteString(os.Stdout, "Hello, World!\n")
    if err != nil {
        log.Fatal(err)
    }
}

3. 缓冲读写

io.BufferedReader

使用 bufio.NewReader 创建一个带缓冲的读取器。

package main

import (
    "bufio"
    "fmt"
    "strings"
)

func main() {
    reader := bufio.NewReader(strings.NewReader("Hello, World!"))
    line, err := reader.ReadString('\n')
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(line)
}

io.BufferedWriter

使用 bufio.NewWriter 创建一个带缓冲的写入器。

package main

import (
    "bufio"
    "os"
)

func main() {
    writer := bufio.NewWriter(os.Stdout)
    _, err := writer.WriteString("Hello, World!\n")
    if err != nil {
        log.Fatal(err)
    }
    writer.Flush()
}

4. 管道

io.Pipe

创建一个同步的内存管道，用于连接两个 goroutine。

package main

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

func main() {
    r, w := io.Pipe()

    go func() {
        defer w.Close()
        _, err := w.Write([]byte("Hello, World!\n"))
        if err != nil {
            log.Fatal(err)
        }
    }()

    _, err := io.Copy(os.Stdout, r)
    if err != nil {
        log.Fatal(err)
    }
}

5. 多路复用

io.MultiReader

创建一个 io.Reader，从多个 io.Reader 顺序读取。

package main

import (
    "fmt"
    "io"
    "strings"
)

func main() {
    r1 := strings.NewReader("Hello, ")
    r2 := strings.NewReader("World!")
    reader := io.MultiReader(r1, r2)
    buf := new(strings.Builder)
    _, err := io.Copy(buf, reader)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(buf.String())
}

io.MultiWriter

创建一个 io.Writer，将数据写入多个 io.Writer。

package main

import (
    "io"
    "os"
)

func main() {
    file, err := os.Create("output.txt")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    writer := io.MultiWriter(os.Stdout, file)
    _, err = writer.Write([]byte("Hello, World!\n"))
    if err != nil {
        log.Fatal(err)
    }
}

6. 限制读取

io.LimitReader

创建一个 io.Reader，从原始 io.Reader 中读取指定字节数。

package main

import (
    "fmt"
    "io"
    "strings"
)

func main() {
    reader := strings.NewReader("Hello, World!")
    limitedReader := io.LimitReader(reader, 5)
    buf := new(strings.Builder)
    _, err := io.Copy(buf, limitedReader)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(buf.String()) // 输出: Hello
}

7. 计数读取

io.TeeReader

创建一个 io.Reader，从 io.Reader 读取并将读取的数据写入 io.Writer。

package main

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

func main() {
    src := strings.NewReader("Hello, World!")
    dst := os.Stdout
    teeReader := io.TeeReader(src, dst)
    buf := new(strings.Builder)
    _, err := io.Copy(buf, teeReader)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println("\nRead data:", buf.String()) // 输出: Hello, World!
}

通过以上这些 io 包中的基本 API，你可以方便地处理各种输入输出操作。根据具体需求，还可以结合 bufio 包和 os 包实现更复杂的读写逻辑。