在Golang中将可变大小的[]字节转换为int64_Go

在Golang中将可变大小的[]字节转换为int64

在Golang中将可变大小的[]字节转换为int64,go,Go,我有一个方法可以将int64（[]int64）的切片转换为int64，但我还没有找到方法我的方法从给定的大小初始化[]字节（例如，make（[]字节，20）），我的方法对给定的位和维度大小进行操作，并将其交错（位操作）：所以，假设一个[]字节{0 0 0 0 0 0 0 23}给出23，一个[更多的尾随零…，125，更多的尾随零…]是500 我想我正在寻找更像java的类的东西，它在BigEndian中接受[]字节（和符号）我尝试（从Java）移植的方法如下： BigInteger toI

我有一个方法可以将int64（[]int64）的切片转换为int64，但我还没有找到方法

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

所以，假设一个[]字节{0 0 0 0 0 0 0 23}给出23，一个[更多的尾随零…，125，更多的尾随零…]是500

我想我正在寻找更像java的类的东西，它在BigEndian中接受[]字节（和符号）

我尝试（从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);
    }

BigInteger到索引（长…转置索引）{
字节[]b=新字节[长度]；
int bIndex=长度-1；
长面罩=1L=1；
}
//b应该是BigEndian
返回新的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))
}

func（s*TestStruct）取消转换（x[]int64）（b int64）{
t:=make（[]字节，s.长度）
bIndex:=s.length-1
掩码：=int64（1=1）
}
返回int64（二进制.BigEndian.Uint64（t））
}

这似乎不正确。[]字节可能超过8位，比如说，[0 0 0 0 2 170]

首先，切片太长。因此，如果每个值代表一个字节，则64位无符号整数只需要8个条目。切片是从前到后读取的，因此在示例中，

条目被截断，因为它是第10个条目

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

&ret

）

最后，您将

ret

定义为长度为32位的

uint

，其中

mySlice

定义了64位整数（

uint64

）。这意味着片的最后32位将被截断

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

主程序包
输入“fmt”
导入“字节”
导入“编码/二进制”
func main（）{
var mySlice=[]字节{0,0,0,0,0,0,0,23}
数据：=binary.BigEndian.Uint64（mySlice）
fmt.Println（数据）
变量ret uint64
buf:=bytes.NewBuffer（mySlice）
Read（buf、binary.BigEndian和ret）
fmt.Println（翻新）
}