bytes

最新推荐文章于 2022-03-22 19:08:04 发布
最新推荐文章于 2022-03-22 19:08:04 发布
阅读量179 收藏
点赞数
分类专栏： 学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lanseali/article/details/117034899
版权 
const timetemplate = "2006-01-02 15:04:05"

func main() {

	// func Compare(a, b []byte) int
	// 比较a，b两个切片是否相等， a=b 返回0，a<b 返回-1，a>b 返回1
	fmt.Println("bytes.Compare([]byte{}, []byte{}):", bytes.Compare([]byte{}, []byte{}))     // 0
	fmt.Println("bytes.Compare([]byte{1}, []byte{2}):", bytes.Compare([]byte{1}, []byte{2})) // -1
	fmt.Println("bytes.Compare([]byte{2}, []byte{1}):", bytes.Compare([]byte{2}, []byte{1})) // 1
	fmt.Println("bytes.Compare([]byte{}, nil):", bytes.Compare([]byte{}, nil))               // 0

	// func Equal(a, b []byte) bool
	// 判断两个切片是否完全相同
	fmt.Println("bytes.Equal([]byte{}, []byte{}):", bytes.Equal([]byte{}, []byte{}))            // true
	fmt.Println("bytes.Equal([]byte{'A'}, []byte{'a'})", bytes.Equal([]byte{'A'}, []byte{'a'})) // false
	fmt.Println("bytes.Equal([]byte{}, nil):", bytes.Equal([]byte{}, nil))                      // true

	// func HasPrefix(s, prefix []byte) bool
	// 判断s是否有前缀切片prefix
	fmt.Println("bytes.HasPrefix([]byte{1, 2, 3}, []byte{1}):", bytes.HasPrefix([]byte{1, 2, 3}, []byte{1})) // true
	fmt.Println("bytes.HasPrefix([]byte{1, 2, 3}, []byte{2}):", bytes.HasPrefix([]byte{1, 2, 3}, []byte{2})) // false
	// func HasSuffix(s, suffix []byte) bool
	// 判断s是否有后缀切片suffix,与HasPrefix类似

	// func Contains(b, subslice []byte) bool
	// 判断切片b是否包含子切片subslice
	fmt.Println("bytes.Contains([]byte{1, 2, 3}, []byte{1}):", bytes.Contains([]byte{1, 2, 3}, []byte{1}))       // true
	fmt.Println("bytes.Contains([]byte{1, 2, 3}, []byte{1, 3}):", bytes.Contains([]byte{1, 2, 3}, []byte{1, 3})) // false

	// func Index(s, sep []byte) int
	// 子切片sep在s中第一次出现的位置，不存在则返回-1
	fmt.Println("bytes.Index([]byte{1, 2, 3, 4, 5}, []byte{2, 3}):", bytes.Index([]byte{1, 2, 3, 4, 5}, []byte{2, 3})) // 1
	fmt.Println("bytes.Index([]byte{1, 2, 3, 4, 5}, []byte{0, 1}):", bytes.Index([]byte{1, 2, 3, 4, 5}, []byte{0, 1})) // -1

	// func IndexByte(s []byte, c byte) int
	// 字符c在s中第一次出现的位置，不存在则返回-1
	fmt.Println("bytes.IndexByte([]byte{1, 2, 3}, 2):", bytes.IndexByte([]byte{1, 2, 3}, 2)) // 1
	fmt.Println("bytes.IndexByte([]byte{1, 2, 3}, 0):", bytes.IndexByte([]byte{1, 2, 3}, 0)) // -1

	// func IndexFunc(s []byte, f func(r rune) bool) int
	// s中第一个满足函数f的元素的索引，不存在则返回-1
	fmt.Println("bytes.IndexFunc([]byte(\"hi go\"), func(r rune) bool {\n\t\treturn r == 'g'\n\t}):",bytes.IndexFunc([]byte("hi go"), func(r rune) bool {
		return r == 'g'
	})) // 3 ; hi go中g的索引为3
	// func LastIndexFunc(s []byte, f func(r rune) bool) int
	// 这个方法与IndexFunc相反，获取最后一个满足函数f的元素的索引，不再演示

	// func LastIndex(s, sep []byte) int
	// 切片sep在s中最后一次出现的位置，不存在则返回-1
	fmt.Println("bytes.LastIndex([]byte(\"hi go\"), []byte(\"go\")):",bytes.LastIndex([]byte("hi go"), []byte("go"))) // 3
	fmt.Println("bytes.LastIndex([]byte{1, 2, 3}, []byte{2, 3}):",bytes.LastIndex([]byte{1, 2, 3}, []byte{2, 3})) // 1

	// func ToLower(s []byte) []byte
	// 返回将s切片所有字符都转为小写的新切片(下面将切片转为字符串方便看到结果)
	fmt.Println("string(bytes.ToLower([]byte(\"ABC\"))):",string(bytes.ToLower([]byte("ABC")))) // abc
	fmt.Println("string(bytes.ToLower([]byte(\"abc\"))):",string(bytes.ToLower([]byte("abc")))) // abc
	// func ToUpper(s []byte) []byte
	// 这个方法将s切片字符全部转为大写，与ToLower相反，不再演示

	// func Repeat(b []byte, count int) []byte
	// 返回count个b切片串联起来的新切片
	fmt.Println("bytes.Repeat([]byte{1, 2}, 3):",bytes.Repeat([]byte{1, 2}, 3)) // [1 2 1 2 1 2]

	// func Replace(s, old, new []byte, x int) []byte
	// 将s中n个old切片替换new切片，并返回这个新切片,当n为-1时，表示替换所有
	fmt.Println("bytes.Replace([]byte{1, 1, 3, 1, 1, 3, 1, 1, 4}, []byte{1, 1}, []byte{0, 0}, -1):",bytes.Replace([]byte{1, 1, 3, 1, 1, 3, 1, 1, 4}, []byte{1, 1}, []byte{0, 0}, -1)) // [0 0 3 0 0 3 0 0 4]

	// func ReplaceAll(s, old, new []byte) []byte
	// ReplaceAll这个函数表示替换所有，与Replace中n为-1时效果是一样的

	// func Map(mapping func(r rune) rune, s []byte) []byte
	// 将s切片的每一个字符元素都进行mapping函数运算，并将得到的结果拼接成新切片返回
	fmt.Println("string(bytes.Map(func(r rune) rune {\n\t\treturn r + 1 // 将每一个字符都+1\n\t}, []byte(\"abc\"))):",string(bytes.Map(func(r rune) rune {
		return r + 1 // 将每一个字符都+1
	}, []byte("abc")))) // bcd

	// func Trim(s []byte, cutset string) []byte
	// 返回将s前后端所有cutset值都去掉的子切片
	fmt.Println("string(bytes.Trim([]byte(\"hi go hi js\"), \"hi\")):",string(bytes.Trim([]byte("hi go hi js"), "hi"))) // go hi js ; 只去除收尾hi，不会去除中间hi

	// func TrimSpace(s []byte) []byte
	// 将前后端所有的空白都去除，并返回新的切片
	fmt.Println("bytes.TrimSpace([]byte(\" hi go \")):",bytes.TrimSpace([]byte(" hi go "))) // [104 105 32 103 111]; 只有五个字符，可以看到，去除了首尾的空字符

	// func TrimLeft(s []byte, cutset string) []byte
	// 返回将s左边等于cutset的值去掉的新切片
	fmt.Println("string(bytes.TrimLeft([]byte(\"hihi go\"), \"hi\")):",string(bytes.TrimLeft([]byte("hihi go"), "hi"))) // go

	// func TrimRight(s []byte, cutset string) []byte
	// 返回将s右边等于cutset的值去掉的新切片，与TrimLeft类似不再演示

	// func TrimPrefix(s, prefix []byte) []byte
	// 返回将s去除prefix前缀的新切片
	fmt.Println("string(bytes.TrimPrefix([]byte(\"hi go\"), []byte(\"hi\"))):",string(bytes.TrimPrefix([]byte("hi go"), []byte("hi")))) // go

	// 返回将s去除suffix后缀的新切片,不再演示
	// func TrimSuffix(s, suffix []byte) []byte
	fmt.Println("string(bytes.TrimSuffix([]byte(\"hi go\"), []byte(\"go\"))):",string(bytes.TrimSuffix([]byte("hi go"), []byte("go")))) // hi

	// func Fields(s []byte) [][]byte
	// 返回将s，按照空字符切割成多个子切片
	s := bytes.Fields([]byte("hi go， hi js， hi c"))
	for _, v := range s {
		fmt.Println(string(v)) // 依次打印 hi|go,|hi|js,|hi|c
	}

	// func FieldsFunc(s []byte, f func(rune) bool) [][]byte
	// 与Fields类似，但是FieldsFunc是以满足函数f条件的字符为分隔符
	s = bytes.FieldsFunc([]byte(" hi go, hi.js-hi c"), func(r rune) bool {
		return r == ',' || r == '-' || r == '.' // 只要是,-. 都可以作为分隔符
	})
	for _, v := range s {
		fmt.Println(string(v)) // 依次打印 hi go| hi|js,|hi c
	}

	// func Split(s, sep []byte) [][]byte
	// 以sep作为分隔符进行分割
	s = bytes.Split([]byte(" hihi go hi js hihi c"), []byte("hi"))
	for _, v := range s {
		fmt.Println(string(v)) // 依次打印 | | go| js|  | c 注意中间的空格
	}
	// func SplitN(s, sep []byte, x int) [][]byte
	// 以sep作为分隔符进行分割,n为分割的个数；
	// x > 0 : 返回的切片最多n个子字符串；最后一个子字符串包含未进行切割的部分。
	//bytes.SplitN([]byte(" hihi go hi js hihi c"), []byte("hi"))
	// x == 0: 返回nil
	// x < 0 : 返回所有的子字符串组成的切片

	// func Join(s [][]byte, sep []byte) []byte
	// 将所有的[][]byte连接成一个新切片，以sep作为连接符号
	fmt.Println("bytes.Join([][]byte{{1, 1}, {2, 2}, {3, 3}}, []byte{0}):",bytes.Join([][]byte{{1, 1}, {2, 2}, {3, 3}}, []byte{0})) // [1 1 0 2 2 0 3 3]

	//初始化buffer
	// 第一种方式
	//buffer1 := new(bytes.Buffer) // 使用new函数
	// 第二种方式
	//buffer2 := bytes.NewBuffer([]byte{}) // 使用bytes包的NewBuffer函数
	// 第三种方式
	//buffer3 := bytes.NewBufferString("") // 使用bytes包的NewBufferString函数

	b := bytes.NewBufferString("abcdefgh") // 创建并初始化一个Buffer
	// 打印一下内容： abcdefgh; [新方法]：func (b *Buffer) String() string => 将Buffer内容转为string
	fmt.Println(b.String()) // abcdefgh
	// func (b *Buffer) Len() int => 获取Buffer的长度
	fmt.Println(b.Len()) // 8

	// 从Buffer读取2个字节数据; [新方法]：func (b *Buffer) Next(x int) []byte => 读取n个字节数据，返回一个byte切片]
	fmt.Println(string(b.Next(2))) // 读到的数据: ab

	tmp := make([]byte, 2) // 新建一个大小为2的切片
	// 从Buffer读取tmp大小的数据; [新方法]：func (b *Buffer) Read(p []byte) (x int, err error) => 从Buffer读取b大小的数据，返回读取的个数和可能发生的错误
	n, _ := b.Read(tmp)
	fmt.Println(string(tmp[:n])) // 读到的数据: cd

	// 读取Buffer中的下一个字节; [新方法]：func (b *Buffer) ReadByte() (c byte, err error) => 读取并返回Buffer中的下一个字节,如果没有数据可用，返回值err为io.EOF
	nextByte, _ := b.ReadByte()
	fmt.Println(string(nextByte)) // 读到的数据: e

	// 读取到指定的分隔符位置； [新方法]：func (b *Buffer) ReadString(delim byte) (line string, err error)
	line, _ := b.ReadString('g')
	fmt.Println(line)       // 读到的数据: fg
	fmt.Println(b.String()) // 还剩余: h

	b = bytes.NewBufferString("abcdefgh") // 重新赋值
	// 读取到指定的分隔符位置； [新方法]：func (b *Buffer) ReadBytes(delim byte) (line []byte, err error) => 与ReadString不同之处，前者返回string后者返回切片
	line2, _ := b.ReadBytes('b')
	fmt.Println(string(line2)) // 读到的数据: ab
	fmt.Println(b.String())    // 还剩余: cdefgh

	// func (b *Buffer) ReadRune() (r rune, size int, err error) => ReadRune读取并返回缓冲中的下一个utf-8码值。如果没有数据可用，返回值err为io.EOF。如果缓冲中的数据是错误的utf-8编码，本方法会吃掉一字节并返回(U+FFFD, 1, nil)。
	// 大多数情况下，ReadRune与ReadByte相同，ReadRune用来判断是否含有错误utf8编码数据
	r, e, _ := b.ReadRune()
	fmt.Println(r, e) // 99 1; c的ASCII编码为99

	// func (b *Buffer) Bytes() []byte => 返回未读取的字节切片
	fmt.Println(string(b.Bytes())) // defgh

	fmt.Println(fmt.Sprintf("日期：%s", time.Now().Format(timetemplate)))

	//buffer写入操作
	b = new(bytes.Buffer) // 创建一个空的Buffer

	// func (b *Buffer) WriteByte(c byte) error => 写入一个字节
	b.WriteByte('a')
	fmt.Println(b.String()) // a

	// func (b *Buffer) Write(p []byte) (n int, err error) => 写入一个字节切片
	b.Write([]byte{98, 99}) // b,c 的ASCII编码为98,99
	fmt.Println(b.String()) // abc

	// func (b *Buffer) WriteString(s string) (n int, err error) => 写入一个字符串
	b.WriteString(" hello")
	fmt.Println(b.String()) // abc hello

	// func (b *Buffer) Reset() => 重设缓冲，因此会丢弃全部内容，等价于b.Truncate(0)。
	b.Reset()
	fmt.Println(b.Len(), b.String()) // 0
}

搬运文章链接

暖雪冷泉
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Golang bytes Index函数解析
流年似水
03-15 2356
func Index(s, sep []byte) int { n := len(sep) switch { case n == 0: return 0 case n == 1: return IndexByte(s, sep[0]) case n == len(s): if Equal(sep, s) { return 0 } return -1 case ...
byte类型的切片（[]byte）与string
最新发布
赵凯月的博客
09-10 208
Go 语言中，表示字符串的数据类型是 string。我们知道字符串是由字节组成，而字节序列在 Go 语言中是用 byte 类型的切片（[]byte）表达，因此 string 类型和 []byte 是可以互相转化的。byte 类型是 unit8 类型的别名，因此输出的 bslice 变量的类型是 “[]unit8”，而后面值对应 ASCII 编码。我们再把 byte 类型的切片 转成 字符串试试？
byte[] 相关的一些处理方法
ADS李的博客
05-22 406
原始下位机回传的原始数据 byte最后转一下 或者直接参照twoCharCompareZero 进行判断 byte 转 8位 byte[] public static byte[] getBooleanArray(byte b) { byte[] array = new byte[8]; for (int i = 7; i >= 0; i--) { array[i] = (byte)(b & 1); b = (byte) (b &gt...
Golang中[]byte与string转换全解析
热门推荐
slphahaha的博客
10-31 2万+
string类型和[]byte类型是我们编程时最常使用到的数据结构。本文将探讨两者之间的转换方式，通过分析它们之间的内在联系来拨开迷雾。 两种转换方式 标准转换 go中string与[]byte的互换，相信每一位gopher都能立刻想到以下的转换方式，我们将之称为标准转换。 // string to []byte s1 := "hello" b := []byte(s1) // []byte to string s2 := string(b) 强转换 通过unsafe和ref
将图片转换为 bytes格式
08-30
在本文中，我们将深入探讨如何将图片转换为bytes（字节）格式，以及这个过程在Go语言、易语言和工具开发中的应用。 首先，我们要理解图片的二进制表示。每种图片格式，如JPEG、PNG、BMP等，都有其特定的文件头标识...
256 Bytes
10-28
标题“256 Bytes”可能指的是一个与计算机内存或数据存储相关的主题，特别是与256个字节的容量有关。在IT领域，字节是数据的基本单位，8位二进制数字组成一个字节。因此，256字节等于2的8次方，即256B。这通常不会是...
Python：关于bytes()函数的学习
12-21
在Python 3中，bytes()是一个重要的内置函数，今天就来和大家分享一下有关bytes()函数的操作。 为了便于各位读者复制学习，笔者使用代码呈现学习过程，详情如下： help(bytes) #关于bytes()函数的学习 # 语法：...
Python每天必学之bytes字节
09-21
### Python每日精进：深入掌握Bytes字节 在Python编程中，`bytes`类型是非常重要的数据结构之一，尤其是在处理文件读写、网络通信等场景下。这篇文章将详细讲解Python中的`bytes`字节，帮助读者更好地理解和运用这...
php Allowed memory size of 134217728 bytes exhausted
06-17
PHP 中最常见的错误之一是 "Allowed memory size of 134217728 bytes exhausted"，這個錯誤是指 PHP腳本在執行過程中，超出了允許的内存限制，導致腳本無法繼續執行。在這篇文章中，我們將詳細解釋這個錯誤的原因、...
byte[]字节操作:byte[] 截取长度&byte[]数组转16进制&byte[]转数据类型工具类
panlupeng的博客
12-08 8773
一.字节定义 字节（Byte）是计算机信息技术用于计量存储容量的一种计量单位，也表示一些计算机编程语言中的数据类型和语言字符。Byte是从0-255的无符号类型，所以不能表示负数。 Byte即字节的意思，通常在读取非文本文件时（如图片，声音，可执行文件）需要用字节数组来保存文件的内容。在下载文件时，也是用byte数组作临时的缓冲器接收文件内容。所以说byte在文件操作时是必不可少的。不管是对文件写入还是读取都要用到。 先来了解一下数组的定义: byte [] aa = {0,1,2,3,4,5}; //字
go语言bytes包中的方法使用
nuoxiaoli的博客
10-21 1083
go语言bytes包中的方法使用 func main() { //Compare函数：对比参数一和参数二，如果a==b返回0， // 如果a<b返回-1；否则返回+1，nil参数视为空切片 fmt.Println("1、Compare的使用例子：") fmt.Println(bytes.Compare([]byte{1, 3, 4, 5, 5}, []byte{1, 2, 3, 1, 4})) //Equal函数：判断两个切片的内容是否相等 fmt.Println("2、Equal的使用例
golang语言中bytes包的常用函数，Reader和Buffer的使用
weixin_34192816的博客
07-22 945
bytes中常用函数的使用： package main; import ( "bytes" "fmt" "unicode" ) //bytes包中实现了大量对[]byte操作的函数和两个最主要的Reader和Buffer两个结构 func main() { str := "aBcD"; //转为小写 fmt.Println(string(bytes...
bytes 类型
apple_50618492的博客
03-11 6891
1.bytes 类型 Python3 新增了 bytes 类型，用于代表字节串，是一个类型。字符串（str）由多个字符组成，以字符为单位进行操作；字节串（bytes）由多个字节组成，以字节为单位进行操作 由于 bytes 保存的就是原始的字节（二进制格式）数据，因此 bytes 对象可用于在网络上传输数据，也可用于存储各种二进制格式的文件，比如图片、音乐等文件。。 2.字节串与字符串之间的区别 bytes 和 str 除操作的数据单元不同之外，它们支持的所有方法都基本相同，bytes 也是不可变序列。 by
Golang-bytes包分析
u012807459的专栏
06-18 3302
根据 字符在在码表中的顺序从第一个字节进行比较如果第一个字节相同比较下一个直到出现两个在码表中顺序不同的两个字符 如果这是a>b则返回1 b>a返回-1 如果每个字符比较到最后都是相等的name 返回1 func Compare(a, b []byte) int   返回sep在s中重复出现的次数 func Count(s, sep []byte) int 返回b 是否包
你真的懂string与[]byte的转换了吗
程序员麦冬的博客（公众号同名）
09-29 1193
string类型和[]byte类型是我们编程时最常使用到的数据结构。本文将探讨两者之间的转换方式，通过分析它们之间的内在联系来拨开迷雾。 两种转换方式 标准转换 go中string与[]byte的互换，相信每一位gopher都能立刻想到以下的转换方式，我们将之称为标准转换。 // string to []byte s1 := "hello" b := []byte(s1) // []byte to string s2 := string(b) 强转换 通过unsafe和reflect包，可以实现
bytes类型
wanchaopeng的博客
11-09 7121
定义 bytes类型是指一堆字节的集合，在python中以b开头的字符串都是bytes类型 b'\xe5\xb0\x8f\xe7\x8c\xbf\xe5\x9c\x88' #b开头的都代表是bytes类型，是以16进制来显示的，2个16进制代表一个字节。 utf-8是3个字节代表一个中文，所以以上正好是9个字节 Bytes类型的作用 计算机只能存储2进制， 我们的字符、图片、视频、音乐等想存到硬盘上，也必须以正确的方式编码成2进制后再存。 对于文字，我们可以以gbk编码，也可以以utf-8、A
Python-数据类型：bytes
u011079613的博客
03-22 1万+
Python-数据类型：bytes0 前言1 bytes类型的特性1.1 ASCII表2 bytes类型创建与转化2.1 bytes类型与数字2.2 bytes类型与ASCII字符2.2.1 创建bytes数据2.2.2 还原bytes数据2.3 bytes类型与汉字3 bytes类型切片迭代 0 前言 >>返回Python系列文章目录<< 1 bytes类型的特性 Python 3.x之后，Python自带字符默认使用utf-8格式编码和显示 Python默认字符串string数
Bytes数组处理工具
青鱼入云的博客
04-12 956
记一个byte数组与int互转、与string互转、字节替换的例子，与int互转的代码解析回头再补上 /** * Bytes数组处理工具 * @author */ public class ByteUtils { /** * byte转int * @param b * @param start * @param len * @...
Bytes
06-01
Java中的Bytes是字节数组的意思，它是一个基本数据类型byte的数组。在Java中使用字节数组可以存储二进制数据和文本数据。 如果您需要将字节数组转换为字符串，可以使用Java的String类中的构造函数来实现，具体的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值