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

电玩女神 2021-09-21 07:28 512阅读 0赞

### 主机字节序 ###

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

### 大端小端区别 ###

大端模式：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_blog.csdn.net_skh2015java_article_details_80751229]

[https://www.jb51.net/article/150599.htm][https_www.jb51.net_article_150599.htm]

[https_blog.csdn.net_skh2015java_article_details_80751229]: https://blog.csdn.net/skh2015java/article/details/80751229
[https_www.jb51.net_article_150599.htm]: https://www.jb51.net/article/150599.htm

发表评论取消回复

表情：

评论列表（有 0 条评论，512人围观）

还没有评论，来说两句吧...

相关阅读

相关字符串和数组之间的转换

String arr = "1,2,3,4,5"; //使用 string.split()函数 String[] split = arr .split(

柔情只为你懂/ 2024年04月01日 11:03/ 0 赞/ 55 阅读

相关 Qt 整型和字符型的转换

Qt 整型和字符型的转换文章目录 Qt 整型和字符型的转换 Qt Help 示例结果 Qt Help `[

今天药忘吃喽~/ 2022年12月05日 12:26/ 0 赞/ 158 阅读

相关字符串和整型之间的相互转换

1.atoi()将字符串转换成整型头文件：\include <stdlib.h> 语法：int atoi (const char \ str); 该函数会扫描字符

雨点打透心脏的1/2处/ 2022年11月05日 11:59/ 0 赞/ 205 阅读

相关整型数在做除法时整型和浮点型的转换

include<stdio.h> int main(int argc, const char argv[]) { //两个整数相除，得到

╰半夏微凉°/ 2022年08月06日 06:15/ 0 赞/ 207 阅读

相关 IP地址与整型数之间的转换

在Linux中关于IP和无符号整数之间的转换有两个比较好的函数: int inet\_aton(const char \cp, struct in\_addr \inp)

柔情只为你懂/ 2022年08月05日 11:08/ 0 赞/ 192 阅读

相关 JS怎么把字符串数组转换成整型数组

http://blog.csdn.net/youmoo/article/details/8051579 今天在学习highcharts时，遇到了一个把字符串数组转换为整形数组

柔情只为你懂/ 2022年07月13日 03:50/ 0 赞/ 312 阅读

相关 c语言整型字符字符串之间的转换

整型转字符 int n; scanf("%d",&n); char c; c = (char)n;

电玩女神/ 2022年05月30日 06:16/ 0 赞/ 260 阅读

相关 golang实现整型和字节数组之间的转换

//isSymbol表示有无符号 func BytesToInt(b []byte, isSymbol bool) (int, error){ if

阳光穿透心脏的1/2处/ 2022年05月22日 09:04/ 0 赞/ 210 阅读

相关 Java字节序,java整型数与网络字节序 byte[] 数组转换关系(ByteArrayOutputStream用法)

[Java字节序][Java] [http://origin100.iteye.com/blog/267165][Java] / 通信格式转换

爱被打了一巴掌/ 2022年05月16日 01:22/ 0 赞/ 227 阅读

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

主机字节序主机字节序模式有两种，大端数据模式和小端数据模式，在网络编程中应注意这两者的区别，以保证数据处理的正确性；例如网络的数据是以大端数据模式进行交互，而我们的主机

电玩女神/ 2021年09月21日 07:28/ 0 赞/ 513 阅读