在Golang实战开发的过程中，我们经常会遇到一些这样那样的问题，然后要卡好半天，等问题解决了才发现原来一些细节知识点还是没有掌握好。今天golang学习网就整理分享《Go 的方式是 PutUint32 还是直接使用 >> 运算符？》，聊聊，希望可以帮助到正在努力赚钱的你。

这是获得相同 4 个字节的两种方法：

package main

import (
  "encoding/binary"
  "fmt"
)

func main() {
  i := binary.LittleEndian.Uint32([]byte{1, 2, 3, 0})
  bs := make([]byte, 4)
  binary.LittleEndian.PutUint32(bs, uint32(i))
  fmt.Println(bs[0] == 1 && bs[1] == 2 && bs[2] == 3 && bs[3] == 0)

  bs = []byte{byte(i & 0x000000ff),
    byte(i >> 8 & 0x000000ff),
    byte(i >> 16 & 0x000000ff),
    byte(i >> 24)}
  fmt.Println(bs[0] == 1 && bs[1] == 2 && bs[2] == 3 && bs[3] == 0)
}

它们都有效。但 go 社区认为哪种方式最好？

解决方案

让我们看看 go 标准库的内部：

func (littleendian) putuint32(b []byte, v uint32) {
    _ = b[3] // early bounds check to guarantee safety of writes below
    b[0] = byte(v)
    b[1] = byte(v >> 8)
    b[2] = byte(v >> 16)
    b[3] = byte(v >> 24)
}

并查看 package 二进制 文档：

此软件包更注重简单性，而不是效率。需要高性能序列化的客户端，尤其是大型数据结构，应该考虑更高级的解决方案，例如编码/gob 包或协议缓冲区。

我们应该走哪条路，取决于我们要解决的问题：
当效率不是主要关注点（我们试图通过编程解决的问题）时，简单就是要走的路（因为更少的错误 是这里的主要目标）：

1. 您可以将 go 标准库函数 binary.littleendian.putuint32 与数组一起使用（请注意，您可以在此处使用数组 [4]byte{}，以提高效率和简单性 通过 make([]byte, 4)):

var v uint32 = 0x4030201
        ary := [4]byte{}
        binary.littleendian.putuint32(ary[:], v)
        fmt.println(ary) // [1 2 3 4]

1. 您可以将 go 标准库函数 binary.littleendian.putuint32 与切片一起使用：

var v uint32 = 0x4030201
        b := make([]byte, 4)
        binary.littleendian.putuint32(b, v)
        fmt.println(b) // [1 2 3 4]

1. 您可以直接编写（效率，因为没有库函数调用）：

var v uint32 = 0x4030201
        a := [4]byte{
            byte(v),
            byte(v >> 8),
            byte(v >> 16),
            byte(v >> 24),
        }
        fmt.println(a) // [1 2 3 4]

1. 您可以使用 unsafe.pointer （只是为了效率或兼容性或...）：

var v uint32 = 1
        a := (*[4]byte)(unsafe.pointer(&v))
        a[0] = 100        // same memory (like `union` in the c language)
        fmt.println(a, v) // &[100 0 0 0] 100

1. 您可以使用 unsafe.pointer 并在一行中制作一份副本（因此不是 union）：

var v uint32 = 0x4030201
        a := *(*[4]byte)(unsafe.pointer(&v))
        fmt.println(a) // [1 2 3 4]

1. 您可以将 unsafe.pointer 与 copy 一起使用来切片：

b := make([]byte, 4)
    copy(b, (*[4]byte)(unsafe.pointer(&v))[:])

全部尝试here

基准：

benchmarkfn1-8          580469606                1.94 ns/op
benchmarkfn2-8          568699358                2.06 ns/op
benchmarkfn3-8          604883466                1.86 ns/op
benchmarkfn4-8          824232160                1.33 ns/op
benchmarkfn5-8          626357875                1.82 ns/op
benchmarkfn6-8          622969119                1.82 ns/op
benchmarkfn7-8          469203398                2.35 ns/op
benchmarkfn8-8          637403140                1.80 ns/op
benchmarkfn9-8          647179550                1.80 ns/op

main.go 文件：

package main

import (
    "encoding/binary"
    "unsafe"
)

// 1.94 ns/op
func fn1(v uint32) [4]byte {
    ary := [4]byte{}
    binary.littleendian.putuint32(ary[:], v)
    return ary
}

// 2.06 ns/op
func fn2(v uint32) []byte {
    b := make([]byte, 4)
    binary.littleendian.putuint32(b, v)
    return b
}

// 1.86 ns/op
func fn3(v uint32) [4]byte {
    a := [4]byte{
        byte(v),
        byte(v >> 8),
        byte(v >> 16),
        byte(v >> 24),
    }
    return a
}

// 1.33 ns/op
func fn4(v uint32) *[4]byte {
    a := (*[4]byte)(unsafe.pointer(&v))
    return a
}

// 1.82 ns/op
func fn5(v uint32) [4]byte {
    a := *(*[4]byte)(unsafe.pointer(&v))
    return a
}

// 1.82 ns/op
func fn6(v uint32) []byte {
    b := make([]byte, 4)
    copy(b, (*[4]byte)(unsafe.pointer(&v))[:])
    return b
}

// 2.35 ns/op
func fn7(v uint32) [4]byte {
    b := [4]byte{}
    copy(b[:], (*[4]byte)(unsafe.pointer(&v))[:])
    return b
}

// 1.80 ns/op
func fn8(v uint32) *[4]byte {
    b := [4]byte{}
    copy(b[:], (*[4]byte)(unsafe.pointer(&v))[:])
    return &b
}

//1.80 ns/op
func fn9(v uint32) []byte {
    b := [4]byte{}
    copy(b[:], (*[4]byte)(unsafe.pointer(&v))[:])
    return b[:]
}

func main() {}

main_test.go 文件：

package main

import "testing"

var result int

func benchmarkfn1(b *testing.b) {
    sum := 0
    for i := 0; i < b.n; i++ {
        r := fn1(uint32(i))
        sum += int(r[0]) + int(r[1]) + int(r[2]) + int(r[3])
    }
    result = sum
}

func benchmarkfn2(b *testing.b) {
    sum := 0
    for i := 0; i < b.n; i++ {
        r := fn2(uint32(i))
        sum += int(r[0]) + int(r[1]) + int(r[2]) + int(r[3])
    }
    result = sum
}

func benchmarkfn3(b *testing.b) {
    sum := 0
    for i := 0; i < b.n; i++ {
        r := fn3(uint32(i))
        sum += int(r[0]) + int(r[1]) + int(r[2]) + int(r[3])
    }
    result = sum
}

func benchmarkfn4(b *testing.b) {
    sum := 0
    for i := 0; i < b.n; i++ {
        r := fn4(uint32(i))
        sum += int(r[0]) + int(r[1]) + int(r[2]) + int(r[3])
    }
    result = sum
}

func benchmarkfn5(b *testing.b) {
    sum := 0
    for i := 0; i < b.n; i++ {
        r := fn5(uint32(i))
        sum += int(r[0]) + int(r[1]) + int(r[2]) + int(r[3])
    }
    result = sum
}

func benchmarkfn6(b *testing.b) {
    sum := 0
    for i := 0; i < b.n; i++ {
        r := fn6(uint32(i))
        sum += int(r[0]) + int(r[1]) + int(r[2]) + int(r[3])
    }
    result = sum
}

func benchmarkfn7(b *testing.b) {
    sum := 0
    for i := 0; i < b.n; i++ {
        r := fn7(uint32(i))
        sum += int(r[0]) + int(r[1]) + int(r[2]) + int(r[3])
    }
    result = sum
}

func benchmarkfn8(b *testing.b) {
    sum := 0
    for i := 0; i < b.n; i++ {
        r := fn8(uint32(i))
        sum += int(r[0]) + int(r[1]) + int(r[2]) + int(r[3])
    }
    result = sum
}

func benchmarkfn9(b *testing.b) {
    sum := 0
    for i := 0; i < b.n; i++ {
        r := fn9(uint32(i))
        sum += int(r[0]) + int(r[1]) + int(r[2]) + int(r[3])
    }
    result = sum
}

结论

超快且不安全（共享内存，例如 c union，它可能与小端系统和大端系统不同）：

a := (*[4]byte)(unsafe.pointer(&v))

快速且安全（v 作为数组的副本）：

a := [4]byte{byte(v), byte(v >> 8), byte(v >> 16), byte(v >> 24)}

简单快速（使用标准库将 v 复制为数组）：

ary := [4]byte{}
    binary.littleendian.putuint32(ary[:], v)

美丽（使用标准库将 v 复制为切片）：

b := make([]byte, 4)
    binary.LittleEndian.PutUint32(b, v)

本篇关于《Go 的方式是 PutUint32 还是直接使用 >> 运算符？》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！