将javascript整数转换为字节数组并返回
我的理解是javascript浮动是将javascript整数转换为字节数组并返回,javascript,Javascript,我的理解是javascript浮动是53位，所以它不应该溢出alert（Math.pow（2,53））工作正常。在JavaScript位移位（>）中，执行位移位与乘以2^（#位+1）相同，因此，与其使用Susanoh13提供的提示移位位val=val，不如使用以下两个函数将数字从字节数组转换为字节数组： var array = getInt64Bytes(23423423); var value = intFromBytes(array); console.log(value); //
53alert（Math.pow（2,53））>）中，执行位移位与乘以2^（#位+1）相同，因此，与其使用Susanoh13提供的提示移位位val=val，不如使用以下两个函数将数字从字节数组转换为字节数组：
var array = getInt64Bytes(23423423);
var value = intFromBytes(array);
console.log(value); //Prints 23423423 - correct
var array = getInt64Bytes(45035996273704);
var value = intFromBytes(array);
console.log(value); //Prints -1030792152 - incorrect
longToByteArray=函数（/*long*/long）{
//我们希望将输入表示为8字节数组
var byteArray=[0,0,0,0,0,0,0,0]；
对于（var index=0；index=0；i--）{
值=（值*256）+字节数组[i]；
}
返回值；
};
脑力操风格的Lodash版本。只需4个lulz！不要使用它
longToByteArray = function(/*long*/long) {
// we want to represent the input as a 8-bytes array
var byteArray = [0, 0, 0, 0, 0, 0, 0, 0];
for ( var index = 0; index < byteArray.length; index ++ ) {
var byte = long & 0xff;
byteArray [ index ] = byte;
long = (long - byte) / 256 ;
}
return byteArray;
};
byteArrayToLong = function(/*byte[]*/byteArray) {
var value = 0;
for ( var i = byteArray.length - 1; i >= 0; i--) {
value = (value * 256) + byteArray[i];
}
return value;
};
Uint32字节到字节数组
函数体添加（Msg）
{
document.body.innerHTML=document.body.innerHTML+Msg；
}
类字节
{
构造函数（值）
{
此.Number=新的UINT8阵列（1）；
此.Number[0]=值；
}
得到
{
返回此.编号[0]；
}
集合（新值）
{
此.Number[0]=新值；
}
};
Uint32级
{
构造函数（值）
{
此编号=新UINT32阵列（1）；
此.Number[0]=值；
}
得到
{
返回此.编号[0]；
}
集合（新值）
{
此.Number[0]=新值；
}
};
var转换=
{
Uint32字节到字节数组：函数（源编号）
{
var Uint32_Num=新Uint32（源编号）；
var Byte_Num=新字节（0）；
var Byte_Arr=新的Uint8Array（4）；
对于（变量i=0；i<4；i++）
{
如果（源数量>255）
{
Uint32_Num.Set=Source_Num/256；
Byte_Num.Set=Source_Num-Uint32_Num.Get*256；
}
其他的
{
Byte_Num.Set=Uint32_Num.Get；
Uint32_Num.Set=0；
}
Byte_Arr[i]=Byte_Num.Get；
Source_Num=Uint32_Num.Get；
}
返回（字节_Arr）；
},
字节数组到字节Uint32：函数（源字节数组，起始位置）
{
var Uint32_Num=新Uint32（0）；
var乘数=1；
for（设i=0；i<4；i++）
{
Uint32_Num.Set=Uint32_Num.Get+源字节数组[起始位置+i]*乘法器；
乘数=乘数*256；
}
返回（Uint32_Num.Get）；
}
};
函数加载_页（）
{
变量数=[0,12574294967295]；
数字。forEach（转换）；
函数转换（项、索引）
{
var Uint32_编号=项目；
var Byte_Array=将.Uint32_转换为字节_Array（Uint32_编号）；
var Uint32\u Number\u Restored=将字节数组\u转换为字节Uint32（字节数组，0）；
正文添加（“转换：源编号：”+Uint32\U编号.toString（）+”，字节数组：“+Byte\U数组.toString（）+”，还原编号：“+Uint32\U编号\U还原.toString（）+”
”；
};
};
尝试（**
是，
是）
intFromBytes
仅适用于由正整数生成的数组
<html>
<head>
<meta charset="utf-8">
<title>Uint32_To_Byte_Array</title>
<script>
function body_Add(Msg)
{
document.body.innerHTML = document.body.innerHTML + Msg;
}
class Byte
{
constructor(Value)
{
this.Number = new Uint8Array(1);
this.Number[0] = Value;
}
get Get()
{
return this.Number[0];
}
set Set(newValue)
{
this.Number[0] = newValue;
}
};
class Uint32
{
constructor(Value)
{
this.Number = new Uint32Array(1);
this.Number[0] = Value;
}
get Get()
{
return this.Number[0];
}
set Set(newValue)
{
this.Number[0] = newValue;
}
};
var Conversion =
{
Uint32_To_Byte_Array: function(Source_Num)
{
var Uint32_Num = new Uint32(Source_Num);
var Byte_Num = new Byte(0);
var Byte_Arr = new Uint8Array(4);
for (var i = 0; i < 4; i++)
{
if (Source_Num > 255)
{
Uint32_Num.Set = Source_Num / 256;
Byte_Num.Set = Source_Num - Uint32_Num.Get * 256;
}
else
{
Byte_Num.Set = Uint32_Num.Get;
Uint32_Num.Set = 0;
}
Byte_Arr[i] = Byte_Num.Get;
Source_Num = Uint32_Num.Get;
}
return(Byte_Arr);
},
Byte_Array_To_Uint32: function(Source_Byte_Array, Start_Position)
{
var Uint32_Num = new Uint32(0);
var Multiplier = 1;
for (let i = 0; i < 4; i++)
{
Uint32_Num.Set = Uint32_Num.Get + Source_Byte_Array[Start_Position + i] * Multiplier;
Multiplier = Multiplier * 256;
}
return (Uint32_Num.Get);
}
};
function Load_Page()
{
var Numbers = [0,1,257,4294967295];
Numbers.forEach(Convert);
function Convert(Item, Index)
{
var Uint32_Number = Item;
var Byte_Array = Conversion.Uint32_To_Byte_Array(Uint32_Number);
var Uint32_Number_Restored = Conversion.Byte_Array_To_Uint32(Byte_Array, 0);
body_Add("Conversion: Source number: " + Uint32_Number.toString() + ", Byte array: " + Byte_Array.toString() + ", Restored number: " + Uint32_Number_Restored.toString() + "<br>");
};
};
</script>
</head>
<body onload="Load_Page()">
</body>
函数getInt64字节（x）{
设y=数学楼层（x/2**32）；
return[y，（y如果您恰好在Node.js上，Buffer
是处理Javascript/Typescript中任何字节数组/流的正确方法：
虽然这些文档更全面，但Stack Overflow建议在链接404的情况下使用代码段，因此下面是该文档中几个最重要的代码示例：
function getInt64Bytes(x) {
let y= Math.floor(x/2**32);
return [y,(y<<8),(y<<16),(y<<24), x,(x<<8),(x<<16),(x<<24)].map(z=> z>>>24)
}
function intFromBytes(byteArr) {
return byteArr.reduce((a,c,i)=> a+c*2**(56-i*8),0)
}
位移位总是在有符号的32位整数上执行。这是有意义的，让它成为一个答案，我会接受。感谢这个问题在谷歌排名很高，可能值得指出的是现在有数组缓冲区：但是如果长（64位有符号整数）需要，解决方案是什么？JS不支持64位长的整数。请看：@TimoKähkönenxJavaScript（ESNext）现在支持64位数字。有符号和无符号。@derkjanspelman有链接吗？除非您指的是BigInt
，但这不是我在byteArrayToLong（）byteArray中所说的64位数字[i] 被视为字符串（依赖于浏览器），结果值计算错误。我通过*1:value=（value*256）+byteArray[i]进行了求解*1；您应该指定是否将字节视为包含有符号整数或无符号整数。这不适用于负数。相反，将解码大的正数。不要使用此代码。此代码仅在Javascript数字为64位无符号整数时有效。但是，它们是64位浮点数，只有或最多52位作为一个精确整数。这意味着，虽然此代码适用于许多字节（例如，[0,1,2,3,4,5,6,7]），但在实际使用所有位时，它将失败。一些失败的情况是（转换为数字并再次返回时会给出不同的结果）：（[255255]=>[0,0,0,0,0,0,0,255]），（[1,2,3,4,5,6,7,8]=>[0,2,3,4,5,6,7,8]），（[1,0,0,0,0,0,0,0,1]=>[0,0,0,0,0,0,1]）结果：转换：源编号：0，字节数组：0,0,0，还原编号：0；转换：源编号：1，字节数组：1,0,0，还原编号：1；转换：源编号：257，字节数组：1
<html>
<head>
<meta charset="utf-8">
<title>Uint32_To_Byte_Array</title>
<script>
function body_Add(Msg)
{
document.body.innerHTML = document.body.innerHTML + Msg;
}
class Byte
{
constructor(Value)
{
this.Number = new Uint8Array(1);
this.Number[0] = Value;
}
get Get()
{
return this.Number[0];
}
set Set(newValue)
{
this.Number[0] = newValue;
}
};
class Uint32
{
constructor(Value)
{
this.Number = new Uint32Array(1);
this.Number[0] = Value;
}
get Get()
{
return this.Number[0];
}
set Set(newValue)
{
this.Number[0] = newValue;
}
};
var Conversion =
{
Uint32_To_Byte_Array: function(Source_Num)
{
var Uint32_Num = new Uint32(Source_Num);
var Byte_Num = new Byte(0);
var Byte_Arr = new Uint8Array(4);
for (var i = 0; i < 4; i++)
{
if (Source_Num > 255)
{
Uint32_Num.Set = Source_Num / 256;
Byte_Num.Set = Source_Num - Uint32_Num.Get * 256;
}
else
{
Byte_Num.Set = Uint32_Num.Get;
Uint32_Num.Set = 0;
}
Byte_Arr[i] = Byte_Num.Get;
Source_Num = Uint32_Num.Get;
}
return(Byte_Arr);
},
Byte_Array_To_Uint32: function(Source_Byte_Array, Start_Position)
{
var Uint32_Num = new Uint32(0);
var Multiplier = 1;
for (let i = 0; i < 4; i++)
{
Uint32_Num.Set = Uint32_Num.Get + Source_Byte_Array[Start_Position + i] * Multiplier;
Multiplier = Multiplier * 256;
}
return (Uint32_Num.Get);
}
};
function Load_Page()
{
var Numbers = [0,1,257,4294967295];
Numbers.forEach(Convert);
function Convert(Item, Index)
{
var Uint32_Number = Item;
var Byte_Array = Conversion.Uint32_To_Byte_Array(Uint32_Number);
var Uint32_Number_Restored = Conversion.Byte_Array_To_Uint32(Byte_Array, 0);
body_Add("Conversion: Source number: " + Uint32_Number.toString() + ", Byte array: " + Byte_Array.toString() + ", Restored number: " + Uint32_Number_Restored.toString() + "<br>");
};
};
</script>
</head>
<body onload="Load_Page()">
</body>
function getInt64Bytes(x) {
let y= Math.floor(x/2**32);
return [y,(y<<8),(y<<16),(y<<24), x,(x<<8),(x<<16),(x<<24)].map(z=> z>>>24)
}
function intFromBytes(byteArr) {
return byteArr.reduce((a,c,i)=> a+c*2**(56-i*8),0)
}
// Creates a Buffer containing the UTF-8-encoded bytes for the string 'tést':
// [0x74, 0xc3, 0xa9, 0x73, 0x74] (in hexadecimal notation)
// [116, 195, 169, 115, 116] (in decimal notation)
const buf6 = Buffer.from('tést');
// Creates a Buffer containing the bytes [1, 2, 3].
const buf4 = Buffer.from([1, 2, 3]);