字节bytes的操作大全

于 2018-12-26 10:55:00 发布
阅读量2.2k 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011525168/article/details/88401168
版权

本节要讲的内容将是一个重点内容

  • 1.字节切片比较
  • 2.字节切片判断
  • 3.字节切片是否包含另外切片的值
  • 4.字节切片是否包含相同UTF-8的字符
  • 5.字符切片是否包含相同的 Unicode编码字符
  • 6.字符切片a中包含多少组不重复的Unicode编码切片b
  • 7.将切片按照空格分割成多个子切片
  • 8.将切片按照指定的规则分割成多个子切片
  • 9.字节切片是否包含前缀字符切片
  • 10.字节切片是否包含后缀切片
  • 11.获取第一个子切片所在的位置index
  • 12.获取切片b中任意一个Unicode编码字符第一次出现在切片a中的位置
  • 13.获取字符b 第一次出现在切片a中的位置
  • 14.返回第一个满足规则的unicode编码字符b,在切片a中的位置
  • 15.返回uncode编码第一次出现在切片a中的位置
  • 16.将多个切片通过字符连接成一个大的切片
  • 17.返回切片b最后一次出现在切片a的索引
  • 18.返回字符切片b中任意字符,最后一次出现在切片a中的位置
  • 19.返回字符b最后一次出现在切片a中的位置
  • 20.返回指定规则下,返回字符最后出现在切片a中的位置
  • 21.map方法处理数组数据
  • 22.将字符切片,重复n此组成新的切片
  • 23.用新的切片,替换切片a中的子切片的数据
  • 24.将utf-8的字符切片转换为rune切片
  • 25.将切片按照字符切片b分割成多个子切片数组,不包含切片b
  • 26.将切片按照字符切片b分割成多个子切片数组,包含切片b
  • 27.将切片按照字符切片b分割成n个子切片数组,如果数量达到n则不在继续分割
  • 28.切片字符中,按照空格划分成字符串,首字符设置大写
  • 29.切片全部转换为小写
  • 30.切片全部转换为小写
  • 31.从左边开始切割字符切片s中出现的字符切片b,返回剩余的数据
  • 32.从右边开始切割字符切片s中出现的字符切片b,返回剩余的数据
1.字节切片比较
package main

import (
  "bytes"
  "fmt"
)

func main() {
  var a,b []byte
  a = []byte{'b','a'}
  b = []byte{'c'}
  fmt.Println(bytes.Compare(a,b))

}
1594482-622e36cba72d0d8d
image.png

两个切片,从下标0的位置,以此进行比较,如果值相等,则进行后面的值比较,直到数据不相等,如果值a > 值b 则返回 1， a == b 返回 0,否则返回-1

2.字节切片判断
package main

import (
  "bytes"
  "fmt"
)

func main() {
  var a,b []byte
  a = []byte{'b','a'}
  b = []byte{'c'}
  fmt.Println(bytes.Equal(a,b))
}

判断规则和上面一致

1594482-f31e01f67e978975
image.png
3.字节切片是否包含另外切片的值

func Contains(b, subslice []byte) bool

package main

import (
  "bytes"
  "fmt"
)

func main() {
  var a,b []byte
  a = []byte{'b','a','c'}
  b = []byte{'c'}
  fmt.Println(bytes.Contains(a,b))
}
1594482-fa4822836e2f7042
image.png
4.字节切片是否包含相同UTF-8的字符

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

package main

import (
  "bytes"
  "fmt"
)

func main() {
  var a []byte
  a = []byte{'b','a','c'}

  fmt.Println(bytes.ContainsAny(a,"abcde"))
}

检测规则如下

ContainsAny 检测chars的任何 UTF-8 编码的 Unicode 代码点是否在 b 中。

5.字符切片是否包含相同的 Unicode编码字符
package main

import (
  "bytes"
  "fmt"
)

func main() {
  var a []byte
  a = []byte("我爱你")
  var c rune = '我'
  fmt.Println(bytes.ContainsRune(a,c))
}
1594482-bb82783be4914525
image.png
6.字符切片a中包含多少组不重复的Unicode编码切片b
package main

import (
  "bytes"
  "fmt"
)

func main() {
  var a,b []byte
  a = []byte("我我我爱你")
  b = []byte("我")
  fmt.Println(bytes.Count(a,b))
}
1594482-253cb337792439b4
image.png

如何 b为空 怎么返回 len(a) + 1 ,即 6

如下

package main

import (
  "bytes"
  "fmt"
)

func main() {
  var a,b []byte
  a = []byte("我我我爱你")
  b = []byte("")
  fmt.Println(bytes.Count(a,b))
}
1594482-32dc47b051388a17
image.png
7.不区分大小写 比较两个切片的大小
package main

import (
  "bytes"
  "fmt"
)

func main() {
  var a,b []byte
  a = []byte("a")
  b = []byte("A")
  fmt.Println(bytes.EqualFold(a,b))
}
1594482-bec91c91d87ed06f
image.png
7.将切片按照空格分割成多个子切片
package main

import (
  "bytes"
  "fmt"
)

func main() {
  var a = []byte("ab  c d")
  var list [][]byte
  list = bytes.Fields(a)
  fmt.Println(list)
}
1594482-1da2ab0bf0aea08f
image.png
8.将切片按照指定的规则分割成多个子切片
package main

import (
  "bytes"
  "fmt"
)

func main() {
  var a = []byte("a=b&c=d&f==e")
  var list [][]byte
  var f = func (s rune) bool{
    if(s=='&'){
      return true
    }
    return false
  }
  list = bytes.FieldsFunc(a,f)
  fmt.Printf("count:%d,%q",len(list),list)
}
1594482-20d78777450e0b7f
image.png

9.字节切片是否包含前缀字符切片

package main

import (
  "bytes"
  "fmt"
)

func main() {
  var a = []byte("xj-abcdef")
  var b = []byte("xj")
  fmt.Println(bytes.HasPrefix(a,b))
}
1594482-528c68fa8ce3be2e
image.png
字符切片是否包含后缀切片
package main

import (
  "bytes"
  "fmt"
)

func main() {
  var a = []byte("xj-abcdef")
  var b = []byte("ef")
  fmt.Println(bytes.HasSuffix(a,b))
}
1594482-2500f8e069aeb1a4
image.png
11.获取第一个子切片所在的位置index
package main

import (
  "bytes"
  "fmt"
)

func main() {
  var a = []byte("xj-abcdef")
  var b = []byte("ef")
  fmt.Println(bytes.Index(a,b))
}
1594482-202a0af34d98a670
image.png
12.获取切片b中任意一个Unicode编码字符第一次出现在切片a中的位置
package main

import (
  "bytes"
  "fmt"
)

func main() {
  var a = []byte("xj-我abcdef")
  var b = "efghe"
  fmt.Println(bytes.IndexAny(a,b))
}
1594482-00c2b0b66230d0e8
image.png
13.获取字符b 第一次出现在切片a中的位置
package main

import (
  "bytes"
  "fmt"
)

func main() {
  var a = []byte("xj-我abcdef")
  var b = byte('e')
  fmt.Println(bytes.IndexByte(a,b))
}
1594482-ccd0d0c9f1b64c8c
image.png
返回第一个满足规则的unicode编码字符b,在切片a中的位置

package main

import (
"bytes"
"fmt"
)

func main() {
var a = []byte("xj-我爱abcdef")
var f = func(r rune)bool{
return r > rune('我')
}
fmt.Println(bytes.IndexFunc(a,f))
}

1594482-ca56f61c1de938ea
image.png
15.返回uncode编码第一次出现在切片a中的位置
package main

import (
  "bytes"
  "fmt"
)

func main() {
  var a = []byte("xj-我爱abcdef")
  var f = rune('我')
  fmt.Println(bytes.IndexRune(a,f))
}
1594482-50320d711af19b1c
image.png
16.将多个切片通过字符连接成一个大的切片
package main

import (
  "bytes"
  "fmt"
)

func main() {
  var a = []byte("xj")
  var b = []byte("-abc")
  var s = bytes.Join([][]byte{a,b},[]byte("&"))
  fmt.Printf("%q",s)
}
1594482-a3554838840dce63
image.png
17.返回切片b最后一次出现在切片a的索引
package main

import (
  "bytes"
  "fmt"
)

func main() {
  var a = []byte("xj")
  var b = []byte("-abc")
  var lastIndex = bytes.LastIndex(a,b)
  fmt.Println(lastIndex)
}

未找到则返回-1


1594482-28ab9ad73a84e468
image.png
18.返回字符切片b中任意字符,最后一次出现在切片a中的位置
package main
import (
  "bytes"
  "fmt"
)
func main() {
  var a = []byte("xjaaaa")
  var b = "bcdefa"
  var lastIndex = bytes.LastIndexAny(a,b)
  fmt.Println(lastIndex)
}
1594482-a00858dc6c035603
image.png
19.返回字符b最后一次出现在切片a中的位置
package main

import (
  "bytes"
  "fmt"
)

func main() {
  var a = []byte("xjaaaa")
  var b = byte('a')
  var lastIndex = bytes.LastIndexByte(a,b)
  fmt.Println(lastIndex)
}

1594482-48aa437002d8a5a5
image.png
20.返回指定规则下,返回字符最后出现在切片a中的位置
package main

import (
  "bytes"
  "fmt"
)
func main() {
  var a = []byte("123456f")
  var f = func (r rune)bool{
    return r == rune('f')
  }
  var lastIndex = bytes.LastIndexFunc(a,f)
  fmt.Println(lastIndex)
}
1594482-ebdb091dc581a74a
image.png
21.map方法处理数组数据

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

package main

import (
  "bytes"
  "fmt"
  "strconv"
)

func main() {
  var a = []byte("123456")
  var f = func (r rune)rune{
    s := string(r)
    num,err := strconv.Atoi(s)
    if(err != nil){
      fmt.Println(err)
      return rune(-1)
    }
    if(num > 5){
      return rune(-1)
    }
   return r
  }
  result := bytes.Map(f,a)
  
  fmt.Println(string(result))
}
1594482-490e0c097dfbeab9
image.png

Map 根据映射函数返回字节切片s的所有字符修改后的副本。如果映射返回负值，则字符将从字符串中删除而不会被替换。 s 和输出中的字符被解释为 UTF-8 编码的 Unicode 代码点

22.将字符切片,重复n此组成新的切片
package main

import (
  "bytes"
  "fmt"
)

func main() {
  fmt.Printf("%s\n", bytes.Repeat([]byte("abc"),3))
}

1594482-04e471aa5a57ed79
image.png
23.用新的切片,替换切片a中的子切片的数据,替换n次
package main

import (
  "bytes"
  "fmt"
)

func main() {
  fmt.Printf("%s\n", bytes.Replace([]byte("121416"),[]byte("1"),[]byte("a"),2))
}
1594482-b8bc45da652e0189
image.png
24.将utf-8的字符切片转换为rune切片
package main

import (
  "bytes"
  "fmt"
)

func main() {
  s := []byte("121416我")
  r := bytes.Runes(s)
  fmt.Printf("%d,%d\n",len(s),len(r))
}
1594482-658711e456778af9
image.png
25.将切片按照字符切片b分割成多个子切片数组,不包含切片b
package main

import (
  "bytes"
  "fmt"
)

func main() {
  fmt.Printf("%s",bytes.Split([]byte("abcdef"),[]byte("d")))
}

1594482-5ba085183f0b942d
image.png
26.将切片按照字符切片b分割成多个子切片数组,包含切片b
  • 27.将切片按照字符切片b分割成n个子切片数组,如果数量达到n则不在继续分割
  • 28.切片字符中,按照空格划分成字符串,首字符设置大写
  • 29.切片全部转换为小写
  • 30.切片全部转换为小写
  • 31.从左边开始切割字符切片s中出现的字符切片b,返回剩余的数据
  • 32.从右边开始切割字符切片s中出现的字符切片b,返回剩余的数据
深渊云海
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值