binary_to_double(data) {
    let buf = new Uint8Array(data);
    buf.reverse();
    let buf64 = new Float64Array(buf.buffer);
    return buf64[0];
浮点数转二进制
 
float_to_binary(data) 
    var str = Number(data).toString();		//单精度浮点数转为字符串表示（十进制）
    var hexStr = this.get_float_hex(str);	//十进制字符串表示转为十六进制字符串表示
    var bin = new Uint8Array(4);
    for(let i=0,j=0;i<4;i++,j+=2)
    	//将每个字节中的二进制数换算成十进制数，存到ArrayBuffer中
        let dec = parseInt(hexStr[j],16)*16 + parseInt(hexStr[j+1],16);	
        bin[i] = dec;
    return bin;
get_float_hex(decString)
    var dec = decString;	//浮点数的十进制字符串
    var sign;
    var signString;
    var decValue = parseFloat(Math.abs(decString));	//获取浮点数的绝对值
    if (decString.toString().charAt(0) == '-')
        sign = 1;	//若为负数，符号位为1
        signString = "1";
        sign = 0;	//若为正数，符号位为0
        signString = "0";
    if (decValue==0)	//对于0的特殊处理
        fraction = 0;
        exponent = 0;
        var exponent = 127;	//单精度浮点数的偏移值为127
        if (decValue>=2)	//若浮点数>=2，就不断除2，同时指数不断增加，直到浮点数小于2
            while (decValue>=2)
                exponent++;
                decValue /= 2;
        else if (decValue<1)	//若浮点数<1，就不断乘2，同时指数不断减少，直到浮点数大于1或指数为0
            while (decValue < 1)
                exponent--;
                decValue *= 2;
                if (exponent ==0)
                    break;
        if (exponent!=0) decValue-=1; else decValue /= 2;	//若指数不为0，取小数部分，否则除以2
    var fractionString = this.DecToBinTail(decValue, 23);	//取23位尾数
    var exponentString = this.DecToBinHead(exponent, 8);	//取8位阶码
    return this.Right('00000000'+parseInt(signString + exponentString + fractionString, 2).toString(16),8);
DecToBinTail(dec, pad)
    var bin = "";
    var i;
    for (i = 0; i < pad; i++)
        dec *= 2;
        if (dec>= 1)
            dec -= 1;
            bin += "1";
            bin += "0";
    return bin;
DecToBinHead(dec,pad)
    var bin="";
    var i;
    for (i = 0; i < pad; i++)
        bin = (parseInt(dec % 2).toString()) + bin;
        dec /= 2;
    return bin;
Right(String, Length)
    if (String == null) 
        return (false); 
    var dest = ''; 
    for (var i = (String.length - 1); i >= 0; i--) 
        dest = dest + String.charAt(i); 
    String = dest; 
    String = String.substr(0, Length); 
    dest = ''; 
    for (var i = (String.length - 1); i >= 0; i--) 
        dest = dest + String.charAt(i); 
    return dest; 
double_to_binary(data)
    var str = Number(data).toString();
    var hexStr = this.get_double_hex(str);
    var bin = new Uint8Array(8);
    for(let i=0,j=0;i<8;i++,j+=2)
        let dec = parseInt(hexStr[j],16)*16 + parseInt(hexStr[j+1],16);
        bin[i] = dec;
    return bin;
get_double_hex(decString)
    var dec = decString;
    var sign;
    var signString;
    var decValue = parseFloat(Math.abs(decString));
    if (decString.toString().charAt(0) == '-')
        sign = 1;
        signString = "1";
        sign = 0;
        signString = "0";
    if (decValue==0)
        fraction = 0;
        exponent = 0;
        var exponent = 1023;	//双精度浮点数偏移值为1023
        if (decValue>=2)
            while (decValue>=2)
                exponent++;
                decValue /= 2;
        else if (decValue<1)
            while (decValue < 1)
                exponent--;
                decValue *= 2;
                if (exponent ==0)
                    break;
        if (exponent!=0) decValue-=1; else decValue /= 2;
    var fractionString = this.DecToBinTail(decValue, 52);	//取52位尾数
    var exponentString = this.DecToBinHead(exponent, 11);	//取11位阶码
    var doubleBinStr = signString + exponentString + fractionString;
    var doubleHexStr = "";
    for(let i=0,j=0;i<8;i++,j+=8)
        let m = 3-(j%4);
        let hexUnit = doubleBinStr[j]*Math.pow(2,m) + doubleBinStr[j+1]*Math.pow(2,m-1) + doubleBinStr[j+2]*Math.pow(2,m-2) + doubleBinStr[j+3]*Math.pow(2,m-3);
        let hexDecade = doubleBinStr[j+4]*Math.pow(2,m) + doubleBinStr[j+5]*Math.pow(2,m-1) + doubleBinStr[j+6]*Math.pow(2,m-2) + doubleBinStr[j+7]*Math.pow(2,m-3);
        doubleHexStr = doubleHexStr + hexUnit.toString(16) + hexDecade.toString(16);
    return doubleHexStr;
DecToBinTail(dec, pad)
    var bin = "";
    var i;
    for (i = 0; i < pad; i++)
        dec *= 2;
        if (dec>= 1)
            dec -= 1;
            bin += "1";
            bin += "0";
    return bin;
DecToBinHead(dec,pad)
    var bin="";
    var i;
    for (i = 0; i < pad; i++)
        bin = (parseInt(dec % 2).toString()) + bin;
        dec /= 2;
    return bin;
Right(String, Length)
    if (String == null) 
        return (false); 
    var dest = ''; 
    for (var i = (String.length - 1); i >= 0; i--) 
        dest = dest + String.charAt(i); 
    String = dest; 
    String = String.substr(0, Length); 
    dest = ''; 
    for (var i = (String.length - 1); i >= 0; i--) 
        dest = dest + String.charAt(i); 
    return dest; 
【参考文章】
 JavaScript实现浮点数转十六进制
                    目录二进制转浮点数浮点数转二进制二进制转浮点数单精度binary_to_float(data){    let buf = new Uint8Array(data);    buf.reverse();    let buf32 =  new Float32Array(buf.buffer);    return buf32[0];}双精度binary_to_double(data) {    let buf = new Uint8Array(data);    buf.rever
[removed]
[removed]("整数转换函数：parseInt(数据,底数)<br>");
[removed]("10101=>" + parseInt("10101",2)+"<br>");
[removed]("77=>" + parseInt("77",8)+"<br>");
[removed]("2A3B=>" + parseInt("2A3B",16)+"<br>");
[removed]("077=>" + parseInt("0
 * @description 进制之间的相互转换
 * @param {number} base 原数据进制
 * @param {number | string} num 原数据 
 * @param {number} tobase 现数据的进制
 * @returns {string} 返回tobase进制字符串数字
const baseChange = (base, num, tobas.
				
int和float都是4字节32位表示形式。为什么float的范围大于int？
float精度为6～7位。1.66*10^10的数字结果并不是166 0000 0000 指数越大，误差越大。
这些问题，都是浮点数的存储方式造成的。 
  float和double在存储方式上都是遵从IEEE的规范的，float遵从的是IEEE R32.24 ,而double 遵从的是R6...
				
一个类型化数组（TypedArray）对象描述了一个底层的二进制数据缓冲区（binary data buffer）的一个类数组视图（view）。事实上，没有名为 TypedArray 的全局属性，也没有一个名为 TypedArray 的构造函数。相反，有许多不同的全局属性，它们的值是特定元素类型的类型化数组构造函数。
TypedArray 指的是以下的其中之一
Int8Array();
Uint8Array();
Uint8ClampedArray();
Int16Array();
Uint16Array(
二进制数组是JavaScript用来操作二进制数据的一个接口。有ArrayBuffer对象、TypedArray视图和DataView视图三个对象接口。它们可以以数组下标的形式直接操作内存，可以与操作系统的原生接口进行二进制通信。
随着Web应用程序变得越来越强大，尤其一些新增加的功能例如：音频视频编辑，访问WebSockets的原始数据等，很明显有些时候如果使用JavaScript代码可以快速方便地通过类型化数组(Typed Arrays)来操作原始的二进制数据将会非常有帮助。注意：(不要把类型
    unsigned char buf[]={0xf5,0xdd,0xd8,0xac,0x2d,0xf4,0x3e,0x40,0xf5,0xdd,0xd8,0xac,0x2d,0xf4,0x3e,0x40};
    readCharToLL(buf,sizeof(buf));
    Double value;
				
Float32Array类型数组代表的是平台字节顺序为32位的浮点数型数组(对应于 C浮点数据类型) 。如果需要控制字节顺序，使用DataView替代。其内容初始化为0。一旦建立起来，你可以使用这个对象的方法对其元素进行操作，或者使用标准数组索引语法 (使用方括号)。
语法如下：
new Float32Array(length);
new Float32Array(typedArray);
new Float32Array(object);
new Float32Array(buffer ...
				
   实习期间利用无聊的空余时间写的一个JWT的工具类，可以用于token生成，token解码，token刷新。工具类基于io.jsonwebtoken——一个jwt的生成库。
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.lang.reflect.Fie
				
在 JavaScript 中，浮点数运算存在精度问题。这是因为 JavaScript 使用 IEEE 754 标准来表示浮点数，这种标准使用二进制表示浮点数，而二进制又不能精确地表示某些十进制小数。这导致在进行简单的浮点数运算时，结果可能会出现不准确的情况。
例如，0.1 + 0.2 的结果在 JavaScript 中是 0.30000000000000004，而不是 0.3。这是因为 0.1 和 0.2 在二进制中不能精确表示。为了弥补这个问题，可以使用一些技巧来解决精度问题，例如将小数转换为整数进行计算，再将结果转换回小数，或使用第三方库来处理浮点数运算。