Go中big.Int与[2]int64互转及补码问题：转换后值不符

你的核心问题在于big.Int的右移使用方式错误，以及补码转回big.Int的逻辑不符合big.Int的存储规则，导致无法还原原始值。以下是具体问题和修正方案：

你的代码中的关键问题 #

1. 右移操作的副作用与逻辑偏差
   value.Rsh(value, 64)会直接修改value变量本身，虽然result[0]能正确获取原始值，但对于负数的big.Int，算术右移64位得到的符号扩展结果（比如-42右移64位得到-1），并不能直接通过big.Int左移拼接的方式还原——因为big.Int采用符号位+绝对值的存储方式，而非补码。

2. 转回逻辑错误
   当你用big.NewInt(result[1]).Lsh(64).Add(big.NewInt(result[0]))时，实际计算的是result[1] << 64 + result[0]，但对于负数的result[1]（比如-1），-1 << 64在big.Int中是-2^64，加上-42得到-2^64-42，显然不等于原始的-42。这是因为补码的高64位是符号扩展，不能直接用big.Int的常规位运算拼接。

修正后的代码 #

package main

import (
	"encoding/binary"
	"fmt"
	"math/big"
)

// BigIntToInt128LE 将big.Int转换为[2]int64，完全匹配Rust的i128::to_le_bytes()结果
func BigIntToInt128LE(x *big.Int) [2]int64 {
	var buf [16]byte
	abs := new(big.Int).Abs(x)
	
	// 写入绝对值的低64位和高64位（小端）
	binary.LittleEndian.PutUint64(buf[:8], abs.Uint64())
	abs.Rsh(abs, 64)
	binary.LittleEndian.PutUint64(buf[8:], abs.Uint64())

	// 负数转换为补码：按位取反加1
	if x.Sign() == -1 {
		// 按位取反
		for i := range buf {
			buf[i] = ^buf[i]
		}
		// 加1处理进位
		carry := 1
		for i := 0; i < 16; i++ {
			sum := int(buf[i]) + carry
			buf[i] = byte(sum & 0xff)
			carry = sum >> 8
			if carry == 0 {
				break
			}
		}
	}

	// 转换为[2]int64返回
	return [2]int64{
		int64(binary.LittleEndian.Uint64(buf[:8])),
		int64(binary.LittleEndian.Uint64(buf[8:])),
	}
}

// Int128LEToBigInt 将[2]int64转换回big.Int，还原原始值
func Int128LEToBigInt(le [2]int64) *big.Int {
	var buf [16]byte
	binary.LittleEndian.PutUint64(buf[:8], uint64(le[0]))
	binary.LittleEndian.PutUint64(buf[8:], uint64(le[1]))

	// 判断是否为负数：检查补码最高位（第15字节的第7位）
	isNegative := (buf[15] & 0x80) != 0

	// 将小端字节转换为big.Int（SetBytes默认大端，需反转）
	var u128 big.Int
	u128.SetBytes(reverseBytes(buf[:]))

	if isNegative {
		// 补码转负数：-(2^128 - 无符号值)
		var two128 big.Int
		two128.Lsh(big.NewInt(1), 128)
		two128.Sub(&two128, &u128)
		two128.Neg(&two128)
		return &two128
	}
	return &u128
}

// reverseBytes 反转字节数组，适配big.Int.SetBytes的大端要求
func reverseBytes(b []byte) []byte {
	res := make([]byte, len(b))
	for i := range b {
		res[i] = b[len(b)-1-i]
	}
	return res
}

func main() {
	initial := new(big.Int)
	initial.SetString("-42", 10)

	// 转换为[2]int64
	result := BigIntToInt128LE(initial)
	fmt.Println("转换后的[2]int64:", result)

	// 转回big.Int
	reverse := Int128LEToBigInt(result)
	fmt.Println("转回后的big.Int:", reverse.String())
	fmt.Println("是否匹配原始值:", initial.String() == reverse.String())

	// 正数测试
	posInitial := big.NewInt(1234567890123456789)
	posResult := BigIntToInt128LE(posInitial)
	posReverse := Int128LEToBigInt(posResult)
	fmt.Println("\n正数测试:")
	fmt.Println("原始值:", posInitial.String())
	fmt.Println("转回后:", posReverse.String())
	fmt.Println("是否匹配:", posInitial.String() == posReverse.String())
}

代码说明 #

1. BigIntToInt128LE

   • 先将big.Int的绝对值写入16字节小端数组；
   • 若为负数，对数组执行按位取反加1操作，生成标准的i128补码；
   • 将补码数组拆分为两个int64返回，完全对齐Rust的i128::to_le_bytes()结果。

2. Int128LEToBigInt

   • 将两个int64重新拼接为16字节小端补码数组；
   • 通过补码最高位判断正负，再将补码转换为big.Int的符号+绝对值存储格式；
   • 负数需通过2^128 - 无符号值再取负的方式还原。

内容的提问来源于stack exchange，提问作者plenio