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》(中卷) 第一部分 前两章