13.数字

98
123.45

> 98 === 98.0
true

// Binary (base 2)
assert.equal(0b11, 3);
// Octal (base 8)
assert.equal(0o10, 8);
// Decimal (base 10):
assert.equal(35, 35);
// Hexadecimal (base 16)
assert.equal(0xE7, 231);

> 35.0
35

> 3e2
300
> 3e-2
0.03
> 0.3e2
30

7.toString(); // syntax error

7.0.toString()
(7).toString()
7..toString()
7 .toString()  // space before dot

assert.equal(1 + 4, 5); // addition
assert.equal(6 - 3, 3); // subtraction
assert.equal(2 * 1.25, 2.5); // multiplication
assert.equal(6 / 4, 1.5); // division
assert.equal(6 % 4, 2); // remainder
assert.equal(2 ** 3, 8); // exponentiation

> 3 % 2
1
> -3 % 2
-1

assert.equal(+(-3), -3); // unary plus
assert.equal(-(-3), 3); // unary negation

> +'7'
7
> +'-12'
-12
> -'9'
-9

let foo = 3;
assert.equal(++foo, 4);
assert.equal(foo, 4);
let bar = 3;
assert.equal(--bar, 2);
assert.equal(bar, 2);

let foo = 3;
assert.equal(foo++, 3);
assert.equal(foo, 4);
let bar = 3;
assert.equal(bar--, 3);
assert.equal(bar, 2);

const obj = { a: 1 };
++obj.a;
assert.equal(obj.a, 2);

const arr = [ 4 ];
arr[0]++;
assert.deepEqual(arr, [5]);

• Number(value)
• +value
• parseFloat(value)（避免；与其他两个不同！）

assert.equal(Number(undefined), NaN);
assert.equal(Number(null), 0);
assert.equal(Number(false), 0);
assert.equal(Number(true), 1);
assert.equal(Number(123), 123);
assert.equal(Number(''), 0);
assert.equal(Number('123'), 123);
assert.equal(Number('xyz'), NaN);

> Number({ valueOf() { return 123 } })
123

• NaN
• Infinity

> typeof NaN
'number'

> Number('$$$')
NaN
> Number(undefined)
NaN

> Math.log(-1)
NaN
> Math.sqrt(-1)
NaN

> NaN - 3
NaN
> 7 ** NaN
NaN

const n = NaN;
assert.equal(n === n, false);

const x = NaN;
assert.equal(Number.isNaN(x), true); // preferred
assert.equal(Object.is(x, NaN), true);
assert.equal(x !== x, true);

> [NaN].indexOf(NaN)
-1

> [NaN].includes(NaN)
true
> [NaN].findIndex(x => Number.isNaN(x))
0
> [NaN].find(x => Number.isNaN(x))
NaN

> Math.pow(2, 1023)
8.98846567431158e+307
> Math.pow(2, 1024)
Infinity

> 5 / 0
Infinity
> -5 / 0
-Infinity

function findMinimum(numbers) {
  let min = Infinity;
  for (const n of numbers) {
    if (n < min) min = n;
  }
  return min;
}
assert.equal(findMinimum([5, -1, 2]), -1);
assert.equal(findMinimum([]), Infinity);

const x = Infinity;
assert.equal(x === Infinity, true);
assert.equal(Number.isFinite(x), false);

> 0.1 + 0.2
0.30000000000000004
> 1.3 * 3
3.9000000000000004
> 1.4 * 100000000000000
139999999999999.98

> 0.1 + 0.2
0.30000000000000004

(-1) ** 符号 * 0b1.小数 * 2 ** 指数

• 我们使用基数 10（十进制）代替基数 2（二进制），因为这是大多数人更熟悉的。
• 小数 是一个解释为小数的自然数（一个点后的数字）。我们切换到尾数 ，这是一个被解释为自身的整数。因此，指数的使用方式不同，但其基本作用不会改变。
• 由于尾数是一个整数（有自己的符号），我们不再需要单独的符号了。

尾数 * 10 ** 指数

• 对于整数-123，我们主要需要尾数：

  > -123 * (10 ** 0)
  - 123
  

• 对于数字1.5，我们想象尾数后面有一个点。我们使用负指数将该点向左移动一位：

  > 15 * (10 ** -1)
  1.5
  

• 对于数字0.25，我们将点向右移动两位数：

  > 25 * (10 ** -2)
  0.25
  

> 15 * (10 ** -1) === 15 / 10
true
> 25 * (10 ** -2) === 25 / 100
true

• 可以表示1/10。它已经具有所需的格式：分母是 10 的幂。
• 1/2可以表示为5/10。我们通过将分子和分母乘以 5，将分母中的 2 变为 10 的幂。
• 1/4可以表示为25/100。通过将分子和分母乘以 25，我们将分母中的 4 变为 10 的幂。
• 1/3无法表示。没有办法将分母变为 10 的幂。（10 的素数因子是 2 和 5。因此，任何只有这些素数因子的分母都可以通过使用足够的二和五乘以分子和分母，来转换为 10 的幂。如果分母有不同的素因子，那么我们无能为力。）

• 0.5 = 1/2可以用基数 2 表示，因为分母已经是 2 的幂。
• 0.25 = 1/4可以用基数 2 表示，因为分母已经是 2 的幂。
• 无法表示0.1 = 1/10，因为分母无法转换为 2 的幂。
• 无法表示0.2 = 2/10，因为分母无法转换为 2 的幂。

> 1 === 1.0
true
> Number.isInteger(1.0)
true

• Math.floor(n)：返回i ≤ n的最大整数

  > Math.floor(2.1)
  2
  > Math.floor(2.9)
  2
  

• Math.ceil(n)：返回i ≥ n的最小整数

  > Math.ceil(2.1)
  3
  > Math.ceil(2.9)
  3
  

• Math.round(n)：返回“最接近”n的整数。0.5 向上舍入。例如：

  > Math.round(2.4)
  2
  > Math.round(2.5)
  3
  

• Math.trunc(n)：删除n具有的任何小数部分（在小数点之后），因此将其转换为整数。

  > Math.trunc(2.1)
  2
  > Math.trunc(2.9)
  2
  

• 安全整数： 可以通过 JavaScript“安全地”表示（意味着什么后面会讲更多）
  • 精度：53 位带符号
  • 范围：(-2 ** 53 ~ 2 ** 53)
• 数组索引
  • 精度：32 位，无符号
  • 范围：[0, 2 ** 32 - 1)（不包括最大长度）
  • 类型数组有更大的 53 位范围（安全和无符号）
• 按位操作数 （按位或，等等）
  • 精度：32 位
  • 无符号右移范围（>>>）：无符号，[0, 2 ** 32)
  • 所有其他按位运算符的范围：有符号，[-2 ** 31, 2 ** 31)

[-2 ** 53 - 1, 2 ** 53 - 1]

> 18014398509481984
18014398509481984
> 18014398509481985
18014398509481984
> 18014398509481986
18014398509481984
> 18014398509481987
18014398509481988

assert.equal(Number.MAX_SAFE_INTEGER, (2 ** 53) - 1);
assert.equal(Number.MIN_SAFE_INTEGER, -Number.MAX_SAFE_INTEGER);
assert.equal(Number.isSafeInteger(5), true);
assert.equal(Number.isSafeInteger('5'), false);
assert.equal(Number.isSafeInteger(5.1), false);
assert.equal(Number.isSafeInteger(Number.MAX_SAFE_INTEGER), true);
assert.equal(Number.isSafeInteger(Number.MAX_SAFE_INTEGER+1), false);

> 9007199254740990 + 3
9007199254740992

> 9007199254740995 - 10
9007199254740986

isSafeInteger(a) && isSafeInteger(b) && isSafeInteger(a op b)

• 首先，操作数转换为数字（64 位双浮点数），然后转换为 32 位整数。
• 然后执行按位操作。
• 最后，结果将转换回双精度并返回。

• 无符号右移运算符（>>>）：32 位，范围[0, 2 ** 32)
• 所有其他按位运算符：32 位包括符号，范围[-2 ** 31, 2 ** 31)

assert.equal(
  b32(-1),
  '11111111111111111111111111111111');
assert.equal(
  b32(1),
  '00000000000000000000000000000001');
assert.equal(
  b32(2 ** 31),
  '10000000000000000000000000000000');

> (0b1010 & 0b11).toString(2).padStart(4, '0')
'0010'
> (0b1010 | 0b11).toString(2).padStart(4, '0')
'1011'
> (0b1010 ^ 0b11).toString(2).padStart(4, '0')
'1001'

> b32(~0b100)
'11111111111111111111111111111011'

> (0b10 << 1).toString(2)
'100'

> b32(0b10000000000000000000000000000010 >> 1)
'11000000000000000000000000000001'
> b32(0b10000000000000000000000000000010 >>> 1)
'01000000000000000000000000000001'

/**
 * Return a string representing n as a 32-bit unsigned integer,
 * in binary notation.
 */
function b32(n) {
  // >>> ensures highest bit isn’t interpreted as a sign
  return (n >>> 0).toString(2).padStart(32, '0');
}
assert.equal(
  b32(6),
  '00000000000000000000000000000110');

> 12 >>> 0
12
> -12 >>> 0
4294967284
> (2**32 + 1) >>> 0
1

• 二元算术运算符（表 11）
• 前缀和后缀算术运算符（表 12）

• 按位和，或，异或，非（表 13）
• 移位运算符（表 14）

• 无符号右移运算符（>>>）：32 位，范围[0, 2 ** 32)
• 所有其他按位运算符：32 位带符号，范围[-2 ** 31, 2 ** 31)

• isFinite()
• isNaN()
• parseFloat()
• parseInt()

• .EPSILON: number ^[ES6]^ 1 和下一个可表示的浮点数之间的差异。通常，机器的 epsilon 为浮点运算中的舍入误差提供上限。
  • 大约为：2.2204460492503130808472633361816 * 10 ** (-16)
• .MAX_SAFE_INTEGER: number ^[ES6]^ JavaScript 可以明确表示的最大整数（2 ** 53 - 1）。
• .MAX_VALUE: number ^[ES1]^ 最大的正有限 JavaScript 数。
  • 大约为：1.7976931348623157 * 10 ** 308
• .MIN_SAFE_INTEGER: number ^[ES6]^ JavaScript 可以明确表示的最小整数（-2 ** 53 + 1）。
• .MIN_VALUE: number ^[ES1]^ 最小的 JavaScript 正数。大约5 * 10 ** -324。
• .NaN: number ^[ES1]^ 与全局变量NaN相同。
• .NEGATIVE_INFINITY: number ^[ES1]^ 与-Number.POSITIVE_INFINITY相同。
• .POSITIVE_INFINITY: number ^[ES1]^ 与全局变量Infinity相同。

• .isFinite(num: number): boolean ^[ES6]^ 如果num是实际数字（不是Infinity，-Infinity和NaN），则返回true。

  > Number.isFinite(Infinity)
  false
  > Number.isFinite(-Infinity)
  false
  > Number.isFinite(NaN)
  false
  > Number.isFinite(123)
  true
  

• .isInteger(num: number): boolean ^[ES6]^ 如果num是一个数字并且没有小数部分，则返回true。

  > Number.isInteger(-17)
  true
  > Number.isInteger(33)
  true
  > Number.isInteger(33.1)
  false
  > Number.isInteger('33')
  false
  > Number.isInteger(NaN)
  false
  > Number.isInteger(Infinity)
  false
  

• .isNaN(num: number): boolean ^[ES6]^ 如果num是值NaN，则返回true：

  > Number.isNaN(NaN)
  true
  > Number.isNaN(123)
  false
  > Number.isNaN('abc')
  false
  

• .isSafeInteger(num: number): boolean ^[ES6]^ 如果num是一个数字并且明确表示一个整数，则返回true。
• .parseFloat(str: string): number ^[ES6]^ 将其参数强制转换为字符串并将其解析为浮点数。为了将字符串转换为数字，Number()（忽略前导和尾随空格）通常是比Number.parseFloat()更好的选择（它忽略前导空格和非法尾随字符并且可以隐藏问题）。

  > Number.parseFloat(' 123.4#')
  123.4
  > Number(' 123.4#')
  NaN
  

• .parseInt(str: string, radix=10): number ^[ES6]^ 将其参数强制转换为字符串并将其解析为整数，忽略前导空格和非法尾随字符：

  > Number.parseInt('  123#')
  123
  

  参数radix指定要解析的数字的基数：

  > Number.parseInt('101', 2)
  5
  > Number.parseInt('FF', 16)
  255
  

  不要使用此方法将数字转换为整数：强制转换为字符串是低效的。并且在第一个非数字之前停止，不是用于移除数字的小数的良好算法。这是一个出错的例子：

  > Number.parseInt(1e21, 10) // wrong
  1
  

  最好使用Math的一个舍入函数将数字转换为整数：

  > Math.trunc(1e21) // correct
  1e+21
  

• .toExponential(fractionDigits?: number): string ^[ES3]^ 返回一个字符串，该字符串通过指数表示法表示数字。使用fractionDigits，您可以指定与指数相乘的数字的位数（默认值是根据需要显示位数）。 示例：数字太小而无法通过.toString()获得正指数。

  > 1234..toString()
  '1234'
  > 1234..toExponential()
  '1.234e+3'
  > 1234..toExponential(5)
  '1.23400e+3'
  

  示例：数字太小而无法通过.toString()得到负指数。

  > 0.003.toString()
  '0.003'
  > 0.003.toExponential()
  '3e-3'
  > 0.003.toExponential(4)
  '3.0000e-3'
  

• .toFixed(fractionDigits=0): string ^[ES3]^ 返回数字的无指数表示，舍入为fractionDigits个数字。

  > 0.0000003.toString()
  '3e-7'
  > 0.0000003.toFixed(10)
  '0.0000003000'
  > 0.0000003.toFixed()
  '0'
  

  如果数字为10 ** 21 或更高，则.toFixed()使用指数：

  > (10 ** 21).toFixed()
  '1e+21'
  

• .toPrecision(precision?: number): string ^[ES3]^ 像.toString()一样工作，但在返回结果之前将尾数修剪为数字precision。如果缺少precision，则使用.toString()。

  > 1234..toPrecision(3)  // requires exponential notation
  '1.23e+3'
  > 1234..toPrecision(4)
  '1234'
  > 1234..toPrecision(5)
  '1234.0'
  > 1.234.toPrecision(3)
  '1.23'
  

• .toString(radix=10): string ^[ES1]^ 返回数字的字符串表示形式。 返回基数为 10 的结果：

  > 123.456.toString()
  '123.456'
  

  使用 10 以外的基数返回结果（通过radix指定）：

  > 4..toString(2)
  '100'
  > 4.5.toString(2)
  '100.1'
  > 255..toString(16)
  'ff'
  > 255.66796875.toString(16)
  'ff.ab'
  > 1234567890..toString(36)
  'kf12oi'
  

  您可以使用parseInt()将整数结果转换回数字：

  > parseInt('kf12oi', 36)
  1234567890
  

• 维基百科
• TypeScript 的内置类型
• JavaScript 的 MDN 网络文档
• ECMAScript 语言规范