Number

[TOC]

索引

~~静态属性~~：

Number.MAX_VALUE：1.7976931348623157e+308，JS 能表示的最大正数。
Number.MIN_VALUE：5e-324，JS 能表示的最小正数（最接近0的值）。
Number.MAX_SAFE_INTEGER：9007199254740991，最大安全整数（2⁵³ - 1）。
Number.MIN_SAFE_INTEGER：-9007199254740991，最小安全整数。

~~静态方法~~：

Number.parseInt()：(string, radix?)，ES2015，用于将字符串转换为整数的核心方法。是全局 parseInt() 函数的标准化版本。ES6 将其添加到 Number 对象中，以提高代码的模块化和可读性。
Number.parseFloat()：(str)，ES2015，用于将字符串转换为浮点数的标准方法，是全局 parseFloat() 函数的标准化版本。ES6 将其添加到 Number 对象中，以提高代码的模块化和一致性。
Number.isFinite()：(value)，ES2015，用于精确检测有限数值的方法。替代全局isFinite()。
Number.isInteger()：(value)，ES2015，用于检测一个值是否为整数的方法。
Number.isNaN()：(value)，ES2015，用于精确检测 NaN（Not-a-Number）值的方法。

方法：

number.toString()：(radix?)，用于将数字转换为字符串的核心方法。它提供了不同进制的转换和格式化选项。
number.toFixed()：(digits?)，用于数字格式化的核心方法，它将数字转换为字符串表示，并保留指定的小数位数。

Number

静态属性

Number.MAX_VALUE：1.7976931348623157e+308，JS 能表示的最大正数。
Number.MIN_VALUE：5e-324，JS 能表示的最小正数（最接近0的值）。
Number.MAX_SAFE_INTEGER：9007199254740991，最大安全整数（2⁵³ - 1）。
Number.MIN_SAFE_INTEGER：-9007199254740991，最小安全整数。

静态方法

parseInt()@

Number.parseInt()：(string, radix?)，ES2015，用于将字符串转换为整数的核心方法。是全局 parseInt() 函数的标准化版本。ES6 将其添加到 Number 对象中，以提高代码的模块化和可读性。

string：string，要解析的字符串。字符串处理：
- 忽略字符串开头的空白字符。
- 遇到无效字符停止解析。
- 空字符串返回 NaN。
radix?：number，默认：10，进制基数（2-36）。特殊值处理：
- 超出范围：如果 radix < 2 或 radix > 36，返回 NaN。
- 非整数：小数会被向下取整。
- null/undefined：被视为无参数，取默认值。
返回：
result：number，解析成功的整数；无法解析时返回 NaN。

~~核心特性~~：

对比全局 parseInt()：
Number.parseInt() 与全局 parseInt() 完全相同：
js
```
Number.parseInt === parseInt; // true
```
1
ES6 添加 Number.parseInt() 是为了：
1. 模块化：减少全局函数数量。
2. 明确性：明确属于数字处理功能。
3. 一致性：与 Number.parseFloat() 配对。

示例：

基本用法：

// 基本值
Number.parseInt("123");      // 123
Number.parseInt("123.45");   // 123（忽略小数部分）
Number.parseInt("  42  ");   // 42（忽略空格）

// 边界值
Number.parseInt("");         // NaN
Number.parseInt("abc");      // NaN
Number.parseInt("123abc");   // 123（部分解析）
Number.parseInt("10", 1);    // NaN（无效基数）

// 特殊数值
Number.parseInt(Infinity);   // NaN
Number.parseInt(null);       // NaN
Number.parseInt(undefined);  // NaN
Number.parseInt(true);       // NaN

指定进制转换：

// 二进制
Number.parseInt("1010", 2);  // 10

// 八进制
Number.parseInt("12", 8);    // 10

// 十六进制
Number.parseInt("FF", 16);   // 255

// 三十二进制
Number.parseInt("100", 32);  // 1024

parseFloat()@

Number.parseFloat()：(str)，ES2015，用于将字符串转换为浮点数的标准方法，是全局 parseFloat() 函数的标准化版本。ES6 将其添加到 Number 对象中，以提高代码的模块化和一致性。

str：string，要解析的字符串。字符串处理：
- 忽略开头的空白字符。
- 遇到无效字符停止解析。
- 空字符串返回 NaN。
- 支持科学计数法（e/E）。
返回：
result：number，解析成功的浮点数；无法解析时返回 NaN。

~~核心特性~~：

对比全局 parseFloat()：
Number.parseFloat() 与全局 parseFloat() 完全相同：
js
```
Number.parseFloat === parseFloat; // true
```
1
ES6 添加 Number.parseFloat() 是为了：
1. 模块化：减少全局函数数量。
2. 明确性：明确属于数字处理功能。
3. 一致性：与 Number.parseInt() 配对。

示例：

基本用法：

Number.parseFloat("3.14");      // 3.14
Number.parseFloat("123");       // 123
Number.parseFloat("  42.5  ");  // 42.5（忽略空格）

// 小数和整数处理
Number.parseFloat("0.123");     // 0.123
Number.parseFloat(".456");      // 0.456
Number.parseFloat("100.");      // 100

// 边界值
Number.parseFloat("");          // NaN
Number.parseFloat("abc");       // NaN
Number.parseFloat("123.45abc"); // 123.45
Number.parseFloat("abc123");    // NaN

// 特殊值
Number.parseFloat(Infinity);   // NaN
Number.parseFloat(null);       // NaN
Number.parseFloat(undefined);  // NaN
Number.parseFloat(true);       // NaN
Number.parseFloat([]);         // NaN
Number.parseFloat([12.3]);     // 12.3（数组转字符串"12.3"）

~~进阶扩展~~：

NaN 处理：

问题：返回值为NaN时，无法比较

const result = Number.parseFloat("abc");
console.log(result === result); // false（NaN 不等于自身）

解决方案：使用 Number.isNaN() 检测

function safeParse(str) {
  const num = Number.parseFloat(str);
  return isNaN(num) ? 0 : num;
}

isFinite()

Number.isFinite()：(value)，ES2015，用于精确检测有限数值的方法。替代全局isFinite()。

value：any，要检测的值。
返回：
isFinite：boolean，返回值内容：
- true：当值是数值类型且为有限数（非 Infinity、-Infinity、NaN）。
- false：其他所有情况。

~~核心特性~~：

对比全局 isFinite()：

不会对参数进行类型转换。

// 全局 isFinite()：会转换类型
isFinite(42);         // true
isFinite("42");       // true（字符串被转换为数字）
isFinite(null);       // true（null 被转换为 0）
isFinite("");         // true（空字符串被转换为 0）
isFinite("  ");       // true（空白字符串被转换为 0）
isFinite(true);       // true（true 被转换为 1）
isFinite([]);         // true（空数组被转换为 0）
isFinite([42]);       // true（单元素数组被转换为 42）

// Number.isFinite()：不会转换类型
Number.isFinite(42);   // tru
Number.isFinite("42"); // false（不转换类型）
Number.isFinite(null); // false
Number.isFinite("");   // false
Number.isFinite(true); // false
Number.isFinite([]);   // false
Number.isFinite([42]); // false

有限数的概念：
在 JS 中，有限数指：
1. 不是 Infinity 或 -Infinity
2. 不是 NaN
3. 在数值范围内（约 ±1.7976931348623157e+308）
有限数的数学定义：
一个数 x 是有限的当且仅当 -Number.MAX_VALUE ≤ x ≤ Number.MAX_VALUE，且 x 不是 NaN。

示例：

基本用法：

Number.isFinite(42);          // true
Number.isFinite(-3.14);       // true
Number.isFinite(0);           // true
Number.isFinite(Math.PI);     // true

// 特殊值
Number.isFinite(Infinity);    // false
Number.isFinite(-Infinity);   // false
Number.isFinite(NaN);         // false
Number.isFinite(1/0);         // false（Infinity）
Number.isFinite(0/0);         // false（NaN）

// 非数值
Number.isFinite("42");        // false（字符串）
Number.isFinite(true);        // false（布尔值）
Number.isFinite(null);        // false
Number.isFinite(undefined);   // false
Number.isFinite([]);          // false（数组）
Number.isFinite({});          // false（对象）
Number.isFinite("");          // false（空字符串）

isInteger()

Number.isInteger()：(value)，ES2015，用于检测一个值是否为整数的方法。

value：any，要检测的值。参数特性：
- 接受任意类型的值。
- 不会对参数进行类型转换。
- 仅当参数为数值类型且值为整数时返回 true。
返回：
isInteger：boolean，返回值内容：
- true：当值是数值类型且为整数（没有小数部分）。
- false：其他所有情况。

~~核心特性~~：

整数的定义：
在 JavaScript 中，整数被定义为：
- 数值类型
- 没有小数部分
- 在 IEEE 754 浮点数范围内可以精确表示
- 整数包括正整数、负整数和零

示例：

基本用法：

Number.isInteger(42);        // true
Number.isInteger(-100);      // true
Number.isInteger(0);         // true

// 小数
Number.isInteger(3.14);      // false
Number.isInteger(0.1);       // false
Number.isInteger(5.0);       // true（小数部分为0）
Number.isInteger(5.000000000000001); // false
Number.isInteger(5.0000000000000001); // true（超出精度范围）

// 特殊值
Number.isInteger(NaN);       // false
Number.isInteger(Infinity);  // false
Number.isInteger(-Infinity); // false
Number.isInteger(1/0);       // false（Infinity）
Number.isInteger(0/0);       // false（NaN）

// 非数值（不进行类型转换）
Number.isInteger("42");      // false（字符串）
Number.isInteger(true);      // false
Number.isInteger(null);      // false
Number.isInteger(undefined); // false
Number.isInteger([]);        // false
Number.isInteger({});        // false
Number.isInteger("10");      // false

isNaN()@

Number.isNaN()：(value)，ES2015，用于精确检测 NaN（Not-a-Number）值的方法。

value：any，要检测的值。参数特性：
- 接受任意类型的值。
- 不会对参数进行类型转换。
- 仅当参数为数值类型且值为 NaN 时返回 true。
返回：
result：boolean，返回值：
- true：当值是数值类型且为 NaN。
- false：其他所有情况。

~~核心特性~~：

对比全局 isNaN()：

全局 isNaN() 会对参数进行类型转换。
推荐使用 Number.isNaN()。

isNaN("NaN");      // true（字符串被转换为数字）
isNaN(undefined);  // true（被转换为 NaN）
isNaN({});         // true（对象被转换为 NaN）

// 以上值在 Number.isNaN() 中返回 false

示例：

基本用法：

Number.isNaN(NaN);        // true
Number.isNaN(0/0);        // true
Number.isNaN(Number.NaN); // true

// 特殊值
Number.isNaN(Infinity);   // false（无穷大是数值）
Number.isNaN("NaN");      // false（字符串）
Number.isNaN(undefined);  // false
Number.isNaN(null);       // false
Number.isNaN(true);       // false
Number.isNaN(false);      // false
Number.isNaN("42");       // false
Number.isNaN([]);         // false
Number.isNaN({});         // false
Number.isNaN(() => {});   // false

方法

toString()

number.toString()：(radix?)，用于将数字转换为字符串的核心方法。它提供了不同进制的转换和格式化选项。

radix?：number，默认：10，表示数值的基数（进制），范围 2-36。特殊值处理：
- 超出范围：如果 radix < 2 或 radix > 36，抛出 RangeError。
- 非整数：小数会被向下取整。
- null/undefined：被视为无参数，取默认值。
返回：
result：string，返回给定数字的字符串。

示例：

默认行为（无参数）：

(10).toString();    // "10"
(3.14).toString();  // "3.14"
(0.0000001).toString(); // "1e-7" (科学计数法)
(-42).toString();   // "-42"

进制转换（指定 radix 参数）：

// 二进制 (base 2)
(10).toString(2);   // "1010"

// 八进制 (base 8)
(64).toString(8);   // "100"

// 十进制 (base 10)
(255).toString(10); // "255"

// 十六进制 (base 16)
(255).toString(16); // "ff"

// 三十二进制 (base 32)
(1000).toString(32); // "vc"

特殊数值处理：

NaN.toString();         // "NaN"
Infinity.toString();    // "Infinity"
(-Infinity).toString(); // "-Infinity"

~~进阶扩展~~：

字面量调用语法：

// 正确方式
10..toString(2);    // "1010"
(10).toString(16);  // "a"
10.0.toString(8);   // "12"

// 错误方式（语法错误）
10.toString(2);     // SyntaxError

toFixed()@

number.toFixed()：(digits?)，用于数字格式化的核心方法，它将数字转换为字符串表示，并保留指定的小数位数。

digits?：number，默认：0，小数点后的位数（0-100）。特殊值处理：
- 超出范围：digits < 0 或 digits > 100 抛出 RangeError。
- 非整数：小数会被四舍五入取整。
- 非数值：非数字参数会被忽略（使用默认值0）。
返回：
result：string，返回定点表示法的数字字符串。

示例：

基本用法：

(123.456).toFixed();    // "123" (默认0位小数)
(123.456).toFixed(0);   // "123"
(123.456).toFixed(2);   // "123.46" (四舍五入)
(123.456).toFixed(4);   // "123.4560" (补零)

特殊数值：

NaN.toFixed(2);         // "NaN"
Infinity.toFixed(2);    // "Infinity"
(-Infinity).toFixed(2); // "-Infinity"

Number ​

索引 ​

Number ​

静态属性 ​

静态方法 ​

parseInt()@ ​

parseFloat()@ ​

isFinite() ​

isInteger() ​

isNaN()@ ​

方法 ​

toString() ​

toFixed()@ ​

Number

索引

Number

静态属性

静态方法

parseInt()@

parseFloat()@

isFinite()

isInteger()

isNaN()@

方法

toString()

toFixed()@