在JavaScript中将十六进制转换为浮点

我想把以10为基数的分数转换成以16为基数的数字

var myno = 28.5;

var convno = myno.toString(16);
alert(convno);

一切都很好。现在我想把它转换回十进制

但现在我不能写：

var orgno = parseInt(convno, 16);
alert(orgno);

因为它不返回小数部分

我不能使用parseFloat，因为根据MDC，parseFloat的语法是

parseFloat(str);

如果我必须转换回int，这不会是一个问题，因为parseInt的语法是

parseInt(str [, radix]);

那么，有什么替代方案呢

免责声明：我认为这是一个微不足道的问题，但谷歌没有给我任何答案

---

让我问了上面的问题。

试试这个：

决定小数点后需要多少位精度

将原始数字乘以16的幂（例如，如果需要两位数，则为256）

将其转换为整数

根据步骤1中的决定手动输入小数点

反向执行步骤以转换回

去掉小数点，记住它在哪里

将十六进制转换为整数形式的十进制

将结果除以16的适当幂（16^n，其中n是在步骤1中取出的小数点后的位数）

一个简单的例子：

将小数点23.5转换为十六进制，转换后小数点后需要一位数字

23.5x16=376

转换为十六进制=0x178

以16:17.8为基数回答

现在转换回十进制：

去掉小数点：0x178

转换为十进制：376

---

除以16:23.5

另一种可能是分别解析数字，将字符串一分为二，并在转换过程中将这两部分视为整数，然后将它们重新相加

函数parseFloat（str，基数）
{
var parts=str.split（“.”）；
如果（零件长度>1）
{
返回parseInt（部分[0]，基数）+parseInt（部分[1]，基数）/Math.pow（基数，部分[1].length）；
}
返回parseInt（部分[0]，基数）；
}
var-myno=28.4382；
var convno=myno.toString（16）；
var f=parseFloat（convno，16）；
console.log（myno+“->”+convno+“->”+f）请尝试以下操作：

function hex2dec(hex) {
    hex = hex.split(/\./);
    var len = hex[1].length;
    hex[1] = parseInt(hex[1], 16);
    hex[1] *= Math.pow(16, -len);
    return parseInt(hex[0], 16) + hex[1];
}


函数hex2dec（hex）{
十六进制=十六进制分割（/\./）；
var len=hex[1]。长度；
十六进制[1]=parseInt（十六进制[1]，16）；
十六进制[1]*=数学功率（16，-len）；
返回parseInt（十六进制[0]，十六进制）+十六进制[1]；
}
// ----------
//试验
// ----------
函数计算（十六进制）{
设dec=hex2dec（hex）；
msg.innerHTML=`dec:${dec}
十六进制测试：${dec.toString（16）}`
} 
让init=“bad.a55”；
inp.value=init；
计算（初始）
我组合并生成了一个重载的parseFloat函数，该函数以一个参数作为基数（更简单、更通用）：

我不确定你想在那里解析什么十六进制格式。这像是“a1.2c”吗

浮点数通常使用十六进制格式存储。该标准不使用任何点（在纯十六进制字母表中不存在）。取而代之的是三组预定义长度的位（1+8+23=总共32位）─ double使用64位）

我编写了以下函数，用于将此类数字解析为浮点：

function hex2float(num) {
    var sign = (num & 0x80000000) ? -1 : 1;
    var exponent = ((num >> 23) & 0xff) - 127;
    var mantissa = 1 + ((num & 0x7fffff) / 0x7fffff);
    return sign * mantissa * Math.pow(2, exponent);
}

试试这个

字符串可以是包含四个字符（0-255）的原始数据（简单文本）或
十六进制字符串“0xFFFFFF”长度为四个字节


var str='0x3F160008'；
函数parseFloat（str）{
var float=0，符号，顺序，尾数，exp，
int=0，multi=1；
如果（/^0x/.exec（str））{
int=parseInt（str，16）；
}
否则{
对于（变量i=str.length-1；i>=0；i-=1）{
如果（str.charCodeAt（i）>255）{
log（'错误的字符串参数'）；
返回false；
}
int+=str.charCodeAt（i）*multi；
多重*=256；
}
}
符号=（int>>>31）？-1:1；
exp=（int>>>23&0xff）-127；
尾数=（（int&0x7fffff）+0x800000）；
对于（i=0；i，以下是尺寸改进：


函数hex2dec（hex）{
设h=十六进制分裂（/\./）；
返回（'0x'+h[1]）*（16**-h[1]。长度）+（'0x'+h[0]）；
}
函数计算（十六进制）{
设dec=hex2dec（hex）；
msg.innerHTML=`dec:${dec}
十六进制测试：${dec.toString（16）}`
} 
让init=“bad.a55”；
inp.value=init；
计算（初始）；
在我看到这个问题后，我实际上只是想弄明白这一点。谢谢kent。我宁愿调用parseFloat以外的函数。但无论如何，这是一个重载：）如果“parts[0]”是空字符串，不要忘了将整数部分默认为0。例如，在解析“.0f”时。请参见下面Kevin的答案。为了转换以10为基数的数字，您不需要解析十六进制格式。您没有回答运算，而是回答“反向”问题。在javascript中也不起作用，因为二进制运算符在执行运算之前将其两个参数都转换为整数。因此，在上面，您正在对整数p进行运算“num”的艺术，而不是在IEEE754表示上。它不起作用的另一个原因是JS使用64位双精度而不是32位浮点。如果您真的想在IEEE754表示上操作，您可以使用ByteArray编写双精度/浮点并读回底层字节。没有使用哪个变量
顺序
。为什么？
function hex2float(num) {
    var sign = (num & 0x80000000) ? -1 : 1;
    var exponent = ((num >> 23) & 0xff) - 127;
    var mantissa = 1 + ((num & 0x7fffff) / 0x7fffff);
    return sign * mantissa * Math.pow(2, exponent);
}

var str = '0x3F160008';

function parseFloat(str) {
    var float = 0, sign, order, mantissa, exp,
    int = 0, multi = 1;
    if (/^0x/.exec(str)) {
        int = parseInt(str, 16);
    }
    else {
        for (var i = str.length -1; i >=0; i -= 1) {
            if (str.charCodeAt(i) > 255) {
                console.log('Wrong string parameter');
                return false;
            }
            int += str.charCodeAt(i) * multi;
            multi *= 256;
        }
    }
    sign = (int >>> 31) ? -1 : 1;
    exp = (int >>> 23 & 0xff) - 127;
    mantissa = ((int & 0x7fffff) + 0x800000).toString(2);
    for (i=0; i<mantissa.length; i+=1) {
        float += parseInt(mantissa[i]) ? Math.pow(2, exp) : 0;
        exp--;
    }
    return float*sign;
}

function hex2dec(hex) {
  let h = hex.split(/\./);
  return ('0x'+h[1])*(16**-h[1].length)+ +('0x'+h[0]);
}