你不知道的JS-Array，String，Number，特殊值

你不知道的JS-Array，String，Number，特殊值

Array

稀散数组：谷歌显示empty，访问undefined

var a = [ ];
a[0] = 1;
a[2] = [ 3 ];

a[1];		// undefined
a.length;	// 3

添加字符串属性时,length 长度不变

var a = [];
a[0] = 1;
a["foobar"] = 2;
a.length;		// 1 

a["foobar"];	// 2
a.foobar;		// 2

类Array可转换为Array后，调用API

Array.prototype.slice.call(arguments)

Array.from(arguments);

String

string内容拥有不可变性,不可被修改

可借助call调用Array方法，除reverse方法

a.join;			// undefined
a.map;			// undefined

var c = Array.prototype.join.call( a, "-" );
var d = Array.prototype.map.call( a, function(v){
	return v.toUpperCase() + ".";
} ).join( "" );

c;				// "f-o-o"
d;				// "F.O.O."

Number

toPrecision:指定多少位 “有效位数” 表示这个值

var a = 42.59;

a.toPrecision( 1 ); // "4e+1"
a.toPrecision( 2 ); // "43"
a.toPrecision( 3 ); // "42.6"
a.toPrecision( 4 ); // "42.59"
a.toPrecision( 5 ); // "42.590"
a.toPrecision( 6 ); // "42.5900"

toFixed保留小数位数注意事项

// 不合法的语法：
42.toFixed( 3 );	// SyntaxError

// 这些都是合法的：
(42).toFixed( 3 );	// "42.000"
0.42.toFixed( 3 );	// "0.420"
42..toFixed( 3 );	// "42.000"

number 字面量还可以使用其他进制表达，比如二进制，八进制，和十六进制。

0xf3;        // 十六进制的: 243
0o363;		// 八进制的: 243
0b11110011;	// 二进制的: 243

二进制浮点数 加法运算 著名副作用

0.1 + 0.2 === 0.3; // false 
//接近于0.30000000000000004 17位小数

错误容差值：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

浮点值:最大值与最小值

Number.MAX_VALUE  1.798e+308
Number.MIN_VALUE  5e-324

安全范围整数:最大值与最小值

大位数number可以用字符串替代

Number.MAX_SAFE_INTEGER //2^53 - 1 也就是9007199254740991
Number.MIN_SAFE_INTEGER //-2^53 - 1 也就是-9007199254740991

判断整数isInteger和安全整数isSafeInteger

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

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

特殊值

undefined和null

null有定义，值为空；undefined有定义，但无值
null为关键字；而undefined只是内建标识符

function foo() {
	undefined = 2; // 非常差劲儿的主意！
}

function foo() {
	"use strict";
	undefined = 2; // TypeError!
}

function foo() {
	"use strict";
	var undefined = 2;
	console.log( undefined ); // 2
}

void 任何值，返回的结果均为undefined

console.log(void 0);	//undefined
console.log(void []);	//undefined
console.log(void "");	//undefined
console.log(void null); //undefined

NaN实质为当数学操作错误时,返回失败的number结果

window.isNaN 与 ES6新增 Number.isNaN 不同
NaN !== NaN
isNaN本质:测试这个传进来的东西是否不是一个 number 或者是一个 number”

var a = 2 / "foo";		// NaN
typeof a === "number";	// true 表示NaN为number类型

var null + undefined //NaN

console.log(NaN == NaN) //false
console.log(NaN === NaN) //false

var a = 2 / "foo";
var b = "foo";

window.isNaN( a ); // true
window.isNaN( b ); // true -- 噢!

Number.isNaN( a ); // true
Number.isNaN( b ); // false -- 咻!

infinity无穷

var a = 1 / 0;	// Infinity
var b = -1 / 0;	// -Infinity

Number.POSITIVE_INFINITY // Infinity
Number.NEGATIVE_INFINITY // -Infinity

Number.MAX_VALUE;	// 1.7976931348623157e+308

零: 0 和 -0

JS中零分为： 0 和 -0

-0字符串化会自动变为0，当反向字符串化时返回本身-0

-0与0在==和===情况均返回true

正负符号为表示方向性

//区分0和-0函数
function isNegZero(n) {
	n = Number( n );
	return (n === 0) && (1 / n === -Infinity);
}

isNegZero( -0 );		// true
isNegZero( 0 / -3 );	// true
isNegZero( 0 );			// false

Object.is:比较特殊值(NaN、0，-0)是否相等

-0与0的比较中,比较Infinity与-Infinity是否相等

NaN与NaN比较是否相同时，两变量各自比较自身是否相等

var a = 2 / "foo"; // NaN
var b = -3 * 0; //-0

Object.is( a, NaN );	// true
Object.is( b, -0 );		// true
Object.is( b, 0 );		// false

值和引用：值拷贝与引用拷贝

简单值（也叫基本标量）：number、string、 boolean、null、undefined、symbol

复合值 —— object（包括 array，和所有的对象包装器(Number、String、Boolean等) ）和 function

底层的基本标量值是不可变的（String 和 Boolean 也一样）。如果一个 Number 对象持有一个基本标量值 2，那么这个 Number 对象就永远不能再持有另一个值；

var a = 2;
var b = a; // `b` 总是 `a` 中的值的拷贝
b++;
a; // 2
b; // 3

var c = [1,2,3];
var d = c; // `d` 是共享值 `[1,2,3]` 的引用
d.push( 4 );
c; // [1,2,3,4]
d; // [1,2,3,4]

var a = [1,2,3];
var b = a;
a; // [1,2,3]
b; // [1,2,3]

// 稍后
b = [4,5,6];
a; // [1,2,3]
b; // [4,5,6]