version: 1.10

package bytes

import "bytes"

概述

bytes 包提供操作字节切片的函数。它类似于特殊的 strings 包。

索引

例子

文件

buffer.go bytes.go bytes_amd64.go bytes_decl.go reader.go

Constants

  1. const MinRead = 512

MinRead 是 Buffer.ReadFrom 读取的最小数。如果 MinRead 个字节已经能够容纳 r 中的内容，那么就不会再增加底层缓存空间。

Variables

  1. var ErrTooLarge = errors.New("bytes.Buffer: too large")

如果内存不能再分配缓存空间保存数据就会把 ErrTooLarge 传递给 panic。

func Compare


  1. func Compare(a, b []byte) int


Compare 比较连个字节切片并根据结果返回一个整数。（a==b 时返回 0，a < b 时返回 -1，a > b 时返回 +1）。参数为 nil 默认为空切片。


例:

// 通过和 0 进行比较来解释流程控制语句的含义
var a, b []byte
if bytes.Compare(a, b) < 0 {
// a 小于 b
}
if bytes.Compare(a, b) <= 0 {
// a 小于等于 b
}
if bytes.Compare(a, b) > 0 {
// a 大于 b
}
if bytes.Compare(a, b) >= 0 {
// a 大于等于 b
}

// 推荐使用 Equal 来判断等于的情况
if bytes.Equal(a, b) {
// a equal b
}
if !bytes.Equal(a, b) {
// a not equal b
}



例:

// 二进制搜索指定的字节切片
var needle []byte
var haystack [][]byte // 排序后
i := sort.Search(len(haystack), func(i int) bool {
// Return haystack[i] >= needle.
return bytes.Compare(haystack[i], needle) >= 0
})
if i < len(haystack) && bytes.Equal(haystack[i], needle) {
// Found it!
}

func Contains


  1. func Contains(b, subslice []byte) bool


Contains 判断 b 中是否包含 subslice。


例:

fmt.Println(bytes.Contains([]byte(“seafood”), []byte(“foo”)))
fmt.Println(bytes.Contains([]byte(“seafood”), []byte(“bar”)))
fmt.Println(bytes.Contains([]byte(“seafood”), []byte(“”)))
fmt.Println(bytes.Contains([]byte(“”), []byte(“”)))
// Output:
// true
// false
// true
// true

func ContainsAny


  1. func ContainsAny(b []byte, chars string) bool


ContainsAny 判断 b 中是否包含 chars 中的任意 UTF-8 代码点


例:

fmt.Println(bytes.ContainsAny([]byte(“I like seafood.”), “fÄo!”))
fmt.Println(bytes.ContainsAny([]byte(“I like seafood.”), “去是伟大的.”))
fmt.Println(bytes.ContainsAny([]byte(“I like seafood.”), “”))
fmt.Println(bytes.ContainsAny([]byte(“”), “”))
// Output:
// true
// true
// false
// false

func ContainsRune


  1. func ContainsRune(b []byte, r rune) bool


ContainsRune 判断 b 中是否包含 UTF-8 编码字节 rune。


例:

fmt.Println(bytes.ContainsRune([]byte(“I like seafood.”), ‘f’))
fmt.Println(bytes.ContainsRune([]byte(“I like seafood.”), ‘ö’))
fmt.Println(bytes.ContainsRune([]byte(“去是伟大的!”), ‘大’))
fmt.Println(bytes.ContainsRune([]byte(“去是伟大的!”), ‘!’))
fmt.Println(bytes.ContainsRune([]byte(“”), ‘@’))
// Output:
// true
// false
// true
// true
// false

func Count


  1. func Count(s, sep []byte) int


Count 计算 s 中 sep 非重叠出现的次数。如果 sep 为空切片，Count 返回 1 + s 中 UTF-8 代码点的数量。


例:

fmt.Println(bytes.Count([]byte(“cheese”), []byte(“e”)))
fmt.Println(bytes.Count([]byte(“five”), []byte(“”))) // before & after each rune
// Output:
// 3
// 5

func Equal


  1. func Equal(a, b []byte) bool


Equal 在 a 和 b 长度相同并包含相同元素时返回 true。参数为 nil 时默认为空切片。


例:

fmt.Println(bytes.Equal([]byte(“Go”), []byte(“Go”)))
fmt.Println(bytes.Equal([]byte(“Go”), []byte(“C++”)))
// Output:
// true
// false

func EqualFold


  1. func EqualFold(s, t []byte) bool


EqualFold 判断 s 和 t 在 UTF-8 编码下忽略大小写时是否相等。


例:

fmt.Println(bytes.EqualFold([]byte(“Go”), []byte(“go”)))
// Output: true

func Fields


  1. func Fields(s []byte) [][]byte


Fields 会把 s 当作 UTF-8 代码点进行解析。它根据一个或多个空白符（unicode.IsSpace 定义）来分割 s 并返回分割结果切片，在 s 只包含空白符时返回空切片。


例:

fmt.Printf(“Fields are: %q”, bytes.Fields([]byte(“ foo bar baz “)))
// Output: Fields are: [“foo” “bar” “baz”]

func FieldsFunc


  1. func FieldsFunc(s []byte, f func(rune) bool) [][]byte


FieldsFunc 会把 s 当作 UTF-8 代码点进行解析。他根据满足 f(c) 的代码点分割 s 并返回分割结果切片。如果所有的代码点都满足 f(c)，或者 len(s)==0，会返回空切片。FieldsFunc 不保证 f(c) 的调用顺序，如果相同 c 返回不同结果，FieldsFunc 会崩溃。


例:

f := func(c rune) bool {
return !unicode.IsLetter(c) && !unicode.IsNumber(c)
}
fmt.Printf(“Fields are: %q”, bytes.FieldsFunc([]byte(“ foo1;bar2,baz3…”), f))
// Output: Fields are: [“foo1” “bar2” “baz3”]

func HasPrefix


  1. func HasPrefix(s, prefix []byte) bool


HasPrefix 判断 s 是否以 prefix 作为前缀。


例:

fmt.Println(bytes.HasPrefix([]byte(“Gopher”), []byte(“Go”)))
fmt.Println(bytes.HasPrefix([]byte(“Gopher”), []byte(“C”)))
fmt.Println(bytes.HasPrefix([]byte(“Gopher”), []byte(“”)))
// Output:
// true
// false
// true

func HasSuffix


  1. func HasSuffix(s, suffix []byte) bool


HasSuffix 判断 s 是否以 suffix 作为后缀。


例:

fmt.Println(bytes.HasSuffix([]byte(“Amigo”), []byte(“go”)))
fmt.Println(bytes.HasSuffix([]byte(“Amigo”), []byte(“O”)))
fmt.Println(bytes.HasSuffix([]byte(“Amigo”), []byte(“Ami”)))
fmt.Println(bytes.HasSuffix([]byte(“Amigo”), []byte(“”)))
// Output:
// true
// false
// false
// true

func Index


  1. func Index(s, sep []byte) int


Index 返回 s 中第一次出现 sep 的位置，如果不存在 sep 返回 -1。


例:

fmt.Println(bytes.Index([]byte(“chicken”), []byte(“ken”)))
fmt.Println(bytes.Index([]byte(“chicken”), []byte(“dmr”)))
// Output:
// 4
// -1

func IndexAny


  1. func IndexAny(s []byte, chars string) int


IndexAny 会把 s 当作 UTF-8 代码点进行解析。它返回 s 中第一次出现 chars 中 Unicode 代码点的位置。如果 chars 为空或不存在返回 -1。


例:

fmt.Println(bytes.IndexAny([]byte(“chicken”), “aeiouy”))
fmt.Println(bytes.IndexAny([]byte(“crwth”), “aeiouy”))
// Output:
// 2
// -1

func IndexByte


  1. func IndexByte(s []byte, c byte) int


IndexByte 返回 s 中第一次出现 c 的位置，如果不存在返回 -1。


例:

fmt.Println(bytes.IndexByte([]byte(“chicken”), byte(‘k’)))
fmt.Println(bytes.IndexByte([]byte(“chicken”), byte(‘g’)))
// Output:
// 4
// -1

func IndexFunc


  1. func IndexFunc(s []byte, f func(r rune) bool) int


IndexFunc 会把 s 当作 UTF-8 代码点进行解析。它返回 s 中第一个满足 f(c) 的代码点的位置，如果没有返回 -1。


例:

f := func(c rune) bool {
return unicode.Is(unicode.Han, c)
}
fmt.Println(bytes.IndexFunc([]byte(“Hello, 世界”), f))
fmt.Println(bytes.IndexFunc([]byte(“Hello, world”), f))
// Output:
// 7
// -1

func IndexRune


  1. func IndexRune(s []byte, r rune) int


IndexFunc 会把 s 当作 UTF-8 代码点进行解析。它返回 s 中第一次出现 rune 的位置。如果没有返回 -1。如果 r 为 utf8.RuneError，它返回第一次出现无效 UTF-8 字符序列的位置。


例:

fmt.Println(bytes.IndexRune([]byte(“chicken”), ‘k’))
fmt.Println(bytes.IndexRune([]byte(“chicken”), ‘d’))
// Output:
// 4
// -1

func Join


  1. func Join(s [][]byte, sep []byte) []byte


Join 会把 s 中的切片用 sep 连接起来并返回。sep 会出现在 s 的每个元素之间。


例:

s := [][]byte{[]byte(“foo”), []byte(“bar”), []byte(“baz”)}
fmt.Printf(“%s”, bytes.Join(s, []byte(“, “)))
// Output: foo, bar, baz

func LastIndex


  1. func LastIndex(s, sep []byte) int


LastIndex 返回 s 中最后一次出现 sep 的位置，如果不存在返回 -1。


例:

fmt.Println(bytes.Index([]byte(“go gopher”), []byte(“go”)))
fmt.Println(bytes.LastIndex([]byte(“go gopher”), []byte(“go”)))
fmt.Println(bytes.LastIndex([]byte(“go gopher”), []byte(“rodent”)))
// Output:
// 0
// 3
// -1

func LastIndexAny


  1. func LastIndexAny(s []byte, chars string) int


LastIndexAny 会把 s 当作 UTF-8 代码点进行解析。它返回 s 最后一次出现 chars 中 Unicode 代码点的位置。如果没有或 chars 为空返回 -1。


例:

fmt.Println(bytes.LastIndexAny([]byte(“go gopher”), “MüQp”))
fmt.Println(bytes.LastIndexAny([]byte(“go 地鼠”), “地大”))
fmt.Println(bytes.LastIndexAny([]byte(“go gopher”), “z,!.”))
// Output:
// 5
// 3
// -1

func LastIndexByte


  1. func LastIndexByte(s []byte, c byte) int


LastIndexByte 返回 s 中最后一次出现 c 的位置，如果不存在返回 -1。


例:

fmt.Println(bytes.LastIndexByte([]byte(“go gopher”), byte(‘g’)))
fmt.Println(bytes.LastIndexByte([]byte(“go gopher”), byte(‘r’)))
fmt.Println(bytes.LastIndexByte([]byte(“go gopher”), byte(‘z’)))
// Output:
// 3
// 8
// -1

func LastIndexFunc


  1. func LastIndexFunc(s []byte, f func(r rune) bool) int


LastIndexFunc 会把 s 当作 UTF-8 代码点进行解析。它返回最后一个满足 f(c) 的 Unicode 代码点的位置，如果没有返回 -1。


例:

fmt.Println(bytes.LastIndexFunc([]byte(“go gopher!”), unicode.IsLetter))
fmt.Println(bytes.LastIndexFunc([]byte(“go gopher!”), unicode.IsPunct))
fmt.Println(bytes.LastIndexFunc([]byte(“go gopher!”), unicode.IsNumber))
// Output:
// 8
// 9
// -1

func Map


  1. func Map(mapping func(r rune) rune, s []byte) []byte


Map 返回每个字节都被 mapping 处理过的 s 切片的拷贝。如果 mappding 返回负数该字符不会出现在结果切片中。s 中的字符会以 UTF-8 代码点的形式进行解析。


例:

rot13 := func(r rune) rune {
switch {
case r >= ‘A’ && r <= ‘Z’:
return ‘A’ + (r-‘A’+13)%26
case r >= ‘a’ && r <= ‘z’:
return ‘a’ + (r-‘a’+13)%26
}
return r
}
fmt.Printf(“%s”, bytes.Map(rot13, []byte(“‘Twas brillig and the slithy gopher…”)))
// Output: ‘Gjnf oevyyvt naq gur fyvgul tbcure…

func Repeat


  1. func Repeat(b []byte, count int) []byte


Repeat 返回重复 count 次 b 的新切片。

如果 count 为负数或者 (len(b) count) 溢出函数会 panic。


例:

fmt.Printf(“ba%s”, bytes.Repeat([]byte(“na”), 2))
// Output: banana

func Replace


  1. func Replace(s, old, new []byte, n int) []byte


Replace 将 s 中的前 n 个 old 替换成 new 并作为新切片返回。如果 old 为空，它会匹配切片de1起点和每个 UTF-8 序列的结尾，对于 k 个 rune 的切片会替换 k + 1 次。如果 n<0，不会限制替换次数。
例:

fmt.Printf(“%s\n”, bytes.Replace([]byte(“oink oink oink”), []byte(“k”), []byte(“ky”), 2))
fmt.Printf(“%s\n”, bytes.Replace([]byte(“oink oink oink”), []byte(“oink”), []byte(“moo”), -1))
// Output:
// oinky oinky oink
// moo moo moo

func Runes


  1. func Runes(s []byte) []rune


Runes 会把 s 当作 UTF-8 代码点进行解析。它返回 s 对应的 rune（Unicode 代码点）切片。


例:

rs := bytes.Runes([]byte(“go gopher”))
for _, r := range rs {
fmt.Printf(“%#U\n”, r)
}
// Output:
// U+0067 ‘g’
// U+006F ‘o’
// U+0020 ‘ ‘
// U+0067 ‘g’
// U+006F ‘o’
// U+0070 ‘p’
// U+0068 ‘h’
// U+0065 ‘e’
// U+0072 ‘r’

func Split


  1. func Split(s, sep []byte) [][]byte


Split 根据 sep 分割 s 并返回分割结果组成的切片。如果 sep 为空，Split 会分割每个 UTF-8 序列。它和 count 等于 -1 的 SplitN 相同。


例:

fmt.Printf(“%q\n”, bytes.Split([]byte(“a,b,c”), []byte(“,”)))
fmt.Printf(“%q\n”, bytes.Split([]byte(“a man a plan a canal panama”), []byte(“a “)))
fmt.Printf(“%q\n”, bytes.Split([]byte(“ xyz “), []byte(“”)))
fmt.Printf(“%q\n”, bytes.Split([]byte(“”), []byte(“Bernardo O’Higgins”)))
// Output:
// [“a” “b” “c”]
// [“” “man “ “plan “ “canal panama”]
// [“ “ “x” “y” “z” “ “]
// [“”]

func SplitAfter


  1. func SplitAfter(s, sep []byte) [][]byte


SplitAfter 从 s 中的每个 sep 后的位置分割 s 并返回分割结果组成的切片。如果 sep 为空，SplitAfter 会分割每个 UTF-8 序列。它和 count 为 -1 的 SplitAfterN 相同。


例:

fmt.Printf(“%q\n”, bytes.SplitAfter([]byte(“a,b,c”), []byte(“,”)))
// Output: [“a,” “b,” “c”]

func SplitAfterN


  1. func SplitAfterN(s, sep []byte, n int) [][]byte


SplitAfterN slices s into subslices after each instance of sep and returns a
slice of those subslices. If sep is empty, SplitAfterN splits after each UTF-8
sequence. The count determines the number of subslices to return:

SplitAfterN 从 s 中的每个 sep 后的位置分割 s 并返回分割结果组成的切片。如果 sep 为空，SplitAfter 会分割每个 UTF-8 序列。count 决定返回结果元素的数量：

n > 0: 最多 n 个元素。最后一个元素包含 s 中未分割的部分。
n == 0: 返回 nil。
n < 0: 不限制返回结果长度。


例:

fmt.Printf(“%q\n”, bytes.SplitAfterN([]byte(“a,b,c”), []byte(“,”), 2))
// Output: [“a,” “b,c”]

func SplitN


  1. func SplitN(s, sep []byte, n int) [][]byte


SplitN 根据 sep 分割 s 并返回分割结果组成的切片。如果 sep 为空，Split 会分割每个 UTF-8 序列。count 决定返回结果元素的数量：

n > 0: 最多 n 个元素。最后一个元素包含 s 中未分割的部分。
n == 0: 返回 nil。
n < 0: 不限制返回结果长度。


例:

fmt.Printf(“%q\n”, bytes.SplitN([]byte(“a,b,c”), []byte(“,”), 2))
z := bytes.SplitN([]byte(“a,b,c”), []byte(“,”), 0)
fmt.Printf(“%q (nil = %v)\n”, z, z == nil)
// Output:
// [“a” “b,c”]
// [] (nil = true)

func Title


  1. func Title(s []byte) []byte


Title 把 s 做为 UTF-8 编码字节切片并返回单词首字母为 Unicode 字符对应 Title 形式的切片。

BUG(rsc): Title 使用的规则不会处理 Unicode 的标点符号。


例:

fmt.Printf(“%s”, bytes.Title([]byte(“her royal highness”)))
// Output: Her Royal Highness

func ToLower


  1. func ToLower(s []byte) []byte


ToLower 把 s 做为 UTF-8 编码字节切片返回由所有 Unicode 字符对应的小写形式组成的切片。


例:

fmt.Printf(“%s”, bytes.ToLower([]byte(“Gopher”)))
// Output: gopher

func ToLowerSpecial


  1. func ToLowerSpecial(c unicode.SpecialCase, s []byte) []byte


ToLowerSpecial 把 s 做为 UTF-8 编码字节切片返回根据指定规则 c 由所有 Unicode 字符对应的小写形式组成的切片。

func ToTitle


  1. func ToTitle(s []byte) []byte


ToTitle 把 s 做为 UTF-8 编码字节切片并返回所有 Unicode 字符对应的 Title 形式组成的切片。


例:

fmt.Printf(“%s\n”, bytes.ToTitle([]byte(“loud noises”)))
fmt.Printf(“%s\n”, bytes.ToTitle([]byte(“хлеб”)))
// Output:
// LOUD NOISES
// ХЛЕБ

func ToTitleSpecial


  1. func ToTitleSpecial(c unicode.SpecialCase, s []byte) []byte


ToTitleSpecial 把 s 做为 UTF-8 编码字节切片并根据指定规则 c 返回所有 Unicode 字符对应的 Title 形式组成的切片。

func ToUpper


  1. func ToUpper(s []byte) []byte


ToTitle 把 s 做为 UTF-8 编码字节切片并返回所有 Unicode 字符对应的大写形式组成的切片。


例:

fmt.Printf(“%s”, bytes.ToUpper([]byte(“Gopher”)))
// Output: GOPHER

func ToUpperSpecial


  1. func ToUpperSpecial(c unicode.SpecialCase, s []byte) []byte


ToUpperSpecial 把 s 做为 UTF-8 编码字节切片并根据指定规则 c 返回所有 Unicode 字符对应的大写形式组成的切片。

func Trim


  1. func Trim(s []byte, cutset string) []byte


Trim 会返回 s 的一个子串，它不包含开头和结尾的 cutset。


例:

fmt.Printf(“[%q]”, bytes.Trim([]byte(“ !!! Achtung! Achtung! !!! “), “! “))
// Output: [“Achtung! Achtung”]

func TrimFunc


  1. func TrimFunc(s []byte, f func(r rune) bool) []byte


TrimFunc 去掉 s 中开头和结尾满足 f(c) 的 UTF-8 代码点。


例:

fmt.Println(string(bytes.TrimFunc([]byte(“go-gopher!”), unicode.IsLetter)))
fmt.Println(string(bytes.TrimFunc([]byte(“\”go-gopher!\””), unicode.IsLetter)))
fmt.Println(string(bytes.TrimFunc([]byte(“go-gopher!”), unicode.IsPunct)))
fmt.Println(string(bytes.TrimFunc([]byte(“1234go-gopher!567”), unicode.IsNumber)))
// Output:
// -gopher!
// “go-gopher!”
// go-gopher
// go-gopher!

func TrimLeft


  1. func TrimLeft(s []byte, cutset string) []byte


TrimLeft 去掉 s 开头 cutset 包含的 UTF-8 代码点。


例:

fmt.Print(string(bytes.TrimLeft([]byte(“453gopher8257”), “0123456789”)))
// Output:
// gopher8257

func TrimLeftFunc


  1. func TrimLeftFunc(s []byte, f func(r rune) bool) []byte


TrimLeftFunc 会把 s 最为 UTF-8 编码字节处理并去掉开头满足 f(c) 的 UTF-8 代码点并返回。


例:

fmt.Println(string(bytes.TrimLeftFunc([]byte(“go-gopher”), unicode.IsLetter)))
fmt.Println(string(bytes.TrimLeftFunc([]byte(“go-gopher!”), unicode.IsPunct)))
fmt.Println(string(bytes.TrimLeftFunc([]byte(“1234go-gopher!567”), unicode.IsNumber)))
// Output:
// -gopher
// go-gopher!
// go-gopher!567

func TrimPrefix


  1. func TrimPrefix(s, prefix []byte) []byte


TrimPrefix 去掉 s 的 prefix 前缀并返回，如果 s 没有 prefix 前缀，s 直接返回。


例:

var b = []byte(“Goodbye,, world!”)
b = bytes.TrimPrefix(b, []byte(“Goodbye,”))
b = bytes.TrimPrefix(b, []byte(“See ya,”))
fmt.Printf(“Hello%s”, b)
// Output: Hello, world!

func TrimRight


  1. func TrimRight(s []byte, cutset string) []byte


TrimRight 去掉 s 中所有 cutset 中的 UTF-8 代码点并返回。


例:

fmt.Print(string(bytes.TrimRight([]byte(“453gopher8257”), “0123456789”)))
// Output:
// 453gopher

func TrimRightFunc


  1. func TrimRightFunc(s []byte, f func(r rune) bool) []byte


TrimRightFunc 去掉 s 中满足 f(c) 的 UTF-8 代码点并返回。


例:

fmt.Println(string(bytes.TrimRightFunc([]byte(“go-gopher”), unicode.IsLetter)))
fmt.Println(string(bytes.TrimRightFunc([]byte(“go-gopher!”), unicode.IsPunct)))
fmt.Println(string(bytes.TrimRightFunc([]byte(“1234go-gopher!567”), unicode.IsNumber)))
// Output:
// go-
// go-gopher
// 1234go-gopher!

func TrimSpace


  1. func TrimSpace(s []byte) []byte


TrimSpace 去掉 s 中开头和结尾的 Unicode 定义的空白符并返回。


例:

fmt.Printf(“%s”, bytes.TrimSpace([]byte(“ \t\n a lone gopher \n\t\r\n”)))
// Output: a lone gopher

func TrimSuffix


  1. func TrimSuffix(s, suffix []byte) []byte


TrimSuffix 返回去掉 suffix 后缀的 s 。如果 s 没有 suffix 后缀，会直接返回 s。


例:

var b = []byte(“Hello, goodbye, etc!”)
b = bytes.TrimSuffix(b, []byte(“goodbye, etc!”))
b = bytes.TrimSuffix(b, []byte(“gopher”))
b = append(b, bytes.TrimSuffix([]byte(“world!”), []byte(“x!”))…)
os.Stdout.Write(b)
// Output: Hello, world!

type Buffer


  1. type Buffer struct {
        // contains filtered or unexported fields
    }


Buffer 是一个可以读取或写入数据的动态尺寸的字节缓存区。Buffer 的零值是一个可以使用的缓冲区。


例:

var b bytes.Buffer // Buffer 不需要初始化
b.Write([]byte(“Hello “))
fmt.Fprintf(&b, “world!”)
b.WriteTo(os.Stdout)
// Output: Hello world!



例:

// Buffer 将字符串或者 []byte 放入 io.Reader。
buf := bytes.NewBufferString(“R29waGVycyBydWxlIQ==”)
dec := base64.NewDecoder(base64.StdEncoding, buf)
io.Copy(os.Stdout, dec)
// Output: Gophers rule!

func NewBuffer


  1. func NewBuffer(buf []byte) Buffer


NewBuffer 把 buf 做为初始内容来创建和初始化一个新的 Buffer。新的 Buffer 接管 buf，并且调用者不应该在调用后再使用 buf。NewBuffer 主要为了准备一块缓冲区读取现存数据。它也可以用来调整写入内部缓冲区的大小。如果想这么做，buf 应是一个指定容积长度为零的切片。

In most cases, new(Buffer) (or just declaring a Buffer variable) is sufficient
to initialize a Buffer.

func NewBufferString


  1. func NewBufferString(s string) Buffer


NewBufferString 把字符串 s 作为初始内容创建并初始化一个新的 Buffer。它主要为了准备一块缓冲区来读取现在的字符串。

大多数情况下，new(Buffer) （或者只声明一个 Buffer 变量）就可以初始化一个 Buffer。

func (Buffer) Bytes


  1. func (b Buffer) Bytes() []byte


Bytes 返回长度 b.Len() 对应的未读缓存的切片。切片在下一次缓存修改（例如：Read，Write，Reset 或 Truncate）之前都有效。切片至少在下一次缓存改变前是引用缓存数据的，所以改变切片内容会影响之后的读取操作。

func (Buffer) Cap


  1. func (b Buffer) Cap() int


Cap 返回缓存底层字节切片的容积。它是分配给缓存的空间大小。

func (Buffer) Grow


  1. func (b Buffer) Grow(n int)


Grow 会为缓存增加 n 字节的容积。在调用 Grow(n) 之后，不用分配额外空间就可以至少向缓存写入 n 字节的数据。如果 n 为负数，Grow 会 panic。如果缓存不会再增加会 panic 并携带 ErrTooLarge 错误。


例:

var b bytes.Buffer
b.Grow(64)
bb := b.Bytes()
b.Write([]byte(“64 bytes or fewer”))
fmt.Printf(“%q”, bb[:b.Len()])
// Output: “64 bytes or fewer”

func (Buffer) Len


  1. func (b Buffer) Len() int


Len 返回缓存中未读的字节数；b.Len()==len(b.Bytes())。

func (Buffer) Next


  1. func (b Buffer) Next(n int) []byte


Next 返回一个包含缓存中下 n 字节的切片，就像 Read 返回的字节一样。如果缓存中含有不到 n 个字符，Next 会把它们全部返回。返回的切片在下一次的读写调用之前有效。

func (Buffer) Read


  1. func (b Buffer) Read(p []byte) (n int, err error)


Read 从缓存中读取下 len(p) 个字节或者直到缓存最后。返回值 n 为读取到的字节数。如果缓存会有数据返回，err 为 io.EOF(除非 len(p) 为 0)；否则 err 为 nil。

func (Buffer) ReadByte


  1. func (b Buffer) ReadByte() (byte, error)


ReadByte 读取并返回缓存的下一个字节，如果没有有效字节返回 io.EOF。

func (Buffer) ReadBytes


  1. func (b Buffer) ReadBytes(delim byte) (line []byte, err error)


ReadBytes 会读取缓存中直到第一个 delim 字节的数据，返回的字节切片包括 delim 和它之前的数据。如果 ReadBytes 在找到 delim 之前发生错误，会返回发生错误之前读取的数据和错误本身（一般为 io.EOF）。只有在数据没有以 delim 结束的时候返回的 err != nil。

func (Buffer) ReadFrom


  1. func (b Buffer) ReadFrom(r io.Reader) (n int64, err error)


ReadFrom 从 r 中读取一直到 EOF 的数据并将数据追加到缓存中，缓存的大小会按需增加。返回值 n 为读取的字节数。除了 io.EOF 以外任何读取时发生的错误都会返回。如果缓存变得过大 Write 会 panic 并附带 ErrTooLarge 错误。

func (Buffer) ReadRune


  1. func (b Buffer) ReadRune() (r rune, size int, err error)


ReadRune 读取并返回缓存中的下一个 UTF-8 代码点。如果没有有效字节，返回的错误为 io.EOF。如果字节为无效的 UFT-8 编码字节，返回 U+FFFD, 1。

func (Buffer) ReadString


  1. func (b Buffer) ReadString(delim byte) (line string, err error)


ReadString 会读取缓存中直到第一个 delim 字节的数据，返回的字符串包括 delim 和它之前的数据。如果 ReadString 在找到 delim 之前发生错误，会返回发生错误之前读取的数据和错误本身（一般为 io.EOF）。只有在数据没有以 delim 结束的时候返回的 err != nil。

func (Buffer) Reset


  1. func (b Buffer) Reset()


Reset 会清空缓存但是保留底层的存储空间用来接收写入的内容。Reset 和 Truncate(0) 相同。

func (Buffer) String


  1. func (b Buffer) String() string


String 把缓存的未读部分作为字符串返回。如果缓存是一个 nil 指针，它会返回 <nil>

更有效的构建字符串可以使用 strings.Builder 类型。

func (Buffer) Truncate


  1. func (b Buffer) Truncate(n int)


Truncate 丢弃缓存中除前 n 个未读字节以外的其他内容并继续使用原来的存储空间。如果 n 为负数或者大于缓存长度会 panic。

func (Buffer) UnreadByte


  1. func (b Buffer) UnreadByte() error


UnreadByte 将最近一次成功的读取操作返回的字节标记为未读。如果在最近一次读取之后发生写入操作，或者最近一次读取操作返回 error，或着读取操作读取了 0 字节，那么 UnreadByte 就会返回错误。

func (Buffer) UnreadRune


  1. func (b Buffer) UnreadRune() error


UnreadRune 将 ReadRune 返回的最近一个 rune 标记为未读。如果针对缓存最近的读取或写入操作没有成功，UnreadRune 会返回错误（在这方面它比 UnreadByte 更加严格，UnreadByte 会把最近任何一个读取操作的字符标记为未读）。

func (Buffer) Write


  1. func (b Buffer) Write(p []byte) (n int, err error)


Write 将 p 追加进缓存，缓存会按需增大。返回值 n 为 p 的长度；err 一直为 nil。如果缓存变得过大 Write 会 panic 并附带 ErrTooLarge 错误。

func (Buffer) WriteByte


  1. func (b Buffer) WriteByte(c byte) error


WriteByte 把 c 追加进缓存，缓存会按需增大。返回的错误一直为 nil，它主要是为了匹配 bufio.Writer 的 WriteByte。

如果缓存变得过大 WriteByte 会 panic 并附带 ErrTooLarge 错误。

func (Buffer) WriteRune


  1. func (b Buffer) WriteRune(r rune) (n int, err error)


WriteRune 把 UTF-8 代码点 r 追加进缓存，并返回它的长度和错误（固定为 nil 为了匹配 bufio.Writer 的 WriteRune 接口）。缓存会按需增大；如果缓存变得过大 WriteRune 会 panic 并附带 ErrTooLarge 错误。

func (Buffer) WriteString


  1. func (b Buffer) WriteString(s string) (n int, err error)


WriteString 会把 s 的内容追加给缓存，它会在需要的时候增加缓存大小。返回值 n 为 s 的长度；err 总是为 nil。如果缓存变得太大，WriteString 会 panic 并附带 ErrTooLarge 错误。

func (Buffer) WriteTo


  1. func (b Buffer) WriteTo(w io.Writer) (n int64, err error)


WriteTo 将数据写入 w 直到缓存已满或发生错误。返回值 n 为写入的字节数；它一般都是 int，不过为了满足 io.WriteTo 接口所以为 int64 类型。写入当中发生的错误都会返回给调用者。

type Reader


  1. type Reader struct {
        // contains filtered or unexported fields
    }


Reader 实现了 io.Reader， io.ReaderAt， io.WriterTo， io.Seeker，io.ByteScanner 和 io.RuneScanner 接口来读取字节切片。与 Buffer 不同它是只读的并且支持 seeking。

func NewReader


  1. func NewReader(b []byte) Reader


NewReader 返回一个读取 b 的新 Reader。

func (Reader) Len


  1. func (r Reader) Len() int


Len 返回 Reader 还未读取的切片长度。


例:

fmt.Println(bytes.NewReader([]byte(“Hi!”)).Len())
fmt.Println(bytes.NewReader([]byte(“こんにちは!”)).Len())
// Output:
// 3
// 16

func (Reader) Read


  1. func (r Reader) Read(b []byte) (n int, err error)


Read 实现了 io.Reader 接口。

func (Reader) ReadAt


  1. func (r Reader) ReadAt(b []byte, off int64) (n int, err error)


ReadAt 实现了 io.ReaderAt 接口。

func (Reader) ReadByte


  1. func (r Reader) ReadByte() (byte, error)


ReadByte 实现了 io.ByteReader 接口。

func (Reader) ReadRune


  1. func (r Reader) ReadRune() (ch rune, size int, err error)


ReadRune 实现了 io.RuneReader 接口。

func (Reader) Reset


  1. func (r Reader) Reset(b []byte)


Reset 重置 Reader 来读取 b。

func (Reader) Seek


  1. func (r Reader) Seek(offset int64, whence int) (int64, error)


Seek 实现了 io.Seeker 接口。

func (Reader) Size


  1. func (r Reader) Size() int64


Size 返回底层字节数组的长度。Size 是 ReadAt 能够读取的有效字节数。它的返回值是固定的不受其他方法影响

func (Reader) UnreadByte


  1. func (r Reader) UnreadByte() error


UnreadByte 为 ReadByte 实现了 io.ByteScanner 接口。

func (Reader) UnreadRune


  1. func (r Reader) UnreadRune() error


UnreadRune 为 ReadRune 实现了 io.RuneScanner 接口。

func (Reader) WriteTo


  1. func (r Reader) WriteTo(w io.Writer) (n int64, err error)


WriteTo 实现了 io.WriterTo 接口。

Bugs

  • ☞ Title 使用的规则不会处理 Unicode 标点符号。