go库函数之-bytes-使用示例

其他 2021-11-18 00:38:41 阅读次数: 0 
// 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)
}

猜你喜欢

转载自blog.csdn.net/liao__ran/article/details/114849897
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
基本数据类型封装类比较 Java源码解读(一) 8种基本类型对应的封装类型
JS实现无缝滚动上
深入解析HashMap原理（基于JDK1.8）
mysql的连接池
关于.htc
linux下的ubuntu12.04图形界面
【数论】好推不好记的扩展欧几里德
设备树详解
cscope + tags 简单设置
xml学习
每日归档
更多
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022