// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package bytes_test
import (
"bytes"
"encoding/base64"
"fmt"
"io"
"os"
"sort"
"unicode"
)
func ExampleBuffer() {
// 声明buffer
var b bytes.Buffer // A Buffer needs no initialization.
b.Write([]byte("Hello "))
fmt.Fprintf(&b, "world!")
b.WriteTo(os.Stdout)
// Output: Hello world!
}
func ExampleBuffer_reader() {
// A Buffer can turn a string or a []byte into an io.Reader.
// 根据字符串创建buffer
buf := bytes.NewBufferString("R29waGVycyBydWxlIQ==")
// 创建一个新的base64流解码器
dec := base64.NewDecoder(base64.StdEncoding, buf)
io.Copy(os.Stdout, dec)
// Output: Gophers rule!
}
func ExampleBuffer_Grow() {
var b bytes.Buffer
// 增加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 ExampleBuffer_Len() {
var b bytes.Buffer
b.Grow(64)
b.Write([]byte("abcde"))
fmt.Printf("%d", b.Len())
// Output: 5
}
func ExampleCompare() {
// Interpret Compare's result by comparing it to zero.
//比较a和b, 返回 0: a等于b, 1: a包含b, -1: a不包含b
//bytes.Compare(a, b)
var a, b []byte
if bytes.Compare(a, b) < 0 {
// a less b
}
if bytes.Compare(a, b) <= 0 {
// a less or equal b
}
if bytes.Compare(a, b) > 0 {
// a greater b
}
if bytes.Compare(a, b) >= 0 {
// a greater or equal b
}
// Prefer Equal to Compare for equality comparisons.
//判断a与b是否相同,忽略大小写
if bytes.Equal(a, b) {
// a equal b
}
if !bytes.Equal(a, b) {
// a not equal b
}
}
func ExampleCompare_search() {
// Binary search to find a matching byte slice.
var needle []byte
var haystack [][]byte // Assume sorted
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 ExampleTrimSuffix() {
//如果a以b结尾,则返回a去掉b结尾部分的新byte。如果不是,返回a
//bytes.TrimSuffix(a, b)
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!
}
func ExampleTrimPrefix() {
//如果a以b开头,则返回a去掉b开头部分的新byte。如果不是,返回a
//bytes.TrimPrefix(a, b)
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 ExampleFields() {
//以一个或者多个空格分割成切片
//bytes.Fields([]byte(" foo bar baz "))
fmt.Printf("Fields are: %q", bytes.Fields([]byte(" foo bar baz ")))
// Output: Fields are: ["foo" "bar" "baz"]
}
func ExampleFieldsFunc() {
//根据指定方法分割成切片
//bytes.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 ExampleContains() {
//判断a是否包含b
//bytes.Contains(a, b)
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 ExampleContainsAny() {
//判断byte是否包含字符串中任意字符,只要包含字符串中一个及以上字符返回true,否则false
//bytes.ContainsAny([]byte("I like seafood."), "fÄo!")
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 ExampleContainsRune() {
//判断byte是否包含rune字符
//bytes.ContainsRune([]byte("I like seafood."), 'f')
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 ExampleCount() {
//统计a中包含所有b的个数,如果b为空则返回a的长度
//bytes.Count(a, b)
fmt.Println(bytes.Count([]byte("cheese"), []byte("e")))
fmt.Println(bytes.Count([]byte("five"), []byte(""))) // before & after each rune
// Output:
// 3
// 5
}
func ExampleEqual() {
//判断a与b是否相同
//bytes.Equal(a, b)
fmt.Println(bytes.Equal([]byte("Go"), []byte("Go")))
fmt.Println(bytes.Equal([]byte("Go"), []byte("C++")))
// Output:
// true
// false
}
func ExampleEqualFold() {
//判断a与b是否相同,忽略大小写
//bytes.EqualFold(a, b)
fmt.Println(bytes.EqualFold([]byte("Go"), []byte("go")))
// Output: true
}
func ExampleHasPrefix() {
//判断a是否以b开头,当b为空时true
//bytes.HasPrefix(a, b)
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 ExampleHasSuffix() {
//判断a是否以b结尾,当b为空时true
//bytes.HasSuffix(a, b)
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 ExampleIndex() {
//检索a中首个b的位置,未检索到返回-1
//bytes.Index(a, b)
fmt.Println(bytes.Index([]byte("chicken"), []byte("ken")))
fmt.Println(bytes.Index([]byte("chicken"), []byte("dmr")))
// Output:
// 4
// -1
}
func ExampleIndexByte() {
//检索a中首个 byte类型字符 的位置,未检索到返回-1
//bytes.IndexByte(a, byte('k'))
fmt.Println(bytes.IndexByte([]byte("chicken"), byte('k')))
fmt.Println(bytes.IndexByte([]byte("chicken"), byte('g')))
// Output:
// 4
// -1
}
func ExampleIndexFunc() {
//自定义方法检索首个字符的位置,未检索到返回-1
//bytes.IndexFunc(
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 ExampleIndexAny() {
//检索a中首个 字符串中任意字符 的位置,未检索到返回-1
//bytes.IndexAny(a, "abc")
fmt.Println(bytes.IndexAny([]byte("chicken"), "aeiouy"))
fmt.Println(bytes.IndexAny([]byte("crwth"), "aeiouy"))
// Output:
// 2
// -1
}
func ExampleIndexRune() {
//检索a中首个 rune类型字符 的位置,未检索到返回-1
//bytes.IndexRune([]byte("chicken"), 'k')
fmt.Println(bytes.IndexRune([]byte("chicken"), 'k'))
fmt.Println(bytes.IndexRune([]byte("chicken"), 'd'))
// Output:
// 4
// -1
}
func ExampleLastIndex() {
//检索a中首个b的位置,未检索到返回-1
//bytes.Index(a, b)
fmt.Println(bytes.Index([]byte("go gopher"), []byte("go")))
//检索a中最后个b的位置,未检索到返回-1
//bytes.LastIndex(a, b)
fmt.Println(bytes.LastIndex([]byte("go gopher"), []byte("go")))
fmt.Println(bytes.LastIndex([]byte("go gopher"), []byte("rodent")))
// Output:
// 0
// 3
// -1
}
func ExampleLastIndexAny() {
//参数二中任意一utf-8字符在参数一中最后一次出现的位置
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 ExampleLastIndexByte() {
//检索a中最后个 byte类型字符 的位置,未检索到返回-1
//bytes.LastIndexByte(a, byte('k'))
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 ExampleLastIndexFunc() {
//自定义方法检索最后个字符的位置,未检索到返回-1
//bytes.LastIndexFunc(a, unicode.IsLetter)
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 ExampleJoin() {
//将byte数组以指定 byte字符 连接成一个新的byte
//s := [][]byte{a, b}
//bytes.Join(s, []byte(","))
s := [][]byte{[]byte("foo"), []byte("bar"), []byte("baz")}
fmt.Printf("%s", bytes.Join(s, []byte(", ")))
// Output: foo, bar, baz
}
func ExampleRepeat() {
// 返回一个重复n次a的新byte
// 例如:a = []byte("abc"),返回 []byte("abcabc")
// bytes.Repeat(a, 2)
fmt.Printf("ba%s", bytes.Repeat([]byte("na"), 2))
// Output: banana
}
func ExampleReplace() {
//返回一个 将a中的b替换为c 的新byte,n为替换个数,-1替换所有
//bytes.Replace(a, b, c, -1)
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 ExampleReplaceAll() {
//返回一个 将a中的b替换为c 的新byte
//bytes.ReplaceAll(a, b, c)
fmt.Printf("%s\n", bytes.ReplaceAll([]byte("oink oink oink"), []byte("oink"), []byte("moo")))
// Output:
// moo moo moo
}
func ExampleRunes() {
//byte类型转rune类型
//bytes.Runes(a)
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 ExampleSplit() {
//将a以指定字符byte分割成byte数组
//bytes.Split(a, []byte(","))
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 ExampleSplitN() {
//将a以指定字符byte分割成byte数组, n为分割个数,-1分割所有
//bytes.SplitN(a, []byte(","), 2)
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 ExampleSplitAfter() {
//将a以指定字符byte分割成byte数组,保留b。
//bytes.SplitAfter(a, []byte(","))
fmt.Printf("%q\n", bytes.SplitAfter([]byte("a,b,c"), []byte(",")))
// Output: ["a," "b," "c"]
}
func ExampleSplitAfterN() {
//将a以指定字符byte分割成byte数组,保留b。n为分割个数,-1分割所有
//bytes.SplitAfterN(a, []byte(","), 2)
fmt.Printf("%q\n", bytes.SplitAfterN([]byte("a,b,c"), []byte(","), 2))
// Output: ["a," "b,c"]
}
func ExampleTitle() {
//返回一个 以空格为界限,所有首个字母大写 的标题格式
//bytes.Title(a)
fmt.Printf("%s", bytes.Title([]byte("her royal highness")))
// Output: Her Royal Highness
}
func ExampleToTitle() {
//返回一个 所有字母大写 的标题格式
//bytes.ToTitle(a)
fmt.Printf("%s\n", bytes.ToTitle([]byte("loud noises")))
fmt.Printf("%s\n", bytes.ToTitle([]byte("хлеб")))
// Output:
// LOUD NOISES
// ХЛЕБ
}
func ExampleToTitleSpecial() {
//使用指定的映射表将 a 中的所有字符修改为标题格式返回。
//bytes.ToTitleSpecial(unicode.SpecialCase{}, a)
str := []byte("ahoj vývojári golang")
totitle := bytes.ToTitleSpecial(unicode.AzeriCase, str)
fmt.Println("Original : " + string(str))
fmt.Println("ToTitle : " + string(totitle))
// Output:
// Original : ahoj vývojári golang
// ToTitle : AHOJ VÝVOJÁRİ GOLANG
}
func ExampleTrim() {
//去除开头结尾所有的 指定字符串中的任意字符
//bytes.Trim(a, " ")
fmt.Printf("[%q]", bytes.Trim([]byte(" !!! Achtung! Achtung! !!! "), "! "))
// Output: ["Achtung! Achtung"]
}
func ExampleTrimFunc() {
//按自定义方法 去除开头结尾所有指定内容
//bytes.TrimFunc(a, unicode.IsLetter)
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 ExampleMap() {
//遍历a按指定的rune方法处理每个字符
//bytes.Map(
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
}
//遍历a按指定的rune方法处理每个字符
fmt.Printf("%s", bytes.Map(rot13, []byte("'Twas brillig and the slithy gopher...")))
// Output: 'Gjnf oevyyvt naq gur fyvgul tbcure...
}
func ExampleTrimLeft() {
//去除开头所有的 指定字符串中的任意字符
//bytes.TrimLeft(a, "0123456789")
fmt.Print(string(bytes.TrimLeft([]byte("453gopher8257"), "0123456789")))
// Output:
// gopher8257
}
func ExampleTrimLeftFunc() {
//按自定义方法 去除开头所有指定内容
//bytes.TrimLeftFunc(a, unicode.IsLetter)
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 ExampleTrimSpace() {
//去除开头结尾所有的 空格换行回车缩进
//bytes.TrimSpace(a)
fmt.Printf("%s", bytes.TrimSpace([]byte(" \t\n a lone gopher \n\t\r\n")))
// Output: a lone gopher
}
func ExampleTrimRight() {
//去除结尾所有的 指定字符串中的任意字符
//bytes.TrimRight(a, "0123456789")
fmt.Print(string(bytes.TrimRight([]byte("453gopher8257"), "0123456789")))
// Output:
// 453gopher
}
func ExampleTrimRightFunc() {
//按自定义方法 去除结尾所有指定内容
//bytes.TrimRightFunc(a, unicode.IsLetter)
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 ExampleToUpper() {
//所有字母大写
//bytes.ToUpper(a)
fmt.Printf("%s", bytes.ToUpper([]byte("Gopher")))
// Output: GOPHER
}
func ExampleToUpperSpecial() {
//使用指定的映射表将 a 中的所有字符修改为大写格式返回。
//bytes.ToUpperSpecial(unicode.SpecialCase{}, a)
str := []byte("ahoj vývojári golang")
totitle := bytes.ToUpperSpecial(unicode.AzeriCase, str)
fmt.Println("Original : " + string(str))
fmt.Println("ToUpper : " + string(totitle))
// Output:
// Original : ahoj vývojári golang
// ToUpper : AHOJ VÝVOJÁRİ GOLANG
}
func ExampleToLower() {
//所有字母小写
//bytes.ToLower(a)
fmt.Printf("%s", bytes.ToLower([]byte("Gopher")))
// Output: gopher
}
func ExampleToLowerSpecial() {
//使用指定的映射表将 a 中的所有字符修改为大写格式返回。
//bytes.ToLowerSpecial(unicode.SpecialCase{}, a)
str := []byte("AHOJ VÝVOJÁRİ GOLANG")
totitle := bytes.ToLowerSpecial(unicode.AzeriCase, str)
fmt.Println("Original : " + string(str))
fmt.Println("ToLower : " + string(totitle))
// Output:
// Original : AHOJ VÝVOJÁRİ GOLANG
// ToLower : ahoj vývojári golang
}
func ExampleReader_Len() {
//根据[]byte创建reader
//bytes.NewReader([]byte("Hello World!"))
fmt.Println(bytes.NewReader([]byte("Hi!")).Len())
fmt.Println(bytes.NewReader([]byte("こんにちは!")).Len())
// Output:
// 3
// 16
}
package main
import (
"bytes"
"fmt"
"unicode"
)
// bytes包实现了操作[]byte的常用函数。本包的函数和strings包的函数相当类似
func main() {
// buffer写入
write()
// buffer直接创建
bufferNew()
// byte操作demo
byteDemo()
}
func write() {
// 声明buffer
var b bytes.Buffer
// 增加buffer容量
b.Grow(64)
// 写入字符串
b.WriteString("Hello ")
// 写入单个byte
b.WriteByte('W')
// 写入单个rune
b.WriteRune('o')
// 写入byte
b.Write([]byte("rld!"))
fmt.Printf("%s\n", b.Bytes())
}
func bufferNew() {
str := "Hello World!"
// 根据字符串创建buffer
buf := bytes.NewBufferString(str)
// 根据byte创建buffer
buf = bytes.NewBuffer([]byte(str))
fmt.Printf("%s\n", buf.Bytes())
}
func byteDemo() {
var a, b, c []byte
// 根据[]byte创建reader
bytes.NewReader([]byte("Hello World!"))
// 比较a和b, 返回 0: a等于b, 1: a包含b, -1: a不包含b
bytes.Compare(a, b)
// 判断a与b是否相同
bytes.Equal(a, b)
// 判断a与b是否相同,忽略大小写
bytes.EqualFold(a, b)
// 判断a是否以b开头,当b为空时true
bytes.HasPrefix(a, b)
// 判断a是否以b结尾,当b为空时true
bytes.HasSuffix(a, b)
// 如果a以b结尾,则返回a去掉b结尾部分的新byte。如果不是,返回a
bytes.TrimSuffix(a, b)
// 如果a以b开头,则返回a去掉b开头部分的新byte。如果不是,返回a
bytes.TrimPrefix(a, b)
// 去除开头结尾所有的 空格换行回车缩进
bytes.TrimSpace(a)
// 去除开头结尾所有的 指定字符串中的任意字符
bytes.Trim(a, " ")
// 按自定义方法 去除开头结尾所有指定内容
bytes.TrimFunc(a, unicode.IsLetter)
// 去除开头所有的 指定字符串中的任意字符
bytes.TrimLeft(a, "0123456789")
// 按自定义方法 去除开头所有指定内容
bytes.TrimLeftFunc(a, unicode.IsLetter)
// 去除结尾所有的 指定字符串中的任意字符
bytes.TrimRight(a, "0123456789")
// 按自定义方法 去除结尾所有指定内容
bytes.TrimRightFunc(a, unicode.IsLetter)
// 以一个或者多个空格分割成切片
bytes.Fields([]byte(" foo bar baz "))
// 根据指定方法分割成切片
bytes.FieldsFunc([]byte(" foo1;bar2,baz3..."), func(c rune) bool {
return !unicode.IsLetter(c) && !unicode.IsNumber(c) // 以 不是字符或者数字 进行分割
})
// 判断a是否包含b
bytes.Contains(a, b)
// 判断byte是否包含字符串中任意字符,只要包含字符串中一个及以上字符返回true,否则false
bytes.ContainsAny([]byte("I like seafood."), "fÄo!")
// 判断byte是否包含rune字符
bytes.ContainsRune([]byte("I like seafood."), 'f')
// 统计a中包含所有b的个数,如果b为空则返回a的长度
bytes.Count(a, b)
// 检索a中首个b的位置,未检索到返回-1
bytes.Index(a, b)
// 检索a中首个 byte类型字符 的位置,未检索到返回-1
bytes.IndexByte(a, byte('k'))
// 自定义方法检索首个字符的位置,未检索到返回-1
bytes.IndexFunc([]byte("Hello, 世界"), func(c rune) bool {
return unicode.Is(unicode.Han, c) // 是否包含中文字符
})
// 检索a中首个 字符串中任意字符 的位置,未检索到返回-1
bytes.IndexAny(a, "abc")
// 检索a中首个 rune类型字符 的位置,未检索到返回-1
bytes.IndexRune([]byte("chicken"), 'k')
// 检索a中最后个b的位置,未检索到返回-1
bytes.LastIndex(a, b)
// 检索a中最后个 byte类型字符 的位置,未检索到返回-1
bytes.LastIndexByte(a, byte('k'))
// 自定义方法检索最后个字符的位置,未检索到返回-1
bytes.LastIndexFunc(a, unicode.IsLetter)
// 将byte数组以指定 byte字符 连接成一个新的byte
s := [][]byte{a, b}
bytes.Join(s, []byte(","))
// 返回一个重复n次a的新byte
// 例如:a = []byte("abc"),返回 []byte("abcabc")
bytes.Repeat(a, 2)
// 返回一个 将a中的b替换为c 的新byte,n为替换个数,-1替换所有
bytes.Replace(a, b, c, -1)
// 返回一个 将a中的b替换为c 的新byte
bytes.ReplaceAll(a, b, c)
// byte类型转rune类型
bytes.Runes(a)
// 将a以指定字符byte分割成byte数组
bytes.Split(a, []byte(","))
// 将a以指定字符byte分割成byte数组, n为分割个数,-1分割所有
bytes.SplitN(a, []byte(","), 2)
// 将a以指定字符byte分割成byte数组,保留b。
bytes.SplitAfter(a, []byte(","))
// 将a以指定字符byte分割成byte数组,保留b。n为分割个数,-1分割所有
bytes.SplitAfterN(a, []byte(","), 2)
// 返回一个 以空格为界限,所有首个字母大写 的标题格式
bytes.Title(a)
// 返回一个 所有字母大写 的标题格式
bytes.ToTitle(a)
// 使用指定的映射表将 a 中的所有字符修改为标题格式返回。
bytes.ToTitleSpecial(unicode.SpecialCase{}, a)
// 所有字母大写
bytes.ToUpper(a)
// 使用指定的映射表将 a 中的所有字符修改为大写格式返回。
bytes.ToUpperSpecial(unicode.SpecialCase{}, a)
// 所有字母小写
bytes.ToLower(a)
// 使用指定的映射表将 a 中的所有字符修改为大写格式返回。
bytes.ToLowerSpecial(unicode.SpecialCase{}, a)
// 遍历a按指定的rune方法处理每个字符
bytes.Map(func(r rune) rune {
if r >= 'A' && r <= 'Z' {
return r
} else {
return 'a'
}
}, a)
}
go库函数之-bytes-使用示例
猜你喜欢
转载自blog.csdn.net/liao__ran/article/details/114849897
今日推荐
周排行