JS的类型和值

1.类型

ECMAScript语言中所有的值都有一个对应的语言类型。ECMAScript语言类型包括Undefined、Null、Boolean、String、Number和Object。

对语言引擎和开发人员来说，类型是值的内部特征，它定义了值的行为，以使其区别于其他值。

内置类型

JavaScript有七种内置类型：

空值(null)
未定义(undefined)
布尔值(boolean)
数字(number)
字符串(string)
对象(object)
符号(symbol，ES6中新增)

除了对象之外，其他统称为“基本类型”。

我们可以用typeof运算符来查看值的类型，它返回的是类型的字符串值。

typeof undefined === "undefined";//true

typeof true === "boolean";//true

typeof 42 === "number";//true

typeof "42" === "string";//true

typeof {life:42} === "object";//true

typeof Symbol() === "symbol";//true

//下面是一个bug

typeof null === "object";//true

typeof function a(){ /*...*/ } === "function";//true

JavaScript中的变量是没有类型的。只有值才有。变量可以随时持有任何类型的值。

在对变量执行typeof操作时，得到的结果并不是该变量的类型，而是该变量持有的值的类型，因为JavaScript中的变量没有类型。

var a = 42;

typeof a;//"number"

a = true;

typeof a;//"boolean"

//因为typeof 42返回"number"

typeof typeof 42;//"string"

2.值

2.1 数组

在JavaScript中，数组可以容纳任何类型的值，可以是字符串、数字、对象(object)，甚至是其他数组。

var a = [1,"2",[3]];

a.length;//3

a[0] === 1;//true

a[2][0] === 3;//true

对数组声明后即可向其中加入值，不需要预先设定大小。

var a = [];

a.length;//0

a[0] = 1;

a[1] = "2";

a[2] = [3];

a.length;//3

使用delete运算符可以将单元从数组中删除，但是要注意，单元删除后，数组的length属性并不会发生变化。

var a = [];

a[0] = 1;

a[2] = [3];

a[1];//undefined

a.length;//3

数组通过数字进行索引，但有趣的是它们也是对象，所以也可以包含字符串键值和属性，但这些并不计算在数组长度内：

var a = [];

a[0] = 1;

a["foobar"] = 2;

a.length;//1

a["foobar"];//2

a.foobar;//2

如果字符串键值能够被强制类型转换为十进制数字的话，它就会被当作数字索引来处理。

var a = [];

a["13"] = 42;

a.length;//14

建议使用对象来存放键值/属性值，用数组来存放数字索引值。

2.2 字符串

JavaScript中的字符串和字符数组并不是一回事。

var a = "foo";

var b = ["f","o","o"];

a.length;//3

b.length;//3

a.indexOf("o");//1

b.indexOf("o");//1

a;//"foo"

b;//["f","o","o"]

a[1] = "0";

b[1] = "0";

a;//"foo"

b;//["f","0","o"]

JavaScript中字符串是不可变的，而数组是可变的。

a[1]在JavaScript中并非总是合法语法，正确的方法应该是a.charAt(1)。

字符串不可变是指字符串的成员函数不会改变其原始值，而是创建并返回一个新的字符串。

许多数组函数用来处理字符串很方便(字符串没有这些函数)。

var a = "foo";

var b = ["f","o","o"];

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."

2.3 数字

number(数字)，包括"整数"和带小数的十进制数。

数字的语法

var a = 0.42;

var b = .42;

var c = 42.0;

var d = 42.;

特别大的特别小的数字默认用指数格式显示。

var a = 5E10;

a;//50000000000

a.toExponential();//"5e+10"

var b = a*a;

b;//2.5e+21

var c = 1/a;

c;//2e-11

var a = 42.59;

a.toFixed(0);//43

a.toFixed(1);//42.6

a.toFixed(2);//42.59

a.toFixed(3);//42.590

a.toFixed(4);//42.5900

a.toPrecision(1);//4e+1

a.toPrecision(2);//43

a.toPrecision(3);//42.6

a.toPrecision(4);//42.59

但是下面的语法是有效的(请注意其中的空格)：

2.4 特殊数值

undefined类型只有一个值，即undefined。null类型也只有一个值，即null。

null指空值。

undefined指没有值。

null是一个特殊关键字，不是标识符，我们不能将其当作变量来使用和赋值。

undefined是一个标识符，可以被当作变量来使用和赋值。

我们通过void运算符即可得到undefined这个值。

var a = 42;

console.log(void a, a);//undefined 42

按惯例我们用void 0来获得undefined。void 0、void 1和undefined之间并没有实质上的区别。

特殊的数字

如果数学运算的操作数不是数字类型，就无法返回一个有效的数字，这种情况下返回值为NaN。

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

typeof a === "number";//true

NaN仍然是数字类型。

NaN用于指出数字类型中的错误情况，即“执行数学运算没有成功，这是失败后返回的结果”。

var a = 2/"foo";

a == NaN;//false

a === NaN;//false

NaN是一个特殊值，它和自身不相等，是唯一一个非自反的值。

可以使用内建的全局工具函数isNaN(..)来判断一个值是否是NaN。

NaN是JavaScript中唯一一个不等于自身的值。

if(!Number.isNaN){

	Number.isNaN = function(n){

		return n != n;

	};

}

无穷数

var a = 1/0;//Infinity

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

JavaScript的运算结果有可能溢出。

规范规定，如果数学运算的结果超出处理范围，则由IEEE754规范中的“就近取整”模式来决定最后结果。

计算结果一旦溢出为无穷数就无法再得到有穷数。换句话说，就是你可以从有穷走向无穷，但无法从无穷回到有穷。

无穷除以无穷(Infinity/ Infinity)是一个未定义操作，结果为NaN。

零值

var a = 0/-3;//-0

var b = 0*-3;//-0

加法和减法运算不会得到负零。

根据规范，对负零进行字符串化会返回"0"：

var a = 0/-3;

a.toString();//"0"

a + "";//"0"

String(a);//"0"

JSON.stringify(a);//"0"

+"-0";//-0

Number("-0");//-0

JSON.parse("-0");//-0

var a = 0;

var b = 0/-3;

a == b;//true

-0 == 0;//true

a === b;//true

-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

特殊的等式

ES6中新加入了一个工具方法Object.is(..)来判断两个值是否绝对相等。

var a = 2/"foo";

var b = -3*0;

Object.is(a,NaN);//true

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

Object.is(b,0);//false

能使用==和===时就尽量不要使用Object.is(..)，因为前者效率更高，更为通用。Object.is(..)主要用来处理那些特殊的相等比较。

2.5 值和引用

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]的一个引用

c;//[1,2,3,4]

d;//[1,2,3,4]

简单值总是通过值复制的方式来赋值/传递，包括null、undefined、字符串、数字、布尔和ES6中的symbol。

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

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]

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

function foo(x){

	x.push(4);

	x;//[1,2,3,4]

	x = [4,5,6];

	x.push(7);

	x;//[4,5,6,7]

}

var a = [1,2,3];

foo(a);

a;//[1,2,3,4]

//我们不能通过引用x来更改引用a的指向，只能更改a和x共同指向的值。

function foo(x){

	x.push(4);

	x;//[1,2,3,4]

	x.length = 0;

	x.push(4,5,6,7);

	x;//[4,5,6,7]

}

var a = [1,2,3];

foo(a);

a;//[4,5,6,7]

/*

function foo(wrapper){

	wrapper.a = 42;

}

var obj = {

	a : 2

};

foo(obj);

obj.a;//42

*/

/*

function foo(x){

	x = x + 1;

	x;//3

}

var a = 2;

var b = new Number(a);//Object(a)也一样

foo(b);

console.log(b);//2

*/

我们无法自行决定使用值复制还是引用复制，一切由值的类型来决定。

参考资料：《你不知道的JavaScript》(中卷) 第一部分前两章