原生函數(shù)
　　常用的原生函數(shù)
　　　　String()
　　　　Number()
　　　　Boolean()
　　　　Array()
　　　　Object()
　　　　Function()
　　　　RegExp()
　　　　Date()
　　　　Error()
　　　　Symbol()
　　內(nèi)部屬性 [Class]
　　　　所有typeof 返回值為object 的對(duì)象都包含一個(gè)內(nèi)部屬性[Class],這個(gè)屬性無(wú)法直接訪問(wèn)，一般通過(guò)Object.prototype.toString(..) 來(lái)看。
　　　　　　例如:
　　　　　　　　Object.prototype.toString.call([1,2,3]);
　　　　　　　　　　// "[object Array]"
　　　　基本類型值
　　　　　　　　Object.prototype.toString.call(null);
　　　　　　　　　　// "[object Null]"
　　　　封裝對(duì)象包裝
　　　　　　　　由于基本類型值沒(méi)有.length 和 .toString() 這樣的屬性和方法。
　　　　封裝對(duì)象釋疑
　　　　　　想要自行封裝基本類型值，可以使用Object(..)(不帶new 關(guān)鍵字)
　　　　　　　　var a = "abc";
　　　　　　　　var b = new String(a);
　　　　　　　　var c = Object(a);
　　　　　　　　　　一般不推薦直接使用封裝函數(shù)
　　　　拆封
　　　　　　封裝對(duì)象中的基本類型值，可以使用valueOf() 函數(shù)。
　　　　　　　　var a = new String("abc");
　　　　　　　　var b = new Number(42);
　　　　　　　　var c = new Boolean(true);

a.valueOf(); // "abc"
　　　　　　　　b.valueOf(); // 42
　　　　　　　　c.valueOf(); // true
　　　　原生函數(shù)作為構(gòu)造函數(shù)
　　　　　　　　Array(..)
　　　　　　　　var a = new Array(1,2,3);
　　　　　　　　　　a; // [1,2,3]
　　　　　　　　var b = [1,2,3]
　　　　　　　　　　b; // [1,2,3]
　　　　　　構(gòu)造函數(shù)Array(..),不要求必須帶關(guān)鍵字new,不帶時(shí)他會(huì)自動(dòng)補(bǔ)上Array構(gòu)造函數(shù)只帶一個(gè)參數(shù)時(shí)候，該參數(shù)會(huì)被數(shù)組的預(yù)設(shè)長(zhǎng)度而不是當(dāng)數(shù)組中的一個(gè)元素。
　　　　　　　　var a = new Array(3);
　　　　　　　　　　a.length; // 3
　　　　　　　　　　a;
　　　　　　　　總之永遠(yuǎn)不要?jiǎng)?chuàng)建和使用空單元數(shù)組
　　　　Object(..) , Function(..) , 和RegExp(..)
　　　　　　　　除非萬(wàn)不得已，否則不要使用Object(..) / Function(..)/ RegExp(..)

Date(..) 和Error(..)
　　　　　　創(chuàng)建時(shí)間必須使用 new Date(),主要是用來(lái)獲取當(dāng)前的Unix 時(shí)間戳Date.new()然后通過(guò)日期對(duì)象中的getTime() 來(lái)獲得。

創(chuàng)建錯(cuò)誤對(duì)象(error objec) 主要是為了獲得當(dāng)前運(yùn)行的上下文。
　　　　Symbol(..)
　　　　　　基本數(shù)據(jù)類型——符號(hào)。符號(hào)具有唯一性的特殊值，用它來(lái)命名屬性不容易導(dǎo)致重名。
　　　　　　Symbol 的靜態(tài)屬性形式，Symbol.create, Symbol.iterator
　　　　　　　　　obj[Sybol.iterator] = function() {/../}
　　　　　　　　使用 Symbol(..) 原生構(gòu)造函數(shù)來(lái)自定義符號(hào)，不能帶new 關(guān)鍵字，否則報(bào)錯(cuò)。
　　　　　　　　　　var mysym = Symbol("my own symbol");
　　　　　　　　　　　　mysym; // Symbol(my own symbol)
　　　　　　　　　　　　mysym.toString(); // "Symbol(my own symbol)"
　　　　　　　　　　　　typeof mysym; // "symbol"

var a = { };
　　　　　　　　　　　　a[mysym] = "foobar";
　　　　　　　　　　　　Object.getOwnPropertySymbols(a);
　　　　　　　　　　　　 // [Symbol(my own symbol)]
　　原型類型
　　　　　　原生構(gòu)造函數(shù)有自己的 .prototype對(duì)象 如： Array.prototype,
　　　　　　　　String.prototype.
　　　　　　　　String#indexOf(..)
　　　　　　　在字符串中查找指定字符串的位置。
　　　　　　　　String#charAt(..)
　　　　　　 獲得字符串指定位置上字符
　　　　　　　　String#substr(..),String#substring(..) 和String# slice(..)
　　　　　　獲取字符串的指定部分
　　　　　　　　String#toUpperCase() 和 String#toLowerCase()
　　　　　　將字符串轉(zhuǎn)換為大寫和小寫
　　　　　　　　String#trim()
　　　　　　去掉字符串前后的空格，返回新的字符串

強(qiáng)制類型轉(zhuǎn)換
　　　　　　值的類型轉(zhuǎn)換
　　　　　　　　　　將值從一種類型轉(zhuǎn)換為另一種類型轉(zhuǎn)換，這是顯示的情況，隱式的情況通常為強(qiáng)制類型轉(zhuǎn)換。
　　　　　　　　　　JavaScript 中的類型轉(zhuǎn)換總是是返回標(biāo)量基本類型。
　　　　　　抽象值操作
　　　　　　　　ToString
　　　　　　　　　　抽象操作ToString ，它負(fù)責(zé)處理非字符串到字符串的強(qiáng)制類型轉(zhuǎn)換數(shù)組的默認(rèn)toString() 方法經(jīng)過(guò)重新定義，將所有的單元字符串化以后在連接在一起。
　　　　　　　　　　　　var a = [1,2,3];
　　　　　　　　　　　　a.toString(); // "1,2,3"
　　　　　　　　JSON字符串換，
　　　　　　　　　　JSON.stringify(..) 在對(duì)象中遇到undefined,function 和 symbol 時(shí)會(huì)自動(dòng)將其忽略，在數(shù)組中則會(huì)返回null。
　　　　　　　　　　　　例如：
　　　　　　　　　　　　　　JSON.stringify(undefined); // undefined
　　　　　　　　　　　　　　JSON.stringify(function(){}); // undefined
　　　　　　　　　　　　　　JSON.stringify(
　　　　　　　　　　　　　　　　　　[1,undefined,function(){},4]
　　　　　　　　　　　　　　　　); // "[1,null,null,4]"
　　　　　　　　　　　　　　JSON.stringify(
　　　　　　　　　　　　　　　　{a:2,b:function(){}}
　　　　　　　　　　　　　　); // "{"a":2}"

toJSON() 返回的應(yīng)該是一個(gè)適當(dāng)?shù)闹担梢允侨魏晤愋停缓笤儆蒍SON.stringify(..) 對(duì)齊進(jìn)行字符串化。
　　　　　　ToNumber
　　　　　　　　有時(shí)候需要將非數(shù)字值當(dāng)做數(shù)字來(lái)使用，比如數(shù)學(xué)運(yùn)算。
　　　　　　　　　　true 轉(zhuǎn)為 1， false 轉(zhuǎn)換為 0 ,undefined 轉(zhuǎn)換為NaN
　　　　　　　　　　null 轉(zhuǎn)換為0
　　　　　　　　為了將值轉(zhuǎn)換為相應(yīng)的基本類型，抽象操作ToPrimitive ,首先檢查該值是否有valueOf() 方法，如果有就用該值進(jìn)行強(qiáng)制類型轉(zhuǎn)換。沒(méi)有就用toString()
　　　　　　　　的返回值來(lái)進(jìn)行強(qiáng)制類型轉(zhuǎn)換。如果valueOf() 和toString() 均不會(huì)返回值就會(huì)產(chǎn)生TypeError 錯(cuò)誤。
　　　　ToBoolean
　　　　　　　假值:
　　　　　　　　值可以被分為以下兩類。
　　　　　　　　　　1.可以被強(qiáng)制類型轉(zhuǎn)換為false的值
　　　　　　　　　　2.其他(被輕質(zhì)類型轉(zhuǎn)換為true的值)
　　　　　　　　以下這些是假值
undefined
null
false
+0,-0和NaN
""
　　　　　　　　假值對(duì)象：瀏覽器在某些特定情況下，在常規(guī)JavaScript語(yǔ)法基礎(chǔ)上創(chuàng)建了一些外來(lái)值，這些就是 “假值對(duì)象”
　　　　　　真值
　　　　　　　　真值就是假值列表以外的值

顯式強(qiáng)制類型轉(zhuǎn)換
　　　　　　　　字符串和數(shù)字之間的顯示轉(zhuǎn)換
　　　　　　　　字符串和數(shù)字之間顯示強(qiáng)制類型轉(zhuǎn)換是通過(guò)String(..) 和Number(..).
　　　　　　　　兩者之間的顯式強(qiáng)制類型轉(zhuǎn)換
var a = 42;
var b = String(a);
var c = "3.14";
var d = Number(c);
b; // "42"
d: // 3.14
　　　　　　 還有其它方式實(shí)現(xiàn)字符串和數(shù)字之間的顯示轉(zhuǎn)換
var a = 42;
var b = a.toString();
var c = "3.14";
var d = +c;
b; // "42"
d: // 3.14
　　　　日期顯示轉(zhuǎn)換為數(shù)字
一元運(yùn)算符+ 的另一個(gè)常見的用途是將日期對(duì)象(Date)對(duì)象強(qiáng)制轉(zhuǎn)換為數(shù)字。
　　　　　　　　var timestamp = +new Date();
　　　　顯式解析數(shù)字字符串
　　　　　　解析字符串中的數(shù)字和將字符串強(qiáng)制類型轉(zhuǎn)換為數(shù)字的返回結(jié)果都是數(shù)字。
　　　　　　　　例如：
var a = "42";
var b = "42px";
Number(a); // 42
parseInt(a); // 42
Number(b); // NaN
parseInt(b); // 42
　　　　　　　　解析允許字符串中含有非數(shù)字字符，解析按從左到右的順序，如果遇到非數(shù)字字符就停止。
　　　　　　　　parseInt(..) 針對(duì)的是字符串，像parseInt(..) 傳遞數(shù)字和其他類型的參數(shù)是沒(méi)用的
　　　　顯示轉(zhuǎn)換為布爾值
　　　　　　ToBoolean 是顯式的ToBoolean 強(qiáng)制類型轉(zhuǎn)換：
var a = "0";
var b = [];
var c = {};

var d = "";
var e = 0;
var f = null;
var g;

Boolean(a); // true
Boolean(b); // true
Boolean(c); // true

Boolea(d); // false
Boolea(e); // false
Boolea(f); // false
Boolea(g); // false
　　　　　　一元運(yùn)算符！顯示地將值強(qiáng)制類型轉(zhuǎn)換為布爾值。
var a = "0";
var b = [];
var c = {};

var d = "";
var e = 0;
var f = null;
var g;

!!a; // true
!!b; // true
!!c; // true

!!d; // false
!!e; // false
!!f; // false
!!g; // false

隱式強(qiáng)制類型轉(zhuǎn)換
　　　　　　隱式地簡(jiǎn)化
　　　　　　　　字符串和數(shù)字之間的隱式強(qiáng)制類型轉(zhuǎn)換
　　　　　　　　+運(yùn)算符既能用于數(shù)字加法，也能用于字符串拼接。
var a = "42";
var b = "0";
var c= 42;
var d = 0;

a + b; // "42"
c + d; // 42
　　　　　　　　對(duì)象的 - 操作與 + 類似；
var a = [3];
var b = [1];
a - b ; // 2
　　　　　　布爾值到數(shù)字的隱式強(qiáng)制類型轉(zhuǎn)換
　　　　　　隱式強(qiáng)制類型轉(zhuǎn)換為布爾值
　　　　　　下面的情況會(huì)發(fā)生隱式強(qiáng)制類型轉(zhuǎn)換
1.if(..) 語(yǔ)句中的條件判斷表達(dá)式。
2.for(..;...;..)語(yǔ)句中的條件判斷表達(dá)式(第二個(gè))
3.while(..) 和do..while(..) 循環(huán)中的條件判斷表達(dá)式。
4.？ ： 中的條件表達(dá)式
5.邏輯運(yùn)算符 || (邏輯或) 和 (邏輯與) 左邊的操作數(shù)（作為條件判斷表達(dá)式）
　　　　　　|| 和 &&
|| 和 && 運(yùn)算符 的返回值并不一定是布爾類型，而是兩個(gè)操作數(shù)其中的一個(gè)的值
var a = 42;
var b = "abc";
var c = null;

a || b; // 42
a && b; // "abc"
c || b; // "abc"
c&& b; // null

對(duì)于 || 來(lái)說(shuō) 如果條件判斷結(jié)果為true 就返回第一個(gè)數(shù)的值，如果為false 就返回第二個(gè)操作數(shù)。
&& 則相反。
下面是一個(gè)|| 十分常見的 || 用法。
function foo(a,b){
a = a || "hello";
b = b || "world";
console.log(a + " " + b );
}

foo(); // "hello world"
foo("yeah","yeah"); // "yeah yeah"
符號(hào)的強(qiáng)制類型轉(zhuǎn)換
　　　　　　　　寬松相等和嚴(yán)格相等
　　　　　　　　　　“== 允許在相等比較中進(jìn)行強(qiáng)制類型轉(zhuǎn)換， 而=== 不允許”
　　　　　　　　抽象相等
　　　　　　　　　　有幾個(gè)非常規(guī)的需要注意
NaN 不等于NaN
+0 等于-0
寬松不相等 != 就是==的相反， !== 同理

字符串和數(shù)字之間的相等比較
1.如果Type(x) 是數(shù)字，Type(y)是字符串，則返回 x== ToNumber(y)
的結(jié)果。
2.如果Type(x) 是字符串，Type(y) 是數(shù)字，則返回 ToNumber(x)== y 的結(jié)果。
　　　　　　其他類型和布爾類型之間的相等比較
　　　　　　 == 最容易出錯(cuò)的地方就是true 和 false 與其他類型之間的相等比較
var a = "42";
var b = true;
a == b; // false
1.如果Type(x) 是布爾類型，則返回ToNumber(x) == y 的結(jié)果
2.如果Type(y) 是布爾類型，則返回 x == ToNumber(y) 的結(jié)果
　　　　　　　　　　首先：
var x = true;
var y = "42";
x == y; // false
反過(guò)來(lái)
var x = "42";
var y = false;
x == y; // false
　　　　　　　　　　null 和undefined 之間的相等比較
　　　　　　　　　　null 和undefinded 之間的 == 也涉及隱士強(qiáng)制類型轉(zhuǎn)換。
1.如果 x 為 null ,y 為 undefined ,則結(jié)果為 true
2.如果x 為undefined, y 為 null, 則結(jié)果為 true
var a == null;
var b;
a == b; // true
a == null; // true
b == null; // true
a == false; // false
b == false; // false
a == "" ; // false
b == ""; // false
a == 0; // false
b == 0; // false

對(duì)象和非對(duì)象之間的相等比較
　　　　　　　　關(guān)于對(duì)象和(對(duì)象/函數(shù)/ 數(shù)組) 和標(biāo)量基本類型(字符串/數(shù)字/布爾值)之間的比較。
1.如果Type(x) 是字符串或數(shù)字，type(y)是對(duì)象，則返回 x == ToPrimitive(y) 的結(jié)果
2.如果Type(x) 是對(duì)象， Type(y)是字符串或數(shù)字，則返回
　　　　　　ToPromitive(x) == y 的結(jié)果。
var a = 42;
var b = [42];
a == b; // true

var a = "abc";
var b = Object(a); // new String(a) 一樣
a === b; // false
a == b; // true
　　　　　　　　　　　　a == b 結(jié)果為true,應(yīng)為b 通過(guò)ToPromitive 進(jìn)行強(qiáng)制類型轉(zhuǎn)換，并返回基本類型值 “abc”，與 a 相等。
　　　　　　假值相等的比較
　　　　　　　　一下是常規(guī)和非常規(guī)的比較
"0" == null; // false
"0" == undefined; // false
"0" == false; // true -- 暈！
“0” == NaN; // false
"0" == 0; // true
"0" == ""; // false

false == null; // false
false == undefined; // false
false == NaN; // false
false == 0; // true -- 暈！
false == "" // true -- 暈！
false == [] // true -- 暈！
false == {} // false

"" == null; // false
"" == undefined; // false
"" == NaN; // false
"" == 0; // true -- 暈！
"" == []; // true -- 暈！
"" == {}; // false

0 == null; // false
0 == undefined; // false
0 == NaN; // false
0 == []; true -- 暈！
0 == {}; false
　　　　　　　　　　因?yàn)樗麄儗儆诩訇?yáng)。
　　　　　　極端情況
　　　　　　　　　　[] == ![] // true
　　　　　　對(duì)布爾值進(jìn)行強(qiáng)制類型轉(zhuǎn)換 [] == ![] 變成 [] == false,
　　　　　　　　　　 2 == [2]
　　　　　　　　　　"" == [null]; //true

42 == "43" // false
"foo" == 42; // false
"true" = '"" // false

42 == "42" // true
"foo" == ["foo"] // true
　　　　　　安全運(yùn)用隱式強(qiáng)制類型轉(zhuǎn)換
1.如果兩邊的值中有true 或者 false, 千萬(wàn)不要使用 ==.
2.如果兩邊的之中有[],"" 或者 0 ，盡量千萬(wàn)不要使用==.這時(shí)候最好使用 === 來(lái)避免強(qiáng)制類型的轉(zhuǎn)換。

抽象關(guān)系比較
　　　　　　　　雙方都是字符串比較
var a = ["42"];
var b = ["043"];

a < b; // false
a 和b 并沒(méi)有被準(zhǔn)換為數(shù)字，因?yàn)門oPrimitive 返回的是字符串，
比較的是 "42 " 和 "043" 兩個(gè)字符串， 因?yàn)?0"在字母順序上小于
“4”，所以最后結(jié)果為 false.
　　　　　　同理
var a = [4,2];
var b = [0,4,3];
a < b; // false
a 被轉(zhuǎn)為 “4,2”，b 轉(zhuǎn)為 “0,4,3” 同樣式按字母順序進(jìn)行比較的。
var a = {b: 42};
var b = {b:43};
a < b ; // false
a 是 [object Object], b也是 [object Object] 所以按著字母順序
a < b 不成立。
　　　　下面的例子
var a = {b: 42};
var b = {b:43};
a < b; // false
a == b; // false
a > b; // false
a <= b; // true
a >= b; // true