JavaScript----数字及数字方法

JavaScript - 数字

JavaScript 只有一种数值类型。
书写数值时带不带小数点均可。

var x = 3.14;    // 带小数点的数值
var y = 3;       // 不带小数点的数值

超大或超小的数可通过科学计数法来写

var x = 123e5;    // 12300000
var y = 123e-5;   // 0.00123

JavaScript数值始终是64位的浮点数
与许多其他编程语言不同，JavaScript 不会定义不同类型的数，比如整数、短的、长的、浮点的等等。
JavaScript 数值始终以双精度浮点数来存储，根据国际 IEEE 754 标准。
此格式用 64 位存储数值，其中 0 到 51 存储数字（片段），52 到 62 存储指数，63 位存储符号：

值(aka Fraction/Mantissa)	指数	符号
52 bits(0 - 51)	11 bits (52 - 62)	1 bit (63)

整数（不使用指数或科学计数法）会被精确到 15 位。

var x = 999999999999999;   // x 将是 999999999999999
var y = 9999999999999999;  // y 将是 10000000000000000

小数的最大数是 17 位，但是浮点的算数并不总是 100% 精准：

var x = 0.2 + 0.1;         // x 将是 0.30000000000000004

使用乘除法有助于解决上面的问题：

var x = (0.2 * 10 + 0.1 * 10) / 10;       // x 将是 0.3

数字和字符串相加

JavaScript 的加法和级联（concatenation）都使用 + 运算符。
数字用加法。字符串用级联。
如果您对两个数相加，结果将是一个数
如果对两个字符串相加，结果将是一个字符串的级联
如果您对一个数和一个字符串相加，结果也是字符串级联

var x = 10;
var y = "20";
var z = x + y;           // z 将是 1020（一个字符串）

如果您对一个字符串和一个数字相加，结果也是字符串级联

var x = "10";
var y = 20;
var z = x + y;           // z 将是 1020（字符串）

注意: JavaScript 从左向右进行编译。

var x = 10;
var y = 20;
var z = "30";
var result = x + y + z;  //x+y=30；30+"30"="3030"

数字字符串

JavaScript 字符串可以拥有数字内容：

var x = 100;        // x 是数字
var y = "100";       // y 是字符串

在所有数字运算中，JavaScript 会尝试将字符串转换为数字

var x = "100";
var y = "10";
var a = x / y;       // a 将是 10
var b = x * y;       // b 将是 1000
var c = x - y;       // c 将是 90

但是该例不会如上例般运行

var x = "100";
var y = "10";
var z = x + y;       // z 不会是 110（而是 10010）

JavaScript 用 + 运算符对字符串进行了级联

NaN - 非数值

NaN 属于 JavaScript 保留词，指示某个数不是合法数。

尝试用一个非数字字符串进行除法会得到 NaN（Not a Number）：

var x = 100 / "Apple";  // x 将是 NaN（Not a Number）

如果是数字字符串，则结果将是数

var x = 100 / "10";     // x 将是 10

您可使用全局 JavaScript 函数 isNaN() 来确定某个值是否是数

var x = 100 / "Apple";
isNaN(x);               // 返回 true，因为 x 不是数

要小心 NaN。假如您在数学运算中使用了 NaN，则结果也将是 NaN：

var x = NaN;
var y = 5;
var z = x + y;         // z 将是 NaN

结果也许是串连接

var x = NaN;
var y = "5";
var z = x + y;         // z 将是 NaN5

⭐⭐⭐ NaN 是数，typeof NaN 返回 number ⭐⭐⭐

typeof NaN;             // 返回 "number"

Infinity

Infinity （或 -Infinity）是 JavaScript 在计算数时超出最大可能数范围时返回的值。

除以 0（零）也会生成 Infinity

var x =  2 / 0;          // x 将是 Infinity
var y = -2 / 0;          // y 将是 -Infinity

⭐⭐⭐ Infinity 是数：typeOf Infinity 返回 number。 ⭐⭐⭐

十六进制

JavaScript 会把前缀为 0x 的数值常量解释为十六进制。

var x = 0xFF;             // x 将是 255

绝不要用前导零写数字（比如 07）。
一些 JavaScript 版本会把带有前导零的数解释为八进制。
默认地，Javascript 把数显示为十进制小数。

但是您能够使用 toString() 方法把数输出为十六进制、八进制或二进制。

var myNumber = 128;
myNumber.toString(16);     // 返回 80
myNumber.toString(8);      // 返回 200
myNumber.toString(2);      // 返回 10000000

数值可以是对象（但不推荐，这样会拖慢执行速度)

通常 JavaScript 数值是通过字面量创建的原始值：var x = 123
但是也可以通过关键词 new 定义为对象：var y = new Number(123)

var x = 123;
var y = new Number(123);
// typeof x 返回 number
// typeof y 返回 object

请不要创建数值对象。这样会拖慢执行速度。
new 关键词使代码复杂化，并产生某些无法预料的结果：
当使用 == 相等运算符时，相等的数看上去相等：

var x = 500;             
var y = new Number(500);
// (x == y) 为 true，因为 x 和 y 有相等的值

当使用 === 相等运算符后，相等的数变为不相等，因为 === 运算符需要类型和值同时相等。

var x = 500;             
var y = new Number(500);
// (x === y) 为 false，因为 x 和 y 的类型不同

甚至更糟。对象无法进行对比：

var x = new Number(500);             
var y = new Number(500);
// (x == y) 为 false，因为对象无法比较

数字方法

所有数字方法可用于任意类型的数字（字面量、变量或表达式）

toString()方法， 以字符串返回数值

var x = 123;
x.toString();            // 从变量 x 返回 123
(123).toString();        // 从文本 123 返回 123
(100 + 23).toString();   // 从表达式 100 + 23 返回 123

toExponential() 返回字符串值，它包含已被四舍五入并使用指数计数法的数字

var x = 9.656;
x.toExponential(2);     // 返回 9.66e+0
x.toExponential(4);     // 返回 9.6560e+0
x.toExponential(6);     // 返回 9.656000e+0

该参数是可选的。如果您没有设置它，JavaScript 不会对数字进行舍入。

toFixed() 返回字符串值，它包含了指定位数小数的数字

var x = 9.656;
x.toFixed(0);           // 返回 10
x.toFixed(2);           // 返回 9.66
x.toFixed(4);           // 返回 9.6560
x.toFixed(6);           // 返回 9.656000

toFixed(2) 非常适合处理金钱。

toPrecision() 返回字符串值，它包含了指定长度的数字

var x = 9.656;
x.toPrecision();        // 返回 9.656
x.toPrecision(2);       // 返回 9.7
x.toPrecision(4);       // 返回 9.656
x.toPrecision(6);       // 返回 9.65600

valueOf() 以数值返回数值

var x = 123;
x.valueOf();            // 从变量 x 返回 123
(123).valueOf();        // 从文本 123 返回 123
(100 + 23).valueOf();   // 从表达式 100 + 23 返回 123

在 JavaScript 中，数字可以是原始值（typeof = number）或对象（typeof = object）。
在 JavaScript 内部使用 valueOf() 方法可将 Number 对象转换为原始值。
没有理由在代码中使用它。
所有 JavaScript 数据类型都有 valueOf() 和 toString() 方法。

把变量转换成数值

这三种 JavaScript 方法可用于将变量转换为数字：

• Number() 方法
• parseInt() 方法
• parseFloat() 方法

这些方法并非数字方法，而是全局JavaScript 方法。

全局方法

JavaScript 全局方法可用于所有 JavaScript 数据类型。
这些是在处理数字时最相关的方法：

方法	描述
Number()	返回数字，由其参数转换而来。
parseFloat()	解析其参数并返回浮点数。
parseInt()	解析其参数并返回整数。

Number() 可用于把 JavaScript 变量转换为数值

x = true;
Number(x);        // 返回 1
x = false;     
Number(x);        // 返回 0
x = new Date();
Number(x);        // 返回 1404568027739
x = "10"
Number(x);        // 返回 10
x = "10 20"
Number(x);        // 返回 NaN

如果无法转换数字，则返回 NaN

Number() 还可以把日期转换为数字

Number(new Date("2019-04-15"));    // 返回 1506729600000

上面的 Number() 方法返回 1970 年 1 月 1 日至今的毫秒数。

parseInt() 解析一段字符串并返回数值。允许空格。只返回首个数字

parseInt("10");         // 返回 10
parseInt("10.33");      // 返回 10
parseInt("10 20 30");   // 返回 10
parseInt("10 years");   // 返回 10
parseInt("years 10");   // 返回 NaN

如果无法转换为数值，则返回 NaN (Not a Number)。

parseFloat() 解析一段字符串并返回数值。允许空格。只返回首个数字

parseFloat("10");        // 返回 10
parseFloat("10.33");     // 返回 10.33
parseFloat("10 20 30");  // 返回 10
parseFloat("10 years");  // 返回 10
parseFloat("years 10");  // 返回 NaN

如果无法转换为数值，则返回 NaN (Not a Number)。

数值属性

属性	描述
MAX_VALUE	返回 JavaScript 中可能的最大数。
MIN_VALUE	返回 JavaScript 中可能的最小数。
NEGATIVE_INFINITY	表示负的无穷大（溢出返回）。
NaN	表示非数字值（"Not-a-Number"）。
POSITIVE_INFINITY	表示无穷大（溢出返回）。

MAX_VALUE 返回 JavaScript 中可能的最大数字

var x = Number.MAX_VALUE;
document.getElementById("demo").innerHTML = x;  //1.7976931348623157e+308

MIN_VALUE 返回 JavaScript 中可能的最小数字。

var x = Number.MIN_VALUE;
document.getElementById("demo").innerHTML = x;  //5e-324

POSITIVE_INFINITY 表示无穷大（溢出返回）

var x = Number.POSITIVE_INFINITY;  //Infinity

溢出时返回 POSITIVE_INFINITY

var x = 1 / 0;  //Infinity

NEGATIVE_INFINITY 表示负的无穷大（溢出返回）

var x = Number.NEGATIVE_INFINITY;  //-Infinity

溢出时返回 NEGATIVE_INFINITY：

var x = -1 / 0;  //-Infinity

NaN - 非数字

var x = Number.NaN;

NaN 属于 JavaScript 保留字，指示数字并非合法的数字。

尝试使用非数字字符串进行算术运算将导致 NaN（非数字）

var x = 100 / "Apple";  // x 将是 NaN (Not a Number)

⭐⭐⭐数字属性不可用于变量⭐⭐⭐
数字属性属于名为 number 的 JavaScript 数字对象包装器。
这些属性只能作为 Number.MAX_VALUE 访问。
使用 myNumber.MAX_VALUE，其中 myNumber 是变量、表达式或值，将返回 undefined