P.S. 我知道在 JavaScript 中有很多 处理大整数的 库, 但通常它们都非常庞大并提供大量的数学运算，而我在这里不需要。我正在寻找一个简单的、现代的、直接的解决方案，只需要将 BE-packed 的 Uint64 和 Int64 字节解码为数字字符串。你有什么想法吗？
编辑：对于转换（U）int64，我现在一定会推荐@LS_DEV的解决方案。只有当有未知或更大数量的字节时，才会使用我的解决方案。
我从https://dev59.com/RGMl5IYBdhLWcg3wK0WA#21668344开始，并进行了修改：
function Int64ToString(bytes, isSigned) {
const isNegative = isSigned && bytes.length > 0 && bytes[0] >= 0x80;
const digits = [];
bytes.forEach((byte, j) => {
if(isNegative)
byte = 0x100 - (j == bytes.length - 1 ? 0 : 1) - byte;
for(let i = 0; byte > 0 || i < digits.length; i++) {
byte += (digits[i] || 0) * 0x100;
digits[i] = byte % 10;
byte = (byte - digits[i]) / 10;
}
});
return (isNegative ? '-' : '') + digits.reverse().join('');
}
const tests = [
{
inp: [77, 101, 130, 33, 7, 252, 253, 82],
signed: false,
expectation: '5577006791947779410'
},
{
inp: [255, 255, 255, 255, 255, 255, 255, 255],
signed: true,
expectation: '-1'
},
];
tests.forEach(test => {
const result = Int64ToString(test.inp, test.signed);
console.log(`${result} ${result !== test.expectation ? '!' : ''}=== ${test.expectation}`);
});bytes [0] > 128）来计算。对于负数，比特必须被否定（255-byte），并且必须将1添加到数字中（因此为256而不是255，用于最后一个字节）。byte％10），并计算开销（字节-数字[i]）/ 10或 Math.floor（byte / 10）下一个数字。对于下一个字节，必须添加上一个字节数字的移位结果（byte + = digits [i] * 256或digits [i] << 8 ）。 0x100 和 0x80 ，另外（在情况下仅剩两个字节组的（U）Int64的情况下） forEach 循环可以展开。分组十进制数字可能不会增加性能，因为结果字符串必须用零填充，从而引入了在最终结果中删除前导零的需要。h*0x100000000+l。考虑十进制，也可以考虑较低的9位数字和剩余的较高数字（ld和hd）：ld=(h*0x100000000+l)%1000000000和hd=(h*0x100000000+l)/1000000000。通过一些算术和代数运算符的属性，可以将这些操作分解为安全的“半”64位操作，并在最后组合字符串。
function int64_to_str(a, signed) {
const negative = signed && a[0] >= 128;
const H = 0x100000000, D = 1000000000;
let h = a[3] + a[2] * 0x100 + a[1] * 0x10000 + a[0]*0x1000000;
let l = a[7] + a[6] * 0x100 + a[5] * 0x10000 + a[4]*0x1000000;
if(negative) {
h = H - 1 - h;
l = H - l;
}
const hd = Math.floor(h * H / D + l / D);
const ld = (((h % D) * (H % D)) % D + l) % D;
const ldStr = ld + '';
return (negative ? '-' : '') +
(hd != 0 ? hd + '0'.repeat(9 - ldStr.length) : '') + ldStr;
}
let result = int64_to_str([77, 101, 130, 33, 7, 252, 253, 82], false);
let expectation = '5577006791947779410';
console.log(result + ' ' + (result === expectation ? '===' : '!==') + ' ' + expectation);
result = int64_to_str([255, 255, 255, 255, 255, 255, 255, 255], true);
expectation = '-1';
console.log(result + ' ' + (result === expectation ? '===' : '!==') + ' ' + expectation);(h % D) * (H % D) 的值比 Number.MAX_SAFE_INTEGER 更大，也可以正常工作，因为丢失的位数仍然是零。Math.trunc(ld/D)部分，因为第一个总和在数学上已经包含了该部分。纠正后，我仍然不确定它是否能够正确地工作。h*H可以得到远高于Number.MAX_SAFE_INTEGER的数字。通过除以D并截断来消除精度损失。然而，我更担心的是(h%D)*(H%D)，因为 D*(H%D)也太大了，这次需要全部精度。 - StephanD 的最后11位（因此为0x800），因此 H%D 已经为零，因此由于“精度损失”而隐式设置它们为零不会引入任何错误。 另外一点需要注意的是：当 hd 为零时，不应附加前导零。 - Stephan;) - VisioNUInt64 版本 - 我无法想象交换会那么困难：
<!DOCTYPE html>
<html>
<body>
<span id='out1'></span>
<br>
<span id='out2'></span>
<br>
<span id='out3'></span>
</body>
<script>
fnl='';
be=[77, 101, 130, 33, 7, 252, 253, 82];
function paddedBinary(n) {
pad='';
sv=128;
while (sv>n) {pad+='0';sv/=2;}
return pad+n.toString(2);
}
for (let i=0;i<8;i++)
fnl+=paddedBinary(be[i]);
out1.textContent=fnl;
dec=new Array(64);
for (let i=0;i<64;i++) dec[i]=new Array(21).fill(0);
function make2s() {
dec[0][0]=1;
for (let i=1;i<64;i++) {
for (let j=0;j<21;j++)
dec[i][j]=2*dec[i-1][j];
for (let j=0;j<21;j++)
if (dec[i][j]>9) {
dec[i][j]-=10;
dec[i][j+1]++;
}
}
}
function int64add(v1,v2) {
var res=new Array(21).fill(0);
for (let i=0;i<21;i++)
res[i]=v1[i]+v2[i];
for (let i=0;i<21;i++)
if (res[i]>9) {
res[i]-=10;
res[i+1]++;
}
return res;
}
make2s();
for (let i=0;i<64;i++)
out2.textContent+=dec[i]+' :: ';
cv=new Array(21).fill(0);
for (let i=0;i<fnl.length;i++)
if (fnl[i]=='1') cv=int64add(cv,dec[63-i]);
out3.textContent=cv;
</script>
</html>paddedBinary()函数返回一个完整的8位二进制数，因此我们可以将'fnl'创建为BigEndian的64位字符串。dec[]数组，以将每个2的幂作为单独的数字存储，通过加倍每个先前的数字并平滑十位数来实现。Uint8Array中的每个字节（从最高位到最低位），将运行总数乘以256并将其添加到新字节的值中
- 要将一个数字乘以256，将其翻倍8次（因为2 ** 8 == 256）
- 要求两个数字的和，使用小学算法：n1[i] || 0 获取n1的第i位数字。如果超出了i的范围，我们将其视为0（想象一下用无限的0来表示数字）。n2同理。added > 9生成一个布尔值，自动转换为数字（如果added >= 10则为1，否则为0）i < n1.length || i < n2.length || carry检查加数或进位是否还有更多数字String(b).split('').map(Number).reverse()将例如100转换为'100'，然后是['1'， '0'， '0']，然后是[1, 0, 0]，最后是[0, 0, 1]，因此它以LE基数10表示result.reverse().join('')将例如[0, 0, 1]转换为[1, 0, 0]，然后是'100'代码：
function add(n1, n2) {
const sum = []
let carry = 0
for (let i = 0; i < n1.length || i < n2.length || carry; i++) {
const added = (n1[i] || 0) + (n2[i] || 0) + carry
sum[i] = added % 10
carry = added > 9 //floor(added / 10)
}
return sum
}
function times256(n1) {
for (let i = 8; i; i--) n1 = add(n1, n1)
return n1
}
function toString(buffer) {
const isNegative = buffer[0] & 128 //check if high bit is set
if (isNegative) { //convert to positive, using 2's complement
buffer = buffer.map(b => ~b) //invert all bits
let i = buffer.length - 1
while (buffer[i] === 255) { //add 1 to the number, carrying if necessary
buffer[i] = 0
i--
}
buffer[i]++
}
const result = buffer.reduce((sum, b) =>
add(
times256(sum), //multiply sum by 256
String(b).split('').map(Number).reverse() //then add b
),
[]
)
const stringResult = result.reverse().join('')
if (isNegative) return '-' + stringResult
else return stringResult
}
uint64很有效。为了使其与int64一起使用，我需要做哪些修改？我在这里创建了一个游乐场：https://jsfiddle.net/wcqLj1qg/。 - VisioN