Преобразование байта переменного размера [] в int64 в Golang

Question

У меня есть метод, который транспонирует часть int64 ([] int64) в int64, но я не нашел способ сделать it .

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)
}

Мой метод инициализирует[] байт заданного размера (скажем, make ([] byte, 20)), и мой метод работает с данным битом и размером измерения и чередует его (операции с битами):

Итак, скажем a []байт {0 0 0 0 0 0 0 0 0 23} дает 23 и [больше конечных нулей ..., 125, больше хвостовых нулей ...] равно 500

Я думаю, что-то ищубольше похоже на java BigInteger класс, который принимает [] byte (и signum) в 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);
    }

и то, что у меня есть на Голанге, таково:

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))
}

, что кажется неправильным.[] байт может быть длиннее 8 бит, скажем, [0 0 0 0 0 0 0 0 2 170]

Answer 1

Во-первых, ваш кусок слишком длинный.Из-за этого, если каждое значение представляет байт, то 64-разрядное целое число без знака требует только 8 записей.Срез читается спереди назад, поэтому в вашем примере запись 23 обрезается, потому что это 10-я запись.

Кроме того, при чтении из буфера необходимо передать ссылку в качестве последнего параметра(&ret).

Наконец, вы определяете ret как uint длиной 32 бита, где 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)
}

23
23