内置类型

JavaScript中有其中内置类型

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

typeof null === "object"; //truetypeof undefined === "undefined"; //truetypeof true === "boolean"; //truetypeof 42 === "number"; //truetypeof "42" === "string"; //truetypeof {life: 42} === "object"; //truetypeof 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; //2b; //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 //falsea; //"foo";b; //"FOO"

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

var a = foo;a.join; //undefineda.map;  //undefinedvar 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.2var b = 0.3foo(a, b); //true

特殊的数字

1.不是数字的数字

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

var a = 2 / "foo"; //NaNtypeof 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); //trueNumber.isNaN(b); //false

2.无穷数

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

var a = 0 / -3; // -0var 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,""。除了这些值之外其他是真值。