概述

索引

文件

bytes.go bytes_decl.go

Constants

Variables

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

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

func Compare


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


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 


  1. func Contains(b, subslice []) 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 ) 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 ) 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)


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 


  1. func Equal(a, b []) 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)


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


例:

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

func 


  1. func Fields(s []) [][]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




    FieldsFunc 会把 s 当作 UTF-8 代码点进行解析。他根据满足 f(c) 的代码点分割 s 并返回分割结果切片。如果所有的代码点都满足 ，或者 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 


    1. func HasPrefix(s, prefix []) 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)


    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 


    1. func Index(s, sep []) 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


    1. func IndexAny(s []byte, chars ) 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 ) 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 ) bool)


    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 


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


    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 


    1. func Join(s [][], sep []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 


    1. func LastIndex(s, sep []) 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 ) 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 ) 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 ) bool)


    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 


    1. func Map(mapping func(r ) rune, s []) []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 ) []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 ) []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) []


    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 


    1. func Split(s, sep []) [][]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




    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 


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


    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 


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


    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)


    1. func Title(s []) []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) []


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


    例:

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

    func 


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


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

    func 


    1. func ToTitle(s []) []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., s []byte) []


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

    func ToUpper


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


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


    例:

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

    func 


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


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

    func 


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


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


    例:

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

    func 


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


    TrimFunc 去掉 s 中开头和结尾满足 的 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 ) []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 ) bool) []


    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 


    1. func TrimPrefix(s, prefix []) []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 ) []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 ) bool) []


    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 


    1. func TrimSpace(s []) []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) []


    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 


    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)


    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)


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

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

    func (Buffer) Bytes


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


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

    func (Buffer) Cap


    1. func (b Buffer) Cap()


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

    func (Buffer) Grow


    1. func (b Buffer) Grow(n )


    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) 


    1. func (b ) Len() int


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

    func (Buffer) 


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


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

    func (Buffer) Read


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


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

    func (Buffer) ReadByte




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

    func (Buffer) ReadBytes


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


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


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


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

    func (Buffer) 


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


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

    func (Buffer) 


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


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

    func (Buffer) 


    1. func (b ) Reset()


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

    func (Buffer) String


    1. func (b Buffer) String()


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

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

    func (Buffer) Truncate


    1. func (b Buffer) Truncate(n )


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

    func (Buffer) UnreadByte


    1. func (b Buffer) UnreadByte()


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

    func (Buffer) UnreadRune


    1. func (b Buffer) UnreadRune()


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

    func (Buffer) Write


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


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

    func (Buffer) WriteByte


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


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

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

    func (Buffer) 


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


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

    func (Buffer) 


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


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


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


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


    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)


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

    func (Reader) Len


    1. func (r Reader) Len()


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


    例:

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

    func (Reader) 


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


    Read 实现了 io.Reader 接口。

    func (Reader) 


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


    ReadAt 实现了 io.ReaderAt 接口。

    func (Reader) ReadByte


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


    ReadByte 实现了 io.ByteReader 接口。

    func (Reader) 


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


    ReadRune 实现了 io.RuneReader 接口。

    func (Reader) 


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


    Reset 重置 Reader 来读取 b。

    func (Reader) 


    1. func (r ) Seek(offset int64, whence ) (int64, )


    Seek 实现了 io.Seeker 接口。

    func (Reader) Size


    1. func (r Reader) Size()


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

    func (Reader) UnreadByte


    1. func (r Reader) UnreadByte()


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

    func (Reader) UnreadRune


    1. func (r Reader) UnreadRune()


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


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


    WriteTo 实现了 io.WriterTo 接口。

    Bugs

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