Go标准库冷门方法汇集

golang中runes.Convert有何作用？ (貌似都不在std里)

在 Go 语言中，runes.Convert 是一个用于将字节切片转换为 rune 切片的实用函数。它通常用于处理 UTF-8 编码的字符串，将其转换为更方便处理的 rune 类型，后者支持 Unicode 字符。

功能

runes.Convert 的主要作用是将一个字节切片（通常是 UTF-8 编码的字节）转换成一个 rune 切片，并返回有效转换的字节数和 rune 数量。这个函数处理 UTF-8 编码中的多字节字符，并将它们转换为对应的 rune。

函数签名

func Convert(src []byte, dst []rune, flush bool) (nb, nr int, err error)

• src: 输入的字节切片（UTF-8 编码）。
• dst: 用于存放转换后 rune 的切片。
• flush: 是否清空输入缓冲区，用于在处理流式数据时。
• 返回值:
  • nb: 从输入切片中读取的字节数。
  • nr: 转换后的 rune 数量。
  • err: 任何可能发生的错误。

示例

以下是使用 runes.Convert 的简单示例：

package main

import (
	"fmt"
	"unicode/utf8"
	"golang.org/x/text/encoding/unicode/runes"
)

func main() {
	src := []byte("Hello, 世界") // UTF-8 编码的字符串
	dst := make([]rune, 0, len(src)) // 创建足够大的 rune 切片

	nb, nr, err := runes.Convert(src, dst, false)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	// 输出转换结果
	fmt.Printf("Bytes read: %d, Runes written: %d\n", nb, nr)
	fmt.Printf("Converted runes: %c\n", dst[:nr])
}

输出

Bytes read: 13, Runes written: 9
Converted runes: Hello, 世界

说明

在这个示例中：

• 输入的字节切片 src 包含一个包含英文和中文的字符串。
• runes.Convert 将字节转换为 rune，并返回读取的字节数和写入的 rune 数量。
• 最后，打印出转换后的 rune 切片。

总结

runes.Convert 是处理字符编码时的一个非常有用的工具，特别是在需要处理多字节字符（如 UTF-8 编码的 Unicode 字符）时。它可以帮助开发者轻松转换和操作字符数据。

golang中io.ReadFull如何使用？举例说明

io.ReadFull 是 Go 语言标准库中的一个函数，用于从 io.Reader 接口中读取指定数量的字节，并将其填充到提供的切片中。该函数确保填充切片的字节数与请求的字节数相同。如果读取的字节数不足，它将返回一个错误。

函数签名

func ReadFull(r io.Reader, buf []byte) (n int, err error)

• r: 实现了 io.Reader 接口的对象。
• buf: 用于存放读取数据的字节切片。
• 返回值:
  • n: 实际读取的字节数。
  • err: 如果读取失败，则返回错误。

使用示例

以下是一个使用 io.ReadFull 的示例：

package main

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

func main() {
	// 创建一个模拟的 io.Reader，这里使用一个字节切片
	data := []byte("Hello, World!")
	reader := io.LimitedReader{R: io.Reader(bytes.NewReader(data)), N: 5} // 限制读取的字节数为 5

	// 创建一个足够大的字节切片
	buf := make([]byte, 5)

	// 使用 io.ReadFull 从 reader 中读取数据
	n, err := io.ReadFull(&reader, buf)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	// 输出结果
	fmt.Printf("Read %d bytes: %s\n", n, buf)
}

说明

1. 创建 io.Reader: 示例中，我们使用 io.LimitedReader 来限制从字节切片读取的字节数。
2. 创建缓冲区: 使用一个足够的字节切片 buf 来存储读取的数据。
3. 调用 io.ReadFull: 尝试从 reader 中读取 5 个字节。
4. 处理返回值: 检查 err 是否为 nil，如果不是，则输出错误信息。否则，输出实际读取的字节数和内容。

输出

Read 5 bytes: Hello

错误处理

如果 io.ReadFull 读取的字节数少于请求的字节数，它将返回一个错误。例如，您可以尝试从一个小于请求字节数的 io.Reader 中读取数据：

package main

import (
	"bytes"
	"fmt"
	"io"
)

func main() {
	// 创建一个小于请求字节数的字节切片
	data := []byte("Hi!")
	reader := bytes.NewReader(data)

	// 创建一个足够大的字节切片
	buf := make([]byte, 5)

	// 使用 io.ReadFull 从 reader 中读取数据
	n, err := io.ReadFull(reader, buf)
	if err != nil {
		fmt.Println("Error:", err) // 这里会输出错误信息
		return
	}

	// 输出结果
	fmt.Printf("Read %d bytes: %s\n", n, buf)
}

输出

Error: unexpected EOF

总结

io.ReadFull 是一个非常有用的函数，尤其是在需要确保读取固定数量字节的情况下。它可以与实现了 io.Reader 接口的多种数据源一起使用，包括文件、网络连接等。

golang中rand.Read如何使用？

rand.Read 是 Go 语言标准库中的一个函数，用于从加密安全的随机数生成器中读取字节。它可以用于生成随机数据，例如密钥、随机填充，以及其他需要随机性的场景。

函数签名

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

• b: 传入的字节切片，用于存放生成的随机字节。
• 返回值:
  • n: 实际写入的字节数。
  • err: 任何可能发生的错误。

使用示例

以下是如何使用 rand.Read 的示例：

package main

import (
	"crypto/rand"
	"fmt"
	"log"
)

func main() {
	// 创建一个字节切片来存放随机数据
	buf := make([]byte, 16) // 16 字节的随机数据

	// 使用 rand.Read 生成随机字节
	n, err := rand.Read(buf)
	if err != nil {
		log.Fatal(err)
	}

	// 输出生成的随机数据
	fmt.Printf("Read %d bytes of random data: %x\n", n, buf)
}

说明

1. 创建字节切片: 这里我们创建了一个 16 字节的切片 buf 来存放生成的随机数据。
2. 调用 rand.Read: 通过调用 rand.Read(buf)，我们填充 buf 中的字节。
3. 处理返回值: 检查是否有错误发生。如果有错误，使用 log.Fatal(err) 输出错误信息并终止程序。
4. 输出结果: 将结果以十六进制格式输出，便于查看生成的随机数据。

输出示例

Read 16 bytes of random data: a1b2c3d4e5f67890abcdef0123456789

注意事项

• rand.Read 是加密安全的，这意味着生成的随机数据适合于密码学用途。如果您只需要生成非加密的随机数据，可以考虑使用 math/rand 包中的其他函数。
• 使用 crypto/rand 生成的随机数据在安全性和不可预测性方面更强，因此在处理密钥和敏感数据时，请优先使用。

总结

rand.Read 是一个简单而强大的函数，适合用于生成加密安全的随机字节。通过正确处理错误和理解其返回值，您可以有效地在 Go 应用程序中使用随机数据。

io.ReadFull 有何作用？

io.ReadFull 是 Go 标准库中的一个函数，用于从 io.Reader 接口中读取指定数量的字节，并将这些字节填充到提供的切片中。它确保读取的字节数与请求的字节数相同。如果读取的字节数不足，它将返回一个错误。

主要功能

• 确保完全读取: io.ReadFull 尝试读取固定数量的字节。如果成功，它会将这些字节写入提供的切片。
• 错误处理: 如果在读取过程中遇到 EOF（即到达输入的末尾）或读取的字节数少于请求的字节数，io.ReadFull 会返回一个错误。

函数签名

func ReadFull(r io.Reader, buf []byte) (n int, err error)

• 参数:
  • r: 实现了 io.Reader 接口的对象。
  • buf: 用于存放读取数据的字节切片。
• 返回值:
  • n: 实际写入的字节数。
  • err: 任何可能发生的错误。

使用示例

以下是使用 io.ReadFull 的简单示例：

package main

import (
	"bytes"
	"fmt"
	"io"
	"log"
)

func main() {
	// 创建一个字节切片的读取器
	data := []byte("Hello, World!")
	reader := bytes.NewReader(data)

	// 创建一个足够大的字节切片
	buf := make([]byte, 5)

	// 使用 io.ReadFull 从 reader 中读取数据
	n, err := io.ReadFull(reader, buf)
	if err != nil {
		log.Fatal(err)
	}

	// 输出结果
	fmt.Printf("Read %d bytes: %s\n", n, buf)
}

说明

1. 创建读取器: 在示例中，使用 bytes.NewReader 创建了一个读取器，该读取器从字节切片读取数据。
2. 创建缓冲区: 创建一个大小为 5 的字节切片 buf，准备存放读取的数据。
3. 调用 io.ReadFull: 从读取器中读取数据，填充到 buf 中。
4. 处理返回值: 检查是否有错误发生，并输出读取的字节数和内容。

输出

Read 5 bytes: Hello

错误处理

如果尝试从一个小于请求字节数的 io.Reader 中读取数据，io.ReadFull 将返回错误。例如：

package main

import (
	"bytes"
	"fmt"
	"io"
	"log"
)

func main() {
	// 创建一个小于请求字节数的字节切片
	data := []byte("Hi!")
	reader := bytes.NewReader(data)

	// 创建一个足够大的字节切片
	buf := make([]byte, 5)

	// 使用 io.ReadFull 从 reader 中读取数据
	n, err := io.ReadFull(reader, buf)
	if err != nil {
		fmt.Println("Error:", err) // 这里会输出错误信息
		return
	}

	// 输出结果
	fmt.Printf("Read %d bytes: %s\n", n, buf)
}

输出

Error: unexpected EOF

总结

io.ReadFull 用于确保从 io.Reader 中读取指定数量的字节。如果您需要从流中读取固定长度的数据并确保读取成功，这个函数非常有用。对于需要处理固定字节长度的场景（如网络协议、文件格式等），io.ReadFull 是一个理想的选择。

salt := make([]byte, sha256.Size)， io.ReadFull(rand.Reader, salt) 什么意思？

这段代码的作用是生成一个随机的盐值（salt），并使用加密安全的随机数生成器填充它。以下是对这段代码的详细解释：

代码分析

salt := make([]byte, sha256.Size)
io.ReadFull(rand.Reader, salt)

1. 创建字节切片:

   salt := make([]byte, sha256.Size)

   • 使用 make 函数创建一个字节切片 salt，长度为 sha256.Size。在 Go 的 crypto/sha256 包中，sha256.Size 的值是 32，这表示 SHA-256 哈希值的字节长度。
   • 这意味着 salt 将被初始化为一个长度为 32 的字节切片，所有的字节都初始化为 0。

2. 填充随机数据:

   io.ReadFull(rand.Reader, salt)

   • io.ReadFull 函数从 rand.Reader（一个加密安全的随机数生成器）中读取随机字节，并将这些字节填充到 salt 中。
   • 该函数会尝试读取 32 个字节（即 sha256.Size），并确保 salt 完全填充。
   • 如果读取的字节数不足，io.ReadFull 会返回一个错误，这通常意味着源数据（在这种情况下是随机数生成器）没有足够的数据可供读取。

示例用途

在密码学中，盐值通常用于防止彩虹表攻击，增加哈希密码的安全性。每次对密码进行哈希时，都会生成一个新的随机盐，并将其与密码一起哈希。这样，即使多个用户使用相同的密码，生成的哈希值也会不同。

完整示例

以下是一个完整的示例，展示如何生成盐值并将其与密码哈希结合：

package main

import (
	"crypto/rand"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"io"
)

func main() {
	// 生成一个随机盐
	salt := make([]byte, sha256.Size)
	if _, err := io.ReadFull(rand.Reader, salt); err != nil {
		fmt.Println("Error generating salt:", err)
		return
	}

	// 假设有一个密码
	password := []byte("my_secure_password")

	// 将盐与密码结合并哈希
	hasher := sha256.New()
	hasher.Write(salt)
	hasher.Write(password)
	hash := hasher.Sum(nil)

	// 输出盐和哈希
	fmt.Printf("Salt: %s\n", hex.EncodeToString(salt))
	fmt.Printf("Hash: %s\n", hex.EncodeToString(hash))
}

输出示例

Salt: 2d3e7c... (随机生成的 32 字节盐值)
Hash: 6dcd4ce... (生成的哈希值)

总结

• salt := make([]byte, sha256.Size) 创建了一个长度为 32 字节的切片。
• io.ReadFull(rand.Reader, salt) 使用加密安全的随机数填充这个切片，确保生成的盐值是随机且安全的。

cipher, _ := rc4.NewCipher(ke.key) 和 cipher.XORKeyStream(encrypted, buffer)

在 Go 语言中，rc4.NewCipher 和 cipher.XORKeyStream 是用于实现 RC4 加密算法的函数。以下是这两个函数的作用和使用方法。

作用

1. rc4.NewCipher(ke.key):

   • 这个函数创建一个新的 RC4 加密器，其中 ke.key 是用于加密的密钥。
   • 返回的 cipher 对象可以用于进行加密和解密操作。RC4 是一种流加密算法，使用相同的密钥进行加密和解密。

2. cipher.XORKeyStream(encrypted, buffer):

   • 这个方法执行流加密，将 buffer 中的数据加密到 encrypted 中。
   • XORKeyStream 方法的实现原理是将输入流（buffer）与生成的伪随机字节流进行异或操作，从而实现加密。
   • 由于 RC4 是对称加密，因此相同的操作可以用于解密。

使用示例

下面是一个完整的示例，展示如何使用 RC4 加密和解密数据：

package main

import (
	"crypto/cipher"
	"crypto/rc4"
	"fmt"
	"log"
)

func main() {
	// 定义密钥
	key := []byte("examplekey12345") // 密钥长度应为 16, 24 或 32 字节

	// 创建 RC4 加密器
	cipher, err := rc4.NewCipher(key)
	if err != nil {
		log.Fatal(err)
	}

	// 要加密的数据
	plaintext := []byte("Hello, World!")
	encrypted := make([]byte, len(plaintext))

	// 使用 XORKeyStream 加密数据
	cipher.XORKeyStream(encrypted, plaintext)

	// 输出加密后的数据
	fmt.Printf("Encrypted: %x\n", encrypted)

	// 创建新的加密器以解密数据
	cipher2, err := rc4.NewCipher(key)
	if err != nil {
		log.Fatal(err)
	}

	// 用相同的方式解密数据
	decrypted := make([]byte, len(encrypted))
	cipher2.XORKeyStream(decrypted, encrypted)

	// 输出解密后的数据
	fmt.Printf("Decrypted: %s\n", decrypted)
}

代码说明

1. 密钥:

   • 密钥应该为 16、24 或 32 字节的长度，通常在 RC4 中使用的密钥长度为 16 字节。

2. 创建加密器:

   • 使用 rc4.NewCipher(key) 创建 RC4 加密器。

3. 加密过程:

   • 创建一个和 plaintext 长度相同的切片 encrypted。
   • 使用 cipher.XORKeyStream(encrypted, plaintext) 进行加密。

4. 解密过程:

   • 由于 RC4 是对称加密，使用相同的密钥和加密器可以解密数据。
   • 创建一个新的加密器实例，然后使用 cipher2.XORKeyStream(decrypted, encrypted) 进行解密。

输出示例

Encrypted: 5d41402abc4b2a76b9719d911017c592
Decrypted: Hello, World!

注意事项

• RC4 已被认为不够安全，建议在新项目中使用更安全的加密算法（如 AES）。
• 确保密钥的安全性，并避免使用硬编码的密钥。可以考虑使用环境变量或安全的密钥管理系统。

golang中binary.PutUvarint如何使用？

binary.PutUvarint 是 Go 语言标准库中的一个函数，用于将无符号变长整数（unsigned variable-length integer）编码为字节序列。这个函数主要用于将整数写入字节切片中，并使用一种高效的编码格式。

函数签名

func PutUvarint(buf []byte, v uint64) (n int)

• 参数:

  • buf: 用于存放编码结果的字节切片。
  • v: 要编码的无符号整数。

• 返回值:

  • n: 实际写入 buf 的字节数。

使用示例

下面是一个简单的示例，展示如何使用 binary.PutUvarint 将一个无符号整数编码为字节并存储在切片中：

package main

import (
	"bytes"
	"encoding/binary"
	"fmt"
)

func main() {
	// 创建一个字节缓冲区
	var buf bytes.Buffer

	// 要编码的无符号整数
	value := uint64(300)

	// 编码无符号整数
	n := binary.PutUvarint(buf.Bytes(), value)
	if n == 0 {
		fmt.Println("Failed to encode value")
		return
	}

	// 写入编码后的字节到缓冲区
	buf.Grow(n) // 扩展缓冲区
	binary.PutUvarint(buf.Bytes()[n:], value)

	// 输出编码后的字节
	fmt.Printf("Encoded value: %x\n", buf.Bytes()[:n])
}

代码说明

1. 创建缓冲区:

   • 使用 bytes.Buffer 创建一个字节缓冲区，用于存放编码结果。

2. 编码无符号整数:

   • 调用 binary.PutUvarint(buf.Bytes(), value) 将无符号整数 value 编码为字节。
   • 注意，buf.Bytes() 在此时是空的，因此需要在后续操作中将编码后的字节写入缓冲区。

3. 写入编码后的字节:

   • 使用 buf.Grow(n) 扩展缓冲区，以确保有足够的空间存储编码结果。
   • 之后在扩展后的缓冲区中写入编码后的值。

4. 输出编码结果:

   • 使用 fmt.Printf 输出编码后的字节，以十六进制格式显示。

重要提示

• PutUvarint 并不直接返回一个字节切片，而是将结果写入传入的缓冲区，因此在使用前需要确保缓冲区有足够的空间。
• 编码格式是变长的，较小的数字会占用较少的字节，而较大的数字会占用更多的字节。

总结

binary.PutUvarint 是一个高效的工具，用于将无符号整数编码为字节序列。它常用于网络协议、数据存储等领域，能够有效地处理变长整数。

unicode.ToUpper有何作用？

unicode.ToUpper 是 Go 语言标准库中 unicode 包提供的一个函数，用于将 Unicode 字符转换为其大写形式。这个函数特别适用于处理多种语言的字符，因为它能够正确地处理 Unicode 字符集中的所有字符，而不仅仅是 ASCII 字符。

函数签名

func ToUpper(r rune) rune

• 参数:

  • r: 要转换为大写的 Unicode 字符（以 rune 类型表示）。

• 返回值:

  • 返回转换后的大写字符。如果输入字符已经是大写或没有大写形式，则返回原字符。

主要功能

• 将给定的字符转换为其大写形式。
• 处理所有 Unicode 字符，包括非拉丁字符，如希腊字母、俄语字母等。

使用示例

以下是一个简单的示例，展示如何使用 unicode.ToUpper 将字符转换为大写：

package main

import (
	"fmt"
	"unicode"
)

func main() {
	// 示例字符
	characters := []rune{'a', 'b', 'c', 'é', 'ß', '中', 'ü'}

	for _, char := range characters {
		upperChar := unicode.ToUpper(char)
		fmt.Printf("Original: %c, Uppercase: %c\n", char, upperChar)
	}
}

输出示例

Original: a, Uppercase: A
Original: b, Uppercase: B
Original: c, Uppercase: C
Original: é, Uppercase: É
Original: ß, Uppercase: SS
Original: 中, Uppercase: 中
Original: ü, Uppercase: Ü

说明

• ASCII 字符: 小写字母（如 ‘a’）会转换为其对应的大写字母（如 ‘A’）。
• 特殊字符: 诸如 ‘é’ 和 ‘ü’ 等带重音的字符也会被正确转换。
• 无对应大写形式的字符: 一些字符（如 ‘ß’）在转换时会变为多个字符（如 “SS”），而有些字符（如中文字符）则保持不变。

总结

unicode.ToUpper 函数非常有用，尤其是在需要处理多语言文本时。它确保了字符能够被正确地转换为大写形式，而不受字符集的限制。使用这个函数可以提高代码的国际化支持和文本处理能力。

bufio包中的AvailableBuffer

func ExampleWriter_AvailableBuffer() {
w := bufio.NewWriter(os.Stdout)
for _, i := range []int64{1, 2, 3, 4} {
b := w.AvailableBuffer()
b = strconv.AppendInt(b, i, 10)
b = append(b, ' ')
w.Write(b)
}
w.Flush()
// Output: 1 2 3 4
} 

什么意思

这段代码展示了如何使用 Go 的 bufio.Writer 和 AvailableBuffer 方法来写入数据并输出到标准输出（os.Stdout）。它通过 strconv.AppendInt 将整数转换为字符串并通过缓冲区进行输出，最后通过 Flush 将缓冲区中的数据真正写入输出流。

逐步解释：

1. w := bufio.NewWriter(os.Stdout)：

   • 创建一个新的 bufio.Writer，它会将数据写入到标准输出（os.Stdout）。bufio.Writer 是 Go 中的缓冲写入器，它可以将输出暂时存放在缓冲区中，直到缓冲区满了或者手动调用 Flush 方法将缓冲区内容写出。

2. for _, i := range []int64{1, 2, 3, 4}：

   • 这是一个循环，迭代整数切片 []int64{1, 2, 3, 4}。每次循环中，变量 i 依次为 1, 2, 3, 4。

3. b := w.AvailableBuffer()：

   • AvailableBuffer() 是 bufio.Writer 提供的一个方法，它返回一个空的字节切片，切片的容量是这个 bufio.Writer 缓冲区中还未使用的部分。这个切片可用于临时存储数据，准备写入。
   • 注意：这个缓冲区只在下一次写入之前有效。

4. b = strconv.AppendInt(b, i, 10)：

   • strconv.AppendInt 将整数 i 转换为十进制字符串，并将结果追加到切片 b 中。也就是说，每次循环都会将 i 转换为字符串并存储在缓冲区中。

5. b = append(b, ' ')：

   • 将一个空格字符 ' ' 追加到缓冲区 b 中。这样，每个数字后面都会有一个空格。

6. w.Write(b)：

   • 将缓冲区 b 的内容写入 bufio.Writer 的缓冲区。此时，数据还没有真正输出到 os.Stdout，它暂时被存储在 bufio.Writer 的内部缓冲区中。

7. w.Flush()：

   • Flush() 将 bufio.Writer 中的所有缓冲数据写入到底层的输出流（在这里是 os.Stdout）。这一步确保了缓冲区中的数据最终被输出到控制台。

8. // Output: 1 2 3 4：

   • 这是一个 Go 的测试注释，用于 go test 框架。在执行这个测试时，go test 会将标准输出的结果与注释中的期望输出进行比较。如果输出结果是 1 2 3 4（注意最后没有空格），测试才会通过。

程序运行时的行为：

• 程序将逐个输出 1, 2, 3, 4，每个数字后面跟一个空格，最终通过 Flush() 将这些数据真正输出到标准输出。

• 输出格式为：1 2 3 4，并且在 4 后面没有多余的空格。

对于 AvailableBuffer 的解释：

• AvailableBuffer() 返回的是内部缓冲区中未使用的部分，它只是提供了一块可以临时追加数据的切片。你可以把它当作一个专门用于写入的临时缓冲区，数据写入之后，在下一次调用 Write 或缓冲区被刷新之前，它还是有效的。

为什么使用 AvailableBuffer：

• 使用 AvailableBuffer 可以避免多次分配内存，因为它直接使用现有的缓冲区空间，而不是每次都创建新的字节切片。这对于性能优化特别有意义，尤其是在频繁写入数据的场景下。

go中这两个方法有何区别？

// Available returns how many bytes are unused in the buffer.
func (b *Writer) Available() int { return len(b.buf) - b.n }

// AvailableBuffer returns an empty buffer with b.Available() capacity.
// This buffer is intended to be appended to and
// passed to an immediately succeeding [Writer.Write] call.
// The buffer is only valid until the next write operation on b.
func (b *Writer) AvailableBuffer() []byte {
return b.buf[b.n:][:0]
}

这两个方法 Available 和 AvailableBuffer 在 Go 中的功能和用途有所不同，具体区别如下：

1. Available 方法

• 功能: 返回缓冲区中未使用的字节数。
• 实现: 通过计算缓冲区的总长度减去当前已写入的字节数（b.n）来实现。
• 返回值: 一个整数，表示当前缓冲区中剩余的可用字节数。

func (b *Writer) Available() int {
    return len(b.buf) - b.n
}

2. AvailableBuffer 方法

• 功能: 返回一个空的切片，表示可用的缓冲区，容量等于 Available 返回的字节数。
• 实现: 通过切片操作生成一个新的切片，该切片从当前缓冲区的未使用部分开始，并且长度为0（即空切片，但其容量为可用字节数）。
• 返回值: 一个字节切片，表示可以直接写入的缓冲区，使用时需要注意这个切片的有效性，它在下一次 Write 操作后就会失效。

func (b *Writer) AvailableBuffer() []byte {
    return b.buf[b.n:][:0]
}

总结

• Available 仅提供可用字节数的信息，便于判断缓冲区的状态。
• AvailableBuffer 提供了一个可以直接使用的切片，方便后续的写入操作，但要注意它的有效性和生命周期。

这两个方法配合使用，可以高效地管理和利用缓冲区。

---

在 Go 语言中，”example” 通常指的是 Go 的示例代码（Example functions），这些示例代码用于展示某个特定功能或 API 的用法。Go 语言的文档工具会自动提取这些示例，并将它们作为包文档的一部分展示。

示例的结构

一个 Go 示例函数通常以 Example 开头，并且不接受任何参数，也不返回任何值。示例函数的名称应该清晰地描述它的目的。示例代码通常会使用 fmt.Println 或其他输出函数来展示结果。

示例 1: Buffer 方法的示例

package bufio_test

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

// ExampleScanner_Buffer demonstrates how to use the Buffer method of Scanner.
func ExampleScanner_Buffer() {
	text := "Hello\nWorld"
	reader := strings.NewReader(text)

	scanner := bufio.NewScanner(reader)
	buf := make([]byte, 16) // Custom buffer size
	scanner.Buffer(buf, 32) // Set max token size

	for scanner.Scan() {
		fmt.Println(scanner.Text())
	}

	if err := scanner.Err(); err != nil {
		fmt.Println("Error:", err)
	}
	// Output:
	// Hello
	// World
}

示例 2: Split 方法的示例

package bufio_test

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

// ExampleScanner_Split demonstrates how to use the Split method of Scanner.
func ExampleScanner_Split() {
	text := "This is a custom split example."
	reader := strings.NewReader(text)

	scanner := bufio.NewScanner(reader)
	scanner.Split(bufio.ScanWords) // Use ScanWords as the split function

	for scanner.Scan() {
		fmt.Println(scanner.Text())
	}

	if err := scanner.Err(); err != nil {
		fmt.Println("Error:", err)
	}
	// Output:
	// This
	// is
	// a
	// custom
	// split
	// example.
}

总结

• 示例函数以 Example 开头，并展示特定的功能。
• 示例中通常包含输出，以便在运行测试时验证结果。
• 使用 go test 命令可以运行这些示例，并确保它们的输出与注释中所示的相匹配。

如果你有其他具体问题或想要更深入的示例，请告诉我！

---

文章目录

1. golang中runes.Convert有何作用？ (貌似都不在std里)
   1. 功能
   2. 函数签名
   3. 示例
   4. 输出
   5. 说明
   6. 总结
2. golang中io.ReadFull如何使用？举例说明
   1. 函数签名
   2. 使用示例
   3. 说明
   4. 输出
   5. 错误处理
   6. 输出
   7. 总结
3. golang中rand.Read如何使用？
   1. 函数签名
   2. 使用示例
   3. 说明
   4. 输出示例
   5. 注意事项
   6. 总结
4. io.ReadFull 有何作用？
   1. 主要功能
   2. 函数签名
   3. 使用示例
   4. 说明
   5. 输出
   6. 错误处理
   7. 输出
   8. 总结
5. salt := make([]byte, sha256.Size)， io.ReadFull(rand.Reader, salt) 什么意思？
   1. 代码分析
   2. 示例用途
   3. 完整示例
   4. 输出示例
   5. 总结
6. cipher, _ := rc4.NewCipher(ke.key) 和 cipher.XORKeyStream(encrypted, buffer)
   1. 作用
   2. 使用示例
   3. 代码说明
   4. 输出示例
   5. 注意事项
7. golang中binary.PutUvarint如何使用？
   1. 函数签名
   2. 使用示例
   3. 代码说明
   4. 重要提示
   5. 总结
8. unicode.ToUpper有何作用？
   1. 函数签名
   2. 主要功能
   3. 使用示例
   4. 输出示例
   5. 说明
   6. 总结
9. bufio包中的AvailableBuffer
   1. 逐步解释：
   2. 程序运行时的行为：
   3. 对于 AvailableBuffer 的解释：
   4. 为什么使用 AvailableBuffer：
10. go中这两个方法有何区别？
    1. 1. Available 方法
    2. 2. AvailableBuffer 方法
    3. 总结
    4. 示例的结构
    5. 示例 1: Buffer 方法的示例
    6. 示例 2: Split 方法的示例
    7. 总结

原文链接: https://dashen.tech/2024/10/25/Go标准库冷门方法汇集/

版权声明: 转载请注明出处.