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,""。除了这些值以外其余是真值。