在 Golang 中从 4、3 和 1 位数据创建 8 位二进制数据

对于一个Golang开发者来说，牢固扎实的基础是十分重要的，golang学习网就来带大家一点点的掌握基础知识点。今天本篇文章带大家了解《在 Golang 中从 4、3 和 1 位数据创建 8 位二进制数据》，主要介绍了，希望对大家的知识积累有所帮助，快点收藏起来吧，否则需要时就找不到了！

我需要使用版本（4 位）、计数（3 位）、标识符（1 位）形成标头（8 位）。我怎样才能在 go 中实现这一目标？例如：

version: 1 (0001)
count: 3 (011)
identifier: 1(1)

header: 00010111 (23)

我正在执行以下操作，但有很多繁琐的代码。我怎样才能有效地做到这一点？

const (
    VersionSize       binary.Bits  = 4
    countSize         binary.Bits  = 3
    IdentifierSize    binary.Bits  = 1
)

type header struct {
    version      uint8 
    count        uint8
    identifier   uint8
}

func main() {
    headerObj := &header{version:1, count:3, identifier:1}
    headerBytes := encode(headerObj)
    // prints [23]
    fmt.PrintLn(headerBytes)
}

func (h *header) encode() []byte {
    var header []byte

    vercountIdBinary := toBinary(h.version, versionSize) + toBinary(h.count,countSize) + toBinary(h.identifier, IdentifierSize)

    vercountIdByte, _ := strconv.ParseInt(vercountIdBinary, 2, 8)
    header = append(header, byte(vercountIdByte))

    return header
}

func toBinary(value interface{}, bitSize binary.Bits) string {
    format := "%0" + strconv.Itoa(int(bitSize)) + "b"
    return fmt.Sprintf(format, value)
}

解决方案

通过位掩码和移位可以简单地实现将位打包和解包为数字。

例如，将位打包成一个数字，掩码并分配第一个，然后将结果与位数或下一个数据左移（为其留出足够的空间）。然后屏蔽第二个数字，并使用按位或“添加”它。然后再次移动第三个数字的大小，然后重复。

解包：用最后一个字段的大小屏蔽结果，然后你就得到了最后一个数字。将数据右移为解码后数字的大小，并使用下一个（按相反顺序）数字的大小进行掩码，然后就得到了数字。重复此过程，直到解码完所有数字。

例如，这会将 identifier 打包到最高有效位，将 count 打包到中间，将 version 打包到最低有效位，但您可以通过以相反的顺序打包字段来执行相反的顺序：

const (
    bitsversion = 4
    bitscount   = 3
    bitsid      = 1
)

const (
    maskversion = 1<<bitsversion - 1
    maskcount   = 1<<bitscount - 1
    maskid      = 1<<bitsid - 1
)

type header struct {
    version    uint8
    count      uint8
    identifier uint8
}

func (h *header) tobyte() uint8 {
    var b uint8

    b = h.identifier & maskid
    b <<= bitscount
    b |= h.count & maskcount
    b <<= bitsversion
    b |= h.version & maskversion

    return b
}

func (h *header) parsebyte(b uint8) {
    h.version = b & maskversion
    b >>= bitsversion
    h.count = b & maskcount
    b >>= bitscount
    h.identifier = b & maskid
}

测试它：

h := &header{
    version:    3,
    count:      2,
    identifier: 1,
}
fmt.printf("%+v\n", h)

b := h.tobyte()

h2 := &header{}
h2.parsebyte(b)
fmt.printf("%+v\n", h2)

将输出（在 Go Playground 上尝试）：

&{version:3 count:2 identifier:1}
&{version:3 count:2 identifier:1}

注意：上面的示例按照 id-count-version 顺序对字段进行编码。只要打包和解包都按照相同的顺序进行，字段的顺序并不重要。如果您需要反向顺序（version-count-id），只需反转字段打包/解包的顺序即可。操作方法如下：

func (h *header) ToByte() uint8 {
    var b uint8

    b = h.version & MaskVersion
    b <<= BitsCount
    b |= h.count & MaskCount
    b <<= BitsId
    b |= h.identifier & MaskId

    return b
}

func (h *header) ParseByte(b uint8) {
    h.identifier = b & MaskId
    b >>= BitsId
    h.count = b & MaskCount
    b >>= BitsCount
    h.version = b & MaskVersion
}

这输出相同。请拨打 Go Playground 试试这个。

请注意，如果您必须对多个数据执行此操作，并针对 io.writer 流，则可以使用 github.com/icza/bitio 库（声明：我是作者）。

本篇关于《在 Golang 中从 4、3 和 1 位数据创建 8 位二进制数据》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！