你对Number一无所知

时间  2019-12-08
标签 number 一无所知 繁體版
原文   原文链接

二进制表示小数

例如用二进制表示 0.8125javascript

0.8125
0.8125*2 = 1.625 取整为 1
0.625*2=1.25 取整为 1
0.25*2=0.5 取整为 0
0.5*2=1 取整为 1
如果 *2 始终没法获得 1，就一直到位数用完，这也是浮点数并不精确的缘由
即 0.8125 的二进制表示是 0.1101
即 0.8125 = 2^-1*1+2^-2*1+2^-3*0+2^-4*1
即 0.8125 = 0.5 + 0.25 + 0.0625

因此 0.1 到 0.9 的 9 个小数中，只有 0.5 能够用二进制精确表示html

浮点数与定点数

在 JS 中，全部的数字都是基于 IEEE 754 的浮点数。除了浮点数，还有定点数，二者的区别就在于小数点的处理。一样是用64个bit表示一个数，定点数会用前 N 位来表示一个数的整数部分，用后 64 - N 来表示一个数的小数部分，这个 N 是固定的，对全部的数都是同样的。java

64位浮点数

对于64位的浮点数，最高的1位是符号位 S，接着是11位的指数 E，剩下的52位为有效数字 Mgit

bg2010060602

S，Sign（1bit）：表示浮点数是正数仍是负数。0表示正数，1表示负数。程序员

E，Exponent（11bit）：指数部分。相似于科学记数法的 M*10^N 中的 N，只不过不是以10为底，而是以2为底。E是一个无符号整数，由于长度是11位，取值范围是 0~2047。可是科学计数法中的指数是能够为负数的，因此再减去一个中间数 1023，[0,1022]表示为负，[1024,2047] 表示为正github

M，Mantissa（52bit）：基数部分。浮点数具体数值的实际表示。小程序

因此计算机将 5.8125 存储为浮点数的过程以下app

  1. 用二进制表示5.8125，获得 101.1101
  2. 用相似科学计数法表示二进制数 101.1101，获得 1.011101 * 2 ^ 2
  3. 偏移指数部分，在 5.8125 中，指数为2，是正数，但实际上指数也可能为负数，例如若是是0.8125，指数就为-1了。11位的指数部分，为了包括负数，全部须要偏移 2^10-1，即 1023。因此指数偏移后为1025=2+1023，用二进制表示 10000000001
  4. 处理整数部分，用相似科学计数法表示二进制数后，小数点前面总为1，能够将这个1忽略，这样能够增长表示数的范围

综上，5.8125 在计算机中的存储形式 0(1位) + 0111,1111,111(11位) + 011101(6位) +0…0(46位)工具

M部分是二进制表示数，E控制小数点的位置，S控制数的正负测试

如今开始解释 Number 中的一些事

JS 中全部的数字都是浮点数，64位浮点数能准确表示的实数是有限的，例如以前提到， 0.1 到 0.9 的 9 个小数中，只有 0.5 能够用浮点数准确表示

687474703a2f2f617461322d696d672e636e2d68616e677a686f752e696d672d7075622e616c6979756e2d696e632e636f6d2f65656539613263613238646433643865366630663563383939353661623433612e6a7067

盗图来源JavaScript浮点数陷阱及解法

也由于 JS 中全部的数字都是以浮点数的形式保存的，因此数字后面的“.”会被看成小数点来处理

因此有

var a = 0.42;        // 0.42
var b = .42;        // 0.42
42.toFixed( 3 );    // SyntaxError
(42).toFixed( 3 );    // "42.000"
0.42.toFixed( 3 );    // "0.420"
42..toFixed( 3 );    // "42.000"

Number.MAX_VALUE 是如何得来的

64位浮点数，M部分最大为52个1 + 被忽略的1，E部分最大为 2046-1023 = 1023，

为何不是 2047-1023 = 1024，由于这个1024要用来表示Infinity

因此最大的二进制数位 1.1111…1(小数点后面52个1) * 2 ^ 1023

在计算机中存储形态为 0 | 111 1111 1110 | 111111...111(52个1)

let sum = 0
for (let i = 0; i < 53; i++) {
    sum = sum + Math.pow(2, 1023 - i)
    console.log(sum)
}
sum // 1.7976931348623157e+308
Number.MAX_VALUE // 1.7976931348623157e+308
// 若是把代码改为 i < 53，获得 1.7976931348623155e+308

Number.MIN_VALUE 是如何得来的

这个值是 最接近0且大于0的，且是精确表示的数

64位浮点数，M部分最小为0 + 被忽略的1，E部分最小为 0-1023 = -1023，

1*2^-1023，即二进制 0.00…001(1以前有1023个0)

Math.pow(2, -1023) // 1.1125369292536007e-308
Number.MIN_VALUE // 5e-324

嗯？WHY？

“若是浮点数的指数部分的编码值是0，尾数为非零，那么这个浮点数将被称为非规约形式的浮点数。IEEE 754标准规定：非规约形式的浮点数的指数偏移值比规约形式的浮点数的指数偏移值大1.例如，最小的规约形式的单精度浮点数的指数部分编码值为1，指数的实际值为-126；而非规约的单精度浮点数的指数域编码值为0，对应的指数实际值也是-126而不是-127。实际上非规约形式的浮点数仍然是有效可使用的，只是它们的绝对值已经小于全部的规约浮点数的绝对值；即全部的非规约浮点数比规约浮点数更接近0。规约浮点数的尾数大于等于1且小于2，而非规约浮点数的尾数小于1且大于0.

...

除了规约浮点数，IEEE754-1985标准采用非规约浮点数，用来解决填补绝对值意义下最小规格数与零的距离。（举例说，正数下，最大的非规格数等于最小的规格数。而一个浮点数编码中，若是exponent=0，且尾数部分不为零，那么就按照非规约浮点数来解析）非规约浮点数源于70年代末IEEE浮点数标准化专业技术委员会酝酿浮点数二进制标准时，Intel公司对渐进式下溢出（gradual underflow）的力荐。当时十分流行的DEC VAX机的浮点数表示采用了忽然式下溢出（abrupt underflow）。若是没有渐进式下溢出，那么0与绝对值最小的浮点数之间的距离（gap）将大于相邻的小浮点数之间的距离。例如单精度浮点数的绝对值最小的规约浮点数是1.0times 2^{{-126}},它与绝对值次小的规约浮点数之间的距离为2^{{-126}}times 2^{{-23}}=2^{{-149}}。若是不采用渐进式下溢出，那么绝对值最小的规约浮点数与0的距离是相邻的小浮点数之间距离的2^{{23}}倍！能够说是很是忽然的下溢出到0。这种状况的一种糟糕后果是：两个不等的小浮点数X与Y相减，结果将是0.训练有素的数值分析人员可能会适应这种限制状况，但对于普通的程序员就很容易陷入错误了。采用了渐进式下溢出后将不会出现这种状况。例如对于单精度浮点数，指数部分实际最小值是（-126），对应的尾数部分从1.1111ldots 11,1.1111ldots 10一直到0.0000ldots 10, 0.0000ldots 01，0.0000ldots 00相邻两小浮点数之间的距离（gap）都是2^{{-126}}times 2^{{-23}}=2^{{-149}}；而与0最近的浮点数（即最小的非规约数）也是2^{{-126}}times 2^{{-23}}=2^{{-149}}。“

以上文字来源非规约形式的浮点数

总结来讲，规定当浮点数的指数为容许的最小指数值，尾数没必要是规范化的。

M部分最小为51个0和1个1

因此最小二进制数，0.00….001(小数点后面51个0)*2^-1022，即二进制0.00..001(1以前有52+1022个0)

Math.pow(2, -1074) // 5e-324

Number.MAX_SAFE_INTEGER

从 Number.MIN_SAFE_INTEGER 到 Number.MAX_SAFE_INTEGER 之间连续的整数都是能够准确表示的

E为52，算上偏移+1023，为1075，用二进制表示 10000110011

M为52个1，算上默认的1，为1.11….1(小数点后面52个1)

在计算机中存储形态为 0 | 100 0011 0011 | 111111...111(52个1)

总体来看就是 1.11…1(小数点后面52个1)*2^52，即 53个1

let sum = 0
for (let i = 0; i < 53; i++) {
    sum = sum + Math.pow(2, i)
}
sum // 9007199254740991
Number.MAX_SAFE_INTEGER // 9007199254740991

Number.MIN_SAFE_INTEGER

将 S 位表示为1

在计算机中存储形态为 1 | 100 0011 0011 | 111111...111(52个1)

0.1 + 0.2 === 0.3 // false

0.1 转成二进制 0.000110011001100...

即 1.1001100 * 2^-4

指数位偏移 1019 = -4+1023，用二进制表示 1111 1110 11

0.1 在计算机中存储形态 0 | 011 1111 1011|1001 1001 1001 1001 1001(12个1001) 1010

最后四位不是 1001 而是 1010，是考虑到 1001的下一位是1，故进一位

再将其转换成二进制 1.1001 1001 1001(12个1001)1010 * 2^-4

其实呢

0.1.toString(2) // "0.0001100110011001100110011001100110011001100110011001101"

0.2 转成二进制 0.0011001100110011...

即 1.1001 1001…*2^-3

指数位偏移 1020 = -3+1023，用二进制表示 1111 1111 00

0.2 在计算机中存储形态 0 | 011 1111 1100 | 1001 1001 1001 1001 1001(12个1001) 1010

最后四位不是 1001 而是 1010，是考虑到 1001的下一位是1，故进一位

再将其转换成二进制 1.1001 1001 1001(12个1001) 1010 *2^-3

0.2.toString(2) // "0.001100110011001100110011001100110011001100110011001101"

将这两个二进制数相加

写个小程序计算一下

function addBinary(a, b) {
    let aStr = a,
        bStr = b
    let addLength = aStr.length - bStr.length
    if (addLength > 0) {
        bStr = bStr + '0'.repeat(addLength)
    } else if (addLength < 0) {
        aStr = aStr + '0'.repeat(-addLength)
    }
    let addFlag = 0
    let arr1 = [...aStr]
    let arr2 = [...bStr]
    let length = arr1.length
    let arr3 = []
    for (let i = 0; i < length; i++) {
        let el1 = arr1.pop()
        let el2 = arr2.pop()
        if (el1 * 1 + el2 * 1 === 0) {
            arr3.unshift(addFlag)
            addFlag = 0
        } else if (el1 * 1 + el2 * 1 === 1) {
            if (addFlag === 1) {
                arr3.unshift(0)
                addFlag = 1
            } else {
                arr3.unshift(1)
                addFlag = 0
            }
        } else if (el1 * 1 + el2 * 1 === 2) {
            arr3.unshift(addFlag)
            addFlag = 1
        }
    }
    return arr3.join('')
}
// 参数a,b 为小数后面的部分
addBinary('0001100110011001100110011001100110011001100110011001101','001100110011001100110011001100110011001100110011001101')
// 0100110011001100110011001100110011001100110011001100111

加上整数部分，获得 0.0100110011001100110011001100110011001100110011001100111

将其转换为实数

function convertBinary(a) {
    return [...a].reduce((acc, cur, i) => {
        acc = acc + cur * Math.pow(2, -1 * (i + 1))
        return acc
    }, 0)
}
// 参数a 依然为小数后面的部分
convertBinary('0100110011001100110011001100110011001100110011001100111')
// 0.30000000000000004

Number.EPSILON

if (!Number.EPSILON) {
    Number.EPSILON = Math.pow(2,-52);
}

用 Number.EPSILON（容差） 来比较两个 number 的等价性

The value of Number.EPSILON is the difference between 1 and the smallest value greater than 1 that is representable as a Number value, which is approximately 2.2204460492503130808472633361816 x 10‍−‍16.

根据ECMASCRIPT-262定义 Number.EPSILON 是大于1的最小可表示数与1的差

function numbersCloseEnoughToEqual(n1,n2) {
    return Math.abs( n1 - n2 ) < Number.EPSILON;
}

var a = 0.1 + 0.2;
var b = 0.3;

numbersCloseEnoughToEqual( a, b );                    // true
numbersCloseEnoughToEqual( 0.0000001, 0.0000002 );    // false

Infinity, a + 1 === a

根据 IEEE 754

形式 指数 小数部分
0 0 0
非规约形式 0 非0
规约形式 1到2^e-2 任意
∞ 2^e-1 0
NaN 2^e-1 非0
  1. 若是指数是0而且尾数的小数部分是0，这个数±0（和符号位相关）
  2. 若是指数 =2^{{e}}-1而且尾数的小数部分是0，这个数是±∞（一样和符号位相关）
  3. 若是指数 = 2^{{e}}-1而且尾数的小数部分非0，这个数表示为不是一个数（NaN） 
var a = Number.MAX_VALUE;    // 1.7976931348623157e+308
a + 1 === a;                // true
a + a;                        // Infinity
a + Math.pow( 2, 970 );        // Infinity
a + Math.pow( 2, 969 );        // 1.7976931348623157e+308

据 IEEE 754

Infinity 中 E的二进制表示为 111 1111 1111，M为1(默认) + 52个0

Infinity 在计算机中存储形态 0 | 111 1111 1111 | 0000(52个0)

Math.pow(2, 1024) // Infinity
Math.pow(2, 1023) + Math.pow(2, 1022) + ... + Math.pow(2, 971) // 1.7976931348623157e+308

能够看到 Infinity 和 Number.MAX_VALUE 之间相差 Math.pow(2, 971)

Untitled Diagram

IEEE 754 “就近舍入”，Number.MAX_VALUE + Math.pow( 2, 969 ) 比起 Infinity 更接近于 Number.MAX_VALUE，因此它“向下舍入”，而 Number.MAX_VALUE + Math.pow( 2, 970 ) 距离 Infinity 更近，因此它“向上舍入”。

再个人理解看来，凡是大于等于 Number.MAX_VALUE + Math.pow( 2, 970 ) 的数字都用 Infinity 来存储

存储形态都是 0 | 111 1111 1111 | 0000(52个0)

Number.MAX_VALUE + Math.pow(2,971) === Number.MAX_VALUE + Math.pow(2,972) // true

NaN

首先 typeof NaN 返回 number，NaN表示不是数字的数字

NaN 为数字表现为它来源于数学计算，

NaN 不是数字表现为计算过程当中的参数并不符合要求，致使计算结果不是数字

"foo"/"foo" // NaN
1 * "fp" // NaN
1 / 0    // Infinity
0 / 0    // NaN
Infinity / Infinity // NaN
Infinity / 1 // Infinity
Infinity / 0 // Infinity

如何判断一个数值是 NaN

  • typeof n === "number" && window.isNaN(n)

  • n !== n

    • 在整个语言中 NaN 是惟一一个本身与本身不相等的值
  • Number.isNaN(n)

0 & -0

Object.is(0, -0);            // false
Object.is(-0, -0);           // true
Object.is(NaN, 0/0);         // true
function fakeIs(v1, v2) {
    // 测试 `-0`
    if (v1 === 0 && v2 === 0) {
        return 1 / v1 === 1 / v2;
    }
    // 测试 `NaN`
    if (v1 !== v1) {
        return v2 !== v2;
    }
    // 其余状况
    return v1 === v2;
}

Number 的方法

  • numObj.toExponential(fractionDigits)

    • fractionDigits 规定了小数位的位数
    • 以指数形式展示数字，科学计数法

  • numObj.toFixed(digits)

    • digits 规定了小数位的位数，不足用 0 填充
    • 固定小数位数

  • numObj.toPrecision(precision)

    • precision 规定了整数位+小数位的位数
    • 以固定精度返回数字

参考博客

工具网站

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程