JavaScript 数字方法

JavaScript Number 方法

JavaScript 提供了几种内置方法来处理数字，用于格式化、转换和其他操作。

用于数字的全局函数

JavaScript 有一些全局函数，它们通常与数字一起使用，尽管它们也可以对其他数据类型进行操作以进行转换。

与数字操作最相关的全局函数是：

方法	描述
Number(value)	将其参数转换为数字。如果转换不可能，返回 `NaN`（Not a Number）。
parseFloat(string)	解析其字符串参数并返回一个浮点数。在遇到第一个非数字字符时停止解析。
parseInt(string, radix)	解析其字符串参数并返回指定进制（基数）的整数。总是指定 `radix`（例如，10 表示十进制）。

Number 原型方法

这些方法是在数字值本身（原始值或 Number 对象）上调用的。JavaScript 会自动将数字原始值封装成一个 Number 对象来访问这些方法（自动装箱）。

方法	描述
toString(radix)	返回数字的字符串表示。可选参数 `radix` (2-36) 可以指定转换的基数（例如，2 表示二进制，16 表示十六进制）。默认为基数 10。
toExponential(fractionDigits)	返回数字的指数（科学）记数法表示的字符串。`fractionDigits` (0-100) 指定小数点后的位数。
toFixed(digits)	返回数字的定点记数法表示的字符串。`digits` (0-100) 指定小数点后出现的位数；如果需要，数字会被四舍五入。
toPrecision(precision)	返回数字的指定精度（总有效数字位数，1-100）表示的字符串。
valueOf()	返回 `Number` 对象的原始值。由 JavaScript 内部调用；在代码中很少直接使用。

重要提示：	所有数字方法都返回一个新值（通常是字符串，除了 `valueOf`）。它们不会修改原始的数字变量。

toString() 方法

toString() 将数字转换为其字符串表示。

它可以用于数字字面量、变量或表达式。可选参数 radix 指定基数。

const num = 123;
num.toString();        // "123" (默认为基数 10)
(42).toString();         // "42"
(100 + 23).toString();   // "123"

num.toString(2);         // "1111011" (二进制)
num.toString(16);        // "7b" (十六进制)

toExponential() 方法

toExponential() 返回数字的指数（科学）记数法表示的字符串。

可选参数 fractionDigits 指定小数点后的位数。

const x = 9.656;
x.toExponential(2);  // "9.66e+0"
x.toExponential(4);  // "9.6560e+0"
x.toExponential();     // "9.656e+0" (如果没有参数，包含尽可能多的位数)

const largeNum = 12345e8;
largeNum.toExponential(3); // "1.235e+12" (表示 1.235 乘以 10 的 12 次方)

toFixed() 方法

toFixed() 使用定点记数法格式化数字并返回一个字符串。

它接受一个参数 digits，指示小数点后的位数。如果需要，数字会被四舍五入。

const x = 9.656;
x.toFixed(0);     // "10" (向上取整)
x.toFixed(2);     // "9.66" (向上取整)
x.toFixed(4);     // "9.6560"
x.toFixed(6);     // "9.656000"

const y = 123.456;
(2.34).toFixed(1);  // "2.3"
(2.35).toFixed(1);  // "2.4" (注意四舍五入)

小贴士：	`toFixed(2)` 常用于格式化货币值。

toPrecision() 方法

toPrecision() 返回数字的指定有效数字位数表示的字符串。

如果精度小于整数部分的位数，将使用指数记数法。

const x = 9.656;
x.toPrecision();    // "9.656" (完整精度)
x.toPrecision(2);   // "9.7" (四舍五入到 2 位有效数字)
x.toPrecision(4);   // "9.656"
x.toPrecision(6);   // "9.65600"

const y = 1234.5;
y.toPrecision(2);   // "1.2e+3" (指数记数法，表示 1.2 乘以 10 的 3 次方)
y.toPrecision(7);   // "1234.500"

将值转换为数字（回顾）

如前所述，有 3 个有用的全局 JavaScript 函数可以将各种类型的值转换为数字：

Number(value): 将值转换为数字的最直接方法。
parseInt(string, radix): 用于将字符串转换为整数。
parseFloat(string): 用于将字符串转换为浮点数。

这些是全局函数，而不是数字对象的方法。

Number() 函数

Number() 尝试将其参数转换为数值。

Number(true);         // 1
Number(false);        // 0
Number(null);         // 0
Number(undefined);    // NaN
Number(new Date());   // 自 1970 年 1 月 1 日 UTC 以来的毫秒数 (例如，1678886400000)
Number("10");         // 10
Number(" 10 ");      // 10 (去除空白)
Number("10.33");      // 10.33
Number("10,33");      // NaN (在此上下文中逗号不是小数点)
Number("10 20");      // NaN (空格使 Number() 认为无效)
Number("John");       // NaN

parseInt() 函数

parseInt() 解析字符串参数并返回一个整数。至关重要的是提供 radix（基数）参数，以避免意外行为，特别是对于可能以 ‘0’ 或 ‘0x’ 开头的字符串。

parseInt("10", 10);         // 10
parseInt("10.33", 10);      // 10 (在小数点处停止)
parseInt("10 20 30", 10);   // 10 (在空格处停止)
parseInt("10 years", 10);   // 10 (在 'y' 处停止)
parseInt("years 10", 10);   // NaN (不是以数字开头)
parseInt("010", 10);        // 10 (radix 10 确保按十进制解释)
parseInt("010");            // 在较旧的 JS 中，可能是 8 (八进制)。现代 JS 如果没有 '0x' 前缀，默认为 10。
                           // 总是使用 radix：parseInt("010", 10) 是安全的。
parseInt("FF", 16);         // 255 (十六进制)

如果第一个字符无法转换为数字，parseInt() 返回 NaN。

parseFloat() 函数

parseFloat() 解析字符串参数并返回一个浮点数。它会持续解析，直到遇到一个不是有效数字表示一部分的字符。

parseFloat("10");          // 10
parseFloat("10.33");       // 10.33
parseFloat("10.00");       // 10
parseFloat("10 20 30");    // 10 (在空格处停止)
parseFloat("10 years");    // 10 (在 'y' 处停止)
parseFloat("years 10");    // NaN (不是以数字开头)
parseFloat("3.14e2");       // 314
parseFloat("  -2.5 ");    // -2.5 (处理前导/尾随空白和符号)

如果第一个字符无法转换为数字，parseFloat() 返回 NaN。

valueOf() 方法

valueOf() 返回 Number 对象的原始值。这个方法通常由 JavaScript 内部调用，在你的代码中通常不显式使用。

const numObj = new Number(123);
numObj.valueOf(); // 123 (原始数字)

const primitiveNum = 42;
primitiveNum.valueOf(); // 42 (返回原始值本身)

在 JavaScript 中，数字可以是原始值（typeof num === ‘number’）或使用 new Number() 创建的对象（typeof numObj === ‘object’）。出于性能和简单性的考虑，几乎总是优先使用原始数字。

注意：	JavaScript 中所有原始数据类型（除了 `null` 和 `undefined`）都有 `valueOf()` 方法。对象也具有 `valueOf()` 和 `toString()` 方法，通常会被重写以实现自定义行为。

对于超出 Number.MAX_SAFE_INTEGER 或需要任意精度整数算术的数字，考虑使用 BigInt。BigInt 有自己的一套操作，不直接与 Number 方法兼容。

延伸阅读：MDN: Number, MDN: parseInt