当前位置：首页 > 文章列表 > Golang > Go问答 > 将可变大小的字节流转化为 int64 类型的数据

将可变大小的字节流转化为 int64 类型的数据

来源：stackoverflow 2024-03-01 09:27:24 0浏览收藏

欢迎各位小伙伴来到golang学习网，相聚于此都是缘哈哈哈！今天我给大家带来《将可变大小的字节流转化为 int64 类型的数据》，这篇文章主要讲到等等知识，如果你对Golang相关的知识非常感兴趣或者正在自学，都可以关注我，我会持续更新相关文章！当然，有什么建议也欢迎在评论留言提出！一起学习！

问题内容

我有一个将 int64 ([]int64) 切片转置为 int64 的方法，但我还没有找到实现它的方法。

package main

import "fmt"
import "bytes"
import "encoding/binary"

func main() {
    var myslice = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 23}
    data := binary.bigendian.uint64(myslice)
    fmt.println(data)

    var ret int64
    buf := bytes.newbuffer(myslice)
    binary.read(buf, binary.bigendian, ret)

    fmt.println(ret)
}

我的方法从给定大小初始化 []byte（例如 make([]byte, 20)），并且我的方法对给定位和维度大小进行操作并将其交错（位操作）：

所以，假设一个 []byte{0 0 0 0 0 0 0 0 0 23} 给出 23，而 [更多尾随零...，125，更多尾随零...] 是 500

我想我正在寻找更像java的biginteger类的东西，它接受bigendian中的[]byte（和signum）。

我尝试（从 java）移植的方法是这样的：

biginteger toindex(long... transposedindex) {
        byte[] b = new byte[length];
        int bindex = length - 1;
        long mask = 1l << (bits - 1);
        for (int i = 0; i < bits; i++) {
            for (int j = 0; j < transposedindex.length; j++) {
                if ((transposedindex[j] & mask) != 0) {
                    b[length - 1 - bindex / 8] |= 1 << (bindex % 8);
                }
                bindex--;
            }
            mask >>= 1;
        }
        // b is expected to be bigendian
        return new biginteger(1, b);
    }

我在 golang 中拥有的是这样的：

func (s *TestStruct) untranspose(x []int64) (b int64) {
    t := make([]byte, s.length)
    bIndex := s.length - 1
    mask := int64(1 << (s.bits - 1))

    for i := 0; i < int(s.bits); i++ {
        for j := 0; j < len(x); j++ {
            if (x[j] & mask) != 0 {
                t[s.length - 1 - bIndex / 8] |= 1 << (bIndex % 8)
            }

            bIndex--
        }
        mask >>= 1
    }

    return int64(binary.BigEndian.Uint64(t))
}

这似乎不正确。 []byte 可能比 8 位长，例如 [0 0 0 0 0 0 0 0 2 170]

解决方案

首先，你的切片太长。因此，如果每个值代表一个字节，则 64 位无符号整数仅需要 8 个条目。该切片是从前往后读取的，因此在您的示例中，23 条目被截断，因为它是第 10 个条目。

此外，从缓冲区读取时，需要传递一个引用作为最后一个参数（&ret）。

最后，将 ret 定义为 32 位长的 uint，其中 myslice 定义 64 位整数 (uint64)。这意味着切片的最后 32 位将被切断。

下面是示例的工作代码及其输出：

package main

import "fmt"
import "bytes"
import "encoding/binary"

func main() {
    var myslice = []byte{0, 0, 0, 0, 0, 0, 0, 23}
    data := binary.bigendian.uint64(myslice)
    fmt.println(data)

    var ret uint64
    buf := bytes.newbuffer(myslice)
    binary.read(buf, binary.bigendian, &ret)
    fmt.println(ret)
}