go整型和字节数组之间的转换

最新推荐文章于 2024-06-08 21:23:25 发布
最新推荐文章于 2024-06-08 21:23:25 发布
阅读量4.4k 收藏 2
点赞数 2
分类专栏： Golang学习笔记 文章标签： go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuemengrui12/article/details/106056220
版权

主机字节序

主机字节序模式有两种，大端数据模式和小端数据模式，在网络编程中应注意这两者的区别，以保证数据处理的正确性；例如网络的数据是以大端数据模式进行交互，而我们的主机大多数以小端模式处理，如果不转换，数据会混乱 参考 ；一般来说，两个主机在网络通信需要经过如下转换过程：主机字节序 —> 网络字节序 -> 主机字节序

大端小端区别

大端模式：Big-Endian就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端

低地址 --------------------> 高地址

高位字节                     地位字节

小端模式：Little-Endian就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端

低地址 --------------------> 高地址

低位字节                     高位字节

高位字节和低位字节概念

例如在32位系统中，257转换成二级制为：00000000 00000000 00000001 00000001，其中

00000001 | 00000001

高位字节     低位字节

int和byte转换

在go语言中，byte其实是uint8的别名，byte 和 uint8 之间可以直接进行互转。目前只能将0~255范围的int转成byte。因为超出这个范围，go在转换的时候，就会把多出来数据扔掉;如果需要将int32转成byte类型，我们需要一个长度为4的[]byte数组就

大端模式下

func f2() {
    var v2 uint32
    var b2 [4]byte
    v2 = 257
    // 将 257转成二进制就是
    // | 00000000 | 00000000 | 00000001 | 00000001 |
    // 	| b2[0]    | b2[1]    | b2[2]    | b2[3]    | // 这里表示b2数组每个下标里面存放的值
    // 这里直接使用将uint32强转成uint8
    // | 00000000 0000000 00000001 | 00000001  直接转成uint8后等于 1
    // |---这部分go在强转的时候扔掉---|
    b2[3] = uint8(v2)
    // | 00000000 | 00000000 | 00000001 | 00000001 | 右移8位 转成uint8后等于 1
    // 下面是右移后的数据
    // |          | 00000000 | 00000000 | 00000001 |
    b2[2] = uint8(v2 >> 8)
    // | 00000000 | 00000000 | 00000001 | 00000001 | 右移16位 转成uint8后等于 0
    // 下面是右移后的数据
    // |          |          | 00000000 | 00000000 |
    b2[1] = uint8(v2 >> 16)
    // | 00000000 | 00000000 | 00000001 | 00000001 | 右移24位 转成uint8后等于 0
    // 下面是右移后的数据
    // |          |          |          | 00000000 |
    b2[0] = uint8(v2 >> 24)
    fmt.Printf("%+v\n", b2)
    // 所以最终将uint32转成[]byte数组输出为
    // [0 0 1 1]
}

小端模式下

小端刚好和大端相反，所以在转成小端模式的时候，只要将[]byte数组的下标首尾对换一下位置就可以了

func f3() {
  var v3 uint32
  var b3 [4]byte
  v3 = 257
  // 将 257转成二进制就是
  // | 00000000 | 00000000 | 00000001 | 00000001 |
  // | b3[0]  | b3[1]  | b3[2]  | b3[3]   | // 这里表示b3数组每个下标里面存放的值
  // 这里直接使用将uint32l强转成uint8
  // | 00000000 0000000 00000001 | 00000001 直接转成uint8后等于 1
  // |---这部分go在强转的时候扔掉---|
  b3[0] = uint8(v3)
  // | 00000000 | 00000000 | 00000001 | 00000001 | 右移8位 转成uint8后等于 1
  // 下面是右移后的数据
  // |     | 00000000 | 00000000 | 00000001 |
  b3[1] = uint8(v3 >> 8)
  // | 00000000 | 00000000 | 00000001 | 00000001 | 右移16位 转成uint8后等于 0
  // 下面是右移后的数据
  // |     |     | 00000000 | 00000000 |
  b3[2] = uint8(v3 >> 16)
  // | 00000000 | 00000000 | 00000001 | 00000001 | 右移24位 转成uint8后等于 0
  // 下面是右移后的数据
  // |     |     |     | 00000000 |
  b3[3] = uint8(v3 >> 24)
  fmt.Printf("%+v\n", b3)
  // 所以最终将uint32转成[]byte数组输出为
  // [1 1 0 0 ]
}

有了上面的的铺垫，go整型和字节数组之间的转换我们也就知道具体操作了，下面上代码

// int 转大端 []byte
func IntToBytesBigEndian(n int64, bytesLength byte) ([]byte, error) {
   switch bytesLength {
   case 1:
      tmp := int8(n)
      bytesBuffer := bytes.NewBuffer([]byte{})
      binary.Write(bytesBuffer, binary.BigEndian, &tmp)
      return bytesBuffer.Bytes(), nil
   case 2:
      tmp := int16(n)
      bytesBuffer := bytes.NewBuffer([]byte{})
      binary.Write(bytesBuffer, binary.BigEndian, &tmp)
      return bytesBuffer.Bytes(), nil
   case 3:
      tmp := int32(n)
      bytesBuffer := bytes.NewBuffer([]byte{})
      binary.Write(bytesBuffer, binary.BigEndian, &tmp)
      return bytesBuffer.Bytes()[1:], nil
   case 4:
      tmp := int32(n)
      bytesBuffer := bytes.NewBuffer([]byte{})
      binary.Write(bytesBuffer, binary.BigEndian, &tmp)
      return bytesBuffer.Bytes(), nil
   case 5:
      tmp := n
      bytesBuffer := bytes.NewBuffer([]byte{})
      binary.Write(bytesBuffer, binary.BigEndian, &tmp)
      return bytesBuffer.Bytes()[3:], nil
   case 6:
      tmp := n
      bytesBuffer := bytes.NewBuffer([]byte{})
      binary.Write(bytesBuffer, binary.BigEndian, &tmp)
      return bytesBuffer.Bytes()[2:], nil
   case 7:
      tmp := n
      bytesBuffer := bytes.NewBuffer([]byte{})
      binary.Write(bytesBuffer, binary.BigEndian, &tmp)
      return bytesBuffer.Bytes()[1:], nil
   case 8:
      tmp := n
      bytesBuffer := bytes.NewBuffer([]byte{})
      binary.Write(bytesBuffer, binary.BigEndian, &tmp)
      return bytesBuffer.Bytes(), nil
   }
   return nil, fmt.Errorf("IntToBytesBigEndian b param is invaild")
}

//int 转小端 []byte
func IntToBytesLittleEndian(n int64, bytesLength byte) ([]byte, error) {
   switch bytesLength {
   case 1:
      tmp := int8(n)
      bytesBuffer := bytes.NewBuffer([]byte{})
      binary.Write(bytesBuffer, binary.LittleEndian, &tmp)
      return bytesBuffer.Bytes(), nil
   case 2:
      tmp := int16(n)
      bytesBuffer := bytes.NewBuffer([]byte{})
      binary.Write(bytesBuffer, binary.LittleEndian, &tmp)
      return bytesBuffer.Bytes(), nil
   case 3:
      tmp := int32(n)
      bytesBuffer := bytes.NewBuffer([]byte{})
      binary.Write(bytesBuffer, binary.LittleEndian, &tmp)
      return bytesBuffer.Bytes()[0:3], nil
   case 4:
      tmp := int32(n)
      bytesBuffer := bytes.NewBuffer([]byte{})
      binary.Write(bytesBuffer, binary.LittleEndian, &tmp)
      return bytesBuffer.Bytes(), nil
   case 5:
      tmp := n
      bytesBuffer := bytes.NewBuffer([]byte{})
      binary.Write(bytesBuffer, binary.LittleEndian, &tmp)
      return bytesBuffer.Bytes()[0:5], nil
   case 6:
      tmp := n
      bytesBuffer := bytes.NewBuffer([]byte{})
      binary.Write(bytesBuffer, binary.LittleEndian, &tmp)
      return bytesBuffer.Bytes()[0:6], nil
   case 7:
      tmp := n
      bytesBuffer := bytes.NewBuffer([]byte{})
      binary.Write(bytesBuffer, binary.LittleEndian, &tmp)
      return bytesBuffer.Bytes()[0:7], nil
   case 8:
      tmp := n
      bytesBuffer := bytes.NewBuffer([]byte{})
      binary.Write(bytesBuffer, binary.LittleEndian, &tmp)
      return bytesBuffer.Bytes(), nil
   }
   return nil, fmt.Errorf("IntToBytesLittleEndian b param is invaild")
}

//(大端) []byte 转 uint
func BytesToUIntBigEndian(b []byte) (int, error) {
   if len(b) == 3 {
      b = append([]byte{0}, b...)
   }
   bytesBuffer := bytes.NewBuffer(b)
   switch len(b) {
   case 1:
      var tmp uint8
      err := binary.Read(bytesBuffer, binary.BigEndian, &tmp)
      return int(tmp), err
   case 2:
      var tmp uint16
      err := binary.Read(bytesBuffer, binary.BigEndian, &tmp)
      return int(tmp), err
   case 4:
      var tmp uint32
      err := binary.Read(bytesBuffer, binary.BigEndian, &tmp)
      return int(tmp), err
   default:
      return 0, fmt.Errorf("%s", "BytesToInt bytes lenth is invaild!")
   }
}

//(大端) []byte 转 int
func BytesToIntBigEndian(b []byte) (int, error) {
   if len(b) == 3 {
      b = append([]byte{0}, b...)
   }
   bytesBuffer := bytes.NewBuffer(b)
   switch len(b) {
   case 1:
      var tmp int8
      err := binary.Read(bytesBuffer, binary.BigEndian, &tmp)
      return int(tmp), err
   case 2:
      var tmp int16
      err := binary.Read(bytesBuffer, binary.BigEndian, &tmp)
      return int(tmp), err
   case 4:
      var tmp int32
      err := binary.Read(bytesBuffer, binary.BigEndian, &tmp)
      return int(tmp), err
   default:
      return 0, fmt.Errorf("%s", "BytesToInt bytes lenth is invaild!")
   }
}

//(小端) []byte 转 uint
func BytesToUIntLittleEndian(b []byte) (int, error) {
   if len(b) == 3 {
      b = append([]byte{0}, b...)
   }
   bytesBuffer := bytes.NewBuffer(b)
   switch len(b) {
   case 1:
      var tmp uint8
      err := binary.Read(bytesBuffer, binary.LittleEndian, &tmp)
      return int(tmp), err
   case 2:
      var tmp uint16
      err := binary.Read(bytesBuffer, binary.LittleEndian, &tmp)
      return int(tmp), err
   case 4:
      var tmp uint32
      err := binary.Read(bytesBuffer, binary.LittleEndian, &tmp)
      return int(tmp), err
   default:
      return 0, fmt.Errorf("%s", "BytesToInt bytes lenth is invaild!")
   }
}

// 小端[]byte 转 int
func BytesToIntLittleEndian(b []byte) (int, error) {
   if len(b) == 3 {
      b = append([]byte{0}, b...)
   }
   bytesBuffer := bytes.NewBuffer(b)
   switch len(b) {
   case 1:
      var tmp int8
      err := binary.Read(bytesBuffer, binary.LittleEndian, &tmp)
      return int(tmp), err
   case 2:
      var tmp int16
      err := binary.Read(bytesBuffer, binary.LittleEndian, &tmp)
      return int(tmp), err
   case 4:
      var tmp int32
      err := binary.Read(bytesBuffer, binary.LittleEndian, &tmp)
      return int(tmp), err
   default:
      return 0, fmt.Errorf("%s", "BytesToInt bytes lenth is invaild!")
   }
}

参考：

https://blog.csdn.net/skh2015java/article/details/80751229

https://www.jb51.net/article/150599.htm

 

爆米花9958
关注
专栏目录
48、Go语言秘籍：数组与字符串的转换技巧解析
silenceallat的博客
06-23 798
本文深入探讨了Go语言中数组与字符串的转换方法，涵盖了fmt.Sprintf和strings.Split等关键函数的使用，同时强调了在转换过程中需要注意的细节和注意事项。通过实际应用场景和实用技巧，我们了解了数组与字符串之间的内在联系，以及如何处理Unicode字符和字节切片。本文旨在帮助读者更好地理解和应用这些知识，提高编程效率。
golang中字符串与数组，切片的转换
ens160的博客
10-28 5353
go语言将字符串作为一种原生的基本数据类型，字符串的初始化可以使用字符串的字面量 var a = "hello,world" 1) 字符串是常量，可以通过类似数组的索引访问其字节单元，但是不能修改某个字节的值 var a = "hello,world" b := a[0] a[1]='a' package main import "fmt" func main() { var a = "hello , world" b := []byte(a)//此时打印b,以rane方式...
go语言中int和byte转换方式
09-19
主要介绍了go语言中int和byte转换方式,需要的朋友可以参考下
golang int转byte数组
Zx13170918986的博客
01-28 1341
golang int转byte数组
go语言byte与uint32之间的转换
jkwanga的博客
12-11 4911
字节与整形之间的转换 func Uint16(b []byte) uint16 { _ = b[1] return uint16(b[0]) | uint16(b[1])<<8 } func BytesToUint32(b []byte) uint32 { _ = b[3] // bounds check hint to compiler; see golang.org/issue/14808 return uint32(b[0]) | ui
golang int与byte数组之间的转换
qq_45535340的博客
05-24 3845
golang byte[] 与int 相互转换
go, uint32与byte数组互转
最新发布
06-08 352
golang 下的 uint32与byte数组互转
python调用golang 数组_Golang数据类型 数组(arry)
weixin_39762001的博客
12-24 351
前言前面学习了Go数据类型中的数字、字符串，下面看看Go中是否有Python中的list、dict等复合数据类型？需要注意的是在Go中数组是可变类型+值(拷贝)类型，而go中切片是引用类型；数组声明之后它里面的元素是可以被修改，如果把1个数组变量引用到1个新的变量，那么这个新的变量会重新拷贝一份旧数组的数组。Python中的list是可变+引用数据类型llist1 = ["A", "B", "C"...
初探Golang（3）-数据类型
weixin_44560620的博客
04-30 315
Go语言拥有两大数据类型，基本数据类型和复合数据类型。 1. 数值类型 ##有符号整数 int8（-128 -> 127） int16（-32768 -> 32767） int32（-2,147,483,648 -> 2,147,483,647） int64（-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,807） int( 32 位操作系统上32 位,64 位操作系统64 位) ##无符号整数 uint8（0 ->
关于go语言中int和byte转换方式
hdxx2022的博客
08-18 986
/ | b2[0] | b2[1] | b2[2] | b2[3] | // 这里表示b2数组每个下标里面存放的值。// | 00000000 | 00000000 | 00000001 | 00000001 | 右移16位 转成uint8后等于 0。// 所以最终将uint32转成[]byte数组输出为。低地址 --------------------> 高地址。低地址 --------------------> 高地址。// |---这部分go在强转的时候扔掉---|
简单谈谈Golang中的字符串与字节数组
09-19
主要给大家介绍了关于Golang中字符串与字节数组的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者使用Golang具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
golang []byte 和 int 互转
热门推荐
whatday的专栏
08-01 2万+
//isSymbol表示有无符号 func BytesToInt(b []byte, isSymbol bool) (int, error){ if isSymbol { return bytesToIntS(b) } return bytesToIntU(b) } //字节数(大端)组转成int(无符号的) func bytesToIntU(b []byte) (int...
切片类型转换
qq_44932835的博客
05-15 553
package main import ( "encoding/binary" "fmt" "reflect" "unsafe" ) func main() { var a uint32 = 'a' var arrs []uint32 = []uint32{97, 98, 99} //1.uint32转化为[]byte fmt.Printf("uint32转化为[]byte: %v\n", U32ToByteSlice(a)) //3.[]byte转化为uint32 fmt.Pri
.Net冷知识之UInt32转换为Byte的方法1、2、3
weixin_30852367的博客
03-09 426
老天爷你算是赢了，忽冷忽热的搞毛啊。最近因为各种原因掌握了丰富的就诊经验（好吧，和这篇博文一样毫无意义的技能Get★daze）。 本来这篇博文的内容是上周冲澡的时候脑洞大开的成果，结果由于各（lan）种（de）原（dong）因（shou）拖延到了今天，那就顺手当作三八妇女节献礼好了（<ゝω・）綺羅星☆。 今天要讨论的是有多少种无趣的手段把一个UInt32拆成4个Byte。至于其他长度整形...
使用Golang如何将[]byte字节数组转成int类型
蜗牛沐雨
05-16 1万+
可以通过使用encoding/binary下的ByteOrder将go语言的字节数组转成int类型，下面以小端序的字节数组[8 0 0 0]转成uint32为例： package main import ( "encoding/binary" "fmt" ) func main() { byteArr := []byte{8, 0, 0, 0} fmt.Println("原始字节数组为：") fmt.Println(byteArr) data := binary.LittleEndian.U
Go语言 字节数组和string
yanghaitao5000的博客
07-02 1017
字符串和字节数组: 字符串:是8位字节的集合，可以为空，不能为nil。字符串的定义为一个结构体(一个字段指向字节数组的指针，第二个字段为len长度)[]byte:byte是uintptr8的别名，字节数组的定义(第一个字段为数组的指针，第二个字段表示长度 第三个字段表示容量)，看起来和string很像，实则差别很大。区别:字符串值不能更改，但可以被替换，字符串底层的指针指向的是一个字符串常量的地址，这个地址是只读的，地址内容不可以被改变，但指针可以指向不同的地址。区别总结:更改变量时，[]byte结构体里，
go字符串转byte_go语言中int和byte转换方式
weixin_35145307的博客
12-24 4488
主机字节序主机字节序模式有两种，大端数据模式和小端数据模式，在网络编程中应注意这两者的区别，以保证数据处理的正确性；例如网络的数据是以大端数据模式进行交互，而我们的主机大多数以小端模式处理，如果不转换，数据会混乱 参考 ；一般来说，两个主机在网络通信需要经过如下转换过程：主机字节序 —> 网络字节序 -> 主机字节序大端小端区别大端模式：Big-Endian就是高位字节排放在内存的低地...
Go语言学习：基本类型与转换详解
转换仅发生在兼容的类型之间，如各类整型之间是不兼容的，不能直接转换。 **类型别名** 允许创建一个已存在类型的别名，例如 `type t_str string`，`t_str` 就是 `string` 的别名。 **类型默认值** 当声明变量但未...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值