我所不知道的JavaScript——值

JavaScript 只有一种数值类型:number(数字)，包括“整数”和带小数的十进制数。JavaScript 中的“整数”就是没有小数的十进制数。所以 42.0 即等同于“整数”42。JavaScript 中的数字类型是基于IEEE 754标准来实现的，该标准通常也被称为“浮点数”。JavaScript使用的是“双精度”格式(即 64 位二进制)。
. 运算符需要给予特别注意，因为它是一个有效的数字字符，会被优先识别为数字常量的一部分，然后才是对象属性访问运算符。

// 无效语法
42.toFixed( 3 ); // SyntaxError
// 下面的语法都有效: 
(42).toFixed( 3 ); // "42.000" 
0.42.toFixed( 3 ); // "0.420" 
42..toFixed( 3 ); // "42.000"

42.tofixed(3) 是无效语法，因为 . 被视为常量 42. 的一部分(如前所述)，所以没有. 属性访问运算符来调用 tofixed 方法。
42..tofixed(3) 则没有问题，因为第一个 . 被视为 number 的一部分，第二个 . 是属性访问运算符。

较小的数值比较

二进制浮点数最大的问题(不仅 JavaScript，所有遵循 IEEE 754 规范的语言都是如此)，是会出现如下情况:
0.1 + 0.2 === 0.3; // false
从数学角度来说，上面的条件判断应该为 true，可结果为什么是false 呢?
简单来说，二进制浮点数中的 0.1 和 0.2 并不是十分精确，它们相加的结果并非刚好等于 0.3，而是一个比较接近的数字 0.30000000000000004，所以条件判断结果为 false。

设置一个误差范围值 2^-52 (2.220446049250313e-16) 来解决以上问题。
从 ES6 开始，该值定义在 Number.EPSILON 中，我们可以直接拿来用，也可以为 ES6 之前的版本写 polyfill:

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

可以使用Number.EPSILON来比较两个数字是否相等(在指定的误差范围内):

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

能够呈现的最大浮点数大约是 1.798e+308(这是一个相当大的数字)，它定义在 Number. MAX_VALUE 中。最小浮点数定义在 Number.MIN_VALUE 中，大约是 5e-324，它不是负数，但无限接近于 0 !

整数检测

要检测一个值是否是整数，可以使用 ES6 中的 Number.isInteger(..) 方法:

Number.isInteger( 42 );     // true
Number.isInteger( 42.000 ); // true
Number.isInteger( 42.3 );   // false

也可以为 ES6 之前的版本 polyfill Number.isInteger(..) 方法:

if (!Number.isInteger) {
  Number.isInteger = function(num) {
    return typeof num == "number" && num % 1 == 0;
  };
}

要检测一个值是否是安全的整数，可以使用 ES6 中的 Number.isSafeInteger(..) 方法:

Number.isSafeInteger( Number.MAX_SAFE_INTEGER );
Number.isSafeInteger( Math.pow( 2, 53 ) );
Number.isSafeInteger( Math.pow( 2, 53 ) - 1 );
// true
// false
// true

可以为 ES6 之前的版本 polyfill Number.isSafeInteger(..) 方法:

if (!Number.isSafeInteger) {
  Number.isSafeInteger = function(num) {
    return Number.isInteger( num ) &&
        Math.abs( num ) <= Number.MAX_SAFE_INTEGER;
  }; 
}

特殊的数字

NaN意指“不是一个数字”（not a number）。
下面来看看全局工具函数 isNaN() 的用法：

var a = 2 / "foo";
var b = "foo";
a; // NaN
b; "foo"
window.isNaN( a ); // true 
window.isNaN( b ); // true

以上的检验方式是：“只要不是数字，它的值就是NaN”。我们定义的变量 b 不是一个数字，但也不是NaN，所以这种检验方式并不太准确。

从ES6开始可以使用工具函数Number.isNaN(..)，ES6 之前的浏览器的 polyfill 如下:

if (!Number.isNaN) {
  Number.isNaN = function(n) {
    return n !== n; // 利用 NaN 不等于自身这个特点,NaN 是 JavaScript 中唯 一一个不等于自身的值。
 };
}
var a = 2 / "foo";
var b = "foo";
Number.isNaN( a ); // true
Number.isNaN( b ); // false

于是，这就是我们所期待的结果了。

值和引用

JavaScript 对值和引用的赋值 / 传递在语法上没有区别，完全根据值的类型来决定。下面来看一个例子:

var a = 2;
var b = a; 
b++;
a; // 2
b; // 3
var c = [1,2,3];
var d = c; 
d.push( 4 );
c; // [1,2,3,4]
d; // [1,2,3,4]

简单值(即标量基本类型值，scalar primitive)总是通过 值复制 的方式来赋值/传递，包括 null、undefined、字符串、数字、布尔和 ES6 中的 symbol。

值复制——例子中b是a的值的一个副本，b值的改变不会影响a的值

复合值——对象(包括数组和封装对象)和函数，则总是通过 引用复制 的方式来赋值 / 传递。

引用复制——例子中c 和 d 则分别指向同一个复合值 [1,2,3] 的两个不同引用，所以它们更改的是同一个值(如调用 .push(4))，随后它们都指向更改后的新值 [1,2,3,4]。

由于引用指向的是值本身而非变量，所以一个引用无法更改另一个引用的指向。