JavaScript之类型

内置类型

JavaScript中有其中内置类型

1. 空值（null）
2. 未定义(undefined)
3. 布尔值(boolean)
4. 数字(number)
5. 字符串(string)
6. 对象(object)
7. 符号(symbol, ES6新增)
   在javascript中可以用typeof运算符来查看值的类型，他返回的是类型的字符串值。

typeof null === "object"; //true
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

以上除了null类型之外，其他的六种类型均有同名的字符串值与之对应，并且null是基本类型中唯一的一个假值类型，typeof对他的返回值是object
除了上述的内置类型，还有一种情况

typeof function a(){} === 'function'; //true

如此看来，function(函数)也是javascript中的一个内置类型，但是通过instanceof这个属性可以发现，实际上它是object的一个子类型，具体来说，可以把函数当作可调用对象，他是一个内部属性[[call]], 该属性使其可以被调用，既然是对象，那函数也有自己的属性，函数对象的length属性是其声明的参数的个数

function a(b, c){}
a.length; //2

值和引用

在javascript中，变量可能包含两种不同数据类型的值，基本类型值和引用类型值。
基本类型值指的是简单的数据段： 总是通过值复制的方式来赋值/传递，包括null，undefined，字符串，数字，布尔和ES6中的symbol
引用类型值指那些可能有多个值构成的对象(包括数组和封装对象和函数)，则总是通过引用复制的方式来赋值/传递
值复制：从一个变量像另一个变量复制基本类型的值，会在变量对象上创建一个新值，然后将该值复制到为新变量分配的位置上，此后这两个变量可以参与任何操作不会有相互影响。

var a = 2;
var b = a; //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]

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

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

b = [4,5,6] //b指向值[4,5,6]
a; //[1,2,3]
b; //[4,5,6]

b = [4,5,6]并不影响a指向值[1,2,3],除非b不是指向数组的引用，而是指向函数a的指针，但在javascript中不存在这样的情况
函数传参： 在javascript中所有函数的参数都是按值传递的，也就是说，把函数外部的值复制给函数内部的参数。即在向参数传递基本类型的值时，被传递的值会被复制给一个局部变量，在向参数传递引用类型的值时，会将这个值在内存中的地址复制给一个局部变量。

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]而不是[4,5,6,7];

我们在向函数传参的时候，实际上是把引用a的复本赋值给x了，而a仍指向[1,2,3]。

字符串

字符串和数组很相似，都有length属性以及indexOf()和concat()方法，在javascript中字符串是不可变的，字符串的成员函数不会改变其原始值，而是创建并返回一个新的字符串。

var a = foo;
var b = a.toUpperCase();
a === b //false
a; //"foo";
b; //"FOO"

许多数组函数用来处理字符串很方便，虽然字符串没有这些函数，但可以通过借用数组的非变更方法来处理字符串；

var a = foo;
a.join; //undefined
a.map;  //undefined

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

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

例如常见的字符串反转问题

var a = "foo";
var b = Array.prototype.reverse.call(a);
b; //"oof";

//也可以是
var c = a.split("").resverse().join("");
c; //"oof"

上述方法对于包含复杂字符(Unicode, 星号， 多字节字符等)的字符串不适用，需要特殊的库来实现

数字

javascript只有一种数值类型： number(数字)， 包括整数和带小数的十进制数，javascript中没有真正意义上的整数，javascript中的整数就是没有小数的十进制数，所以42.0等同于整数42。 而数字类型常见的问题就是

0.1 + 0.2 === 0.3 //false

这是因为二进制浮点数中的0.1和0.2并不是十分精确，他们相加的结果并非刚好等于0.3，而是一个比较接近的数字，所以判断结果为false。
对于这种情况，最常见的方法是设置一个误差范围值，从ES6开始，该值定义在Number.EPSILON中我们可以直接拿来用。

if(!Number.EPSILON){
    Number.EPSILON = Math.pow(2, -52);
}
function foo(n1, n2){
    return Math.abs(n1 - n2) < Number.EPSILON
}
var a = 0.1 + 0.2
var b = 0.3
foo(a, b); //true

特殊的数字

1.不是数字的数字
如果数学运算的操作数不是数字类型(或者无法解析常规的十进制或十六进制数字)，就无法返回一个有效的数字，这种情况下返回值为NaN。例如

var a = 2 / "foo"; //NaN
typeof a === "number"; // true

NaN是一个警戒值，用于指出数字类型中的错误情况，即执行数学运算没有成功，这是失败后返回的结果。他是一个特殊值，她和自身不相等

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

我们可以用内建的全局工具函数isNaN(..)来判断一个值是否是NaN，但是这种方法有严重缺陷

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

对于这种现象，ES6开始使用工具函数Number.isNaN(..)

if(!Number.isNaN){
    Number.isNaN = function(n){
        return n !== n;
    }
}

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

Number.isNaN(a); //true
Number.isNaN(b); //false

2.无穷数
在javascript中1 / 0 和 - 1 / 0这种操作会返回Infinity或者-Infinity
javascript使用有限数字表示法，所以javascript的运算结果容易溢出，此时结果为Infinity或者-Infinity。
3.零值
javascript中有一个常规的0，还有一个-0

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

对-0进行字符串化会返回0

var a = 0 / -3;
a.toString(); //"0";
a + ""; //"0"

将其从字符串转换成数字，得到的结果是正确的

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

布尔

javascript中有两个关键词true和false，代表真和假，其他数据类型的值可以强制转换为布尔值。在javascript中假值有这些：
undefined,null,false,+0, -0和NaN,""。除了这些值之外其他是真值。