Boolean：false
Number：NaN
String："undefined"

null表示對(duì)象不存在 document.getElementById("notExitElement");

Boolean：false
Number：0
String："null"

條件語句導(dǎo)致系統(tǒng)執(zhí)行的隱式類型轉(zhuǎn)換 if(document.getElementById("notExitElement");){...}

字面量或變量定義： true, var a = true;

只有以下6個(gè)值會(huì)被轉(zhuǎn)換為false：

undefined
null
false
0
NaN
""或""（空字符串）

注意：空數(shù)組[]和空對(duì)象{}，對(duì)應(yīng)的布爾值都是true。

Number：1 0
String："true" "false"

"abbv" "lll"

String：  ""    "123"  "notEmpty"
Number：  0      123      NaN
Boolean：false  true     true

123 var a = 1;

Number：  0      123      NaN   Infinity
Boolean：false   true     true    false
String：  "0"   "123"    "NaN"  "Infinity"

十進(jìn)制：沒有前導(dǎo)0的數(shù)值。
八進(jìn)制：有前綴0o或0O的數(shù)值，或者有前導(dǎo)0、且只用到0-7的七個(gè)阿拉伯?dāng)?shù)字的數(shù)值。
十六進(jìn)制：有前綴0x或0X的數(shù)值。
二進(jìn)制：有前綴0b或0B的數(shù)值。

一組屬性的集合。

{a: "value-a", b: "value-b", ...}

Object:  {}
Number：  NaN 
Boolean： true 
String：  "[object Object]"

主要介紹typeof、Object.prototype.toString、constructor、instanceof等類型識(shí)別的方法。

typeof 1 // number
typeof true // boolean
typeof "str" // string
typeof undefined // undefined
typeof null // object
typeof {} // object

也就是說，標(biāo)準(zhǔn)數(shù)據(jù)類型中，除了null被識(shí)別為object，其余類型都識(shí)別正確。

另外，需要注意typeof undefined 會(huì)得到 undefined，利用這一點(diǎn)，typeof可用于檢查一個(gè)沒有聲明的變量而不報(bào)錯(cuò)：

if(a) { ... }
//Uncaught ReferenceError: a is not defined

if(typeof a === "undefined") { console.log("未定義也不報(bào)錯(cuò)") }
//未定義也不報(bào)錯(cuò)

typeof function(){} // function
typeof [] // object
typeof new Date(); // object
typeof /d/; // object
function Person() {};
typeof new Person; // object

因此，不能識(shí)別具體的對(duì)象類型，函數(shù)對(duì)象除外。

Object.prototype.toString.call(1); // "[object Number]"

所以我們寫一個(gè)函數(shù)來簡(jiǎn)化調(diào)用，以及截取我們需要的部分：

function type(obj){
  return Object.prototype.toString.call(obj).slice(8, -1).toLowerCase();
}

type(1) // number
type("str") // string
type(true) // boolean
type(undefined) //undefined
type(null) //null
type({}) //object
type([]) //array
type(new Date) // date
type(/d/) // regexp
type(function(){}) // function

Object.prototype.toString可以準(zhǔn)確識(shí)別出所有的標(biāo)準(zhǔn)類型以及內(nèi)置(build-in)對(duì)象類型。

那么自定義類型呢？

function Point(x, y){
  this.x = x;
  this.y = y;
}

type(new Point(1, 2)) //object

所以它無法識(shí)別出自定義類型。

對(duì)象原型上的一個(gè)屬性，它指向了構(gòu)造器本身。

可以識(shí)別原始數(shù)據(jù)類型（undefined和null除外，因?yàn)樗鼈儧]有構(gòu)造器）,內(nèi)置對(duì)象類型和自定義對(duì)象類型，尤其注意自定義對(duì)象類型（如：Person）。

//判斷原始類型
"Jerry".constructor === String //true
(1).constructor === Number //true
true.constructor === Boolean //true
({}).constructor === Object //true
//判斷內(nèi)置對(duì)象
[].constructor === Array //true
//判斷自定義對(duì)象 ヾ(o???)?
function Person(name){
  this.name = name;
}
new Person("Jerry").constructor === Person // true ヾ(o???)? !!!

//判斷原始類型
1 instanceof Number // false
true instanceof boolean // false
//判斷內(nèi)置對(duì)象類型
[] instanceof Array // true
// instanceof RegExp // true
//判斷自定義對(duì)象類型
function Person(name){
  this.name = name;
}
new Person("miao") instanceof Person // true

不能判斷原始類型，可以判斷內(nèi)置對(duì)象類型，可以判斷自定義對(duì)象類型及父子類型。

分為兩類：普通對(duì)象與構(gòu)造器對(duì)象。其中，構(gòu)造器對(duì)象可用于實(shí)例化普通對(duì)象。

普通對(duì)象只有自身的屬性和方法。
構(gòu)造器對(duì)象除了自身的屬性和方法之外，還有原型對(duì)象prototype上的屬性和方法，以及實(shí)例化出來的對(duì)象的屬性和方法。

以下代碼創(chuàng)建了一個(gè)Point構(gòu)造器并實(shí)例化了一個(gè)p對(duì)象

function Point(x, y){
    this.x = x;
    this.y = y;
}
Point.prototype.move = function(x, y){
    this.x += x;
    this.y += y;
}
var p = new Point(1,1);
p.move(1,2);

"__proto__"是對(duì)象的一個(gè)內(nèi)部隱藏屬性。
"__proto__"是對(duì)實(shí)例化該對(duì)象的構(gòu)造器的prototype屬性的一個(gè)引用，因此可以訪問prototype的所有屬性和方法。
除了Object對(duì)象，每個(gè)對(duì)象都有一個(gè)"__proto__"屬性，"__proto__"逐級(jí)增長(zhǎng)形成一個(gè)鏈就是我們所說的原型鏈，原型鏈頂端是一個(gè)Object對(duì)象。
當(dāng)開發(fā)者調(diào)用對(duì)象屬性或方法時(shí)(比如"p.move(1,2)")，引擎首先會(huì)查找p對(duì)象的自身屬性，如果自身屬性中沒有"move"方法，則會(huì)繼續(xù)沿原型鏈逐級(jí)向上查找，直到找到該方法并調(diào)用。
"__proto__"跟瀏覽器引擎實(shí)現(xiàn)相關(guān)，不同的引擎中名字和實(shí)現(xiàn)不盡相同(chrome、firefox中名稱是"__proto__"，并且可以被訪問到，IE中無法訪問)?；诖a兼容性、可讀性等方面的考慮，不建議開發(fā)者顯式訪問"__proto__"屬性或通過"__proto__"更改原型鏈上的屬性和方法，可以通過更改構(gòu)造器prototype對(duì)象來更改對(duì)象的__proto__屬性。

Point.prototype其實(shí)就是個(gè)普通對(duì)象：

Point.prototype = {
  move: function(){ ... },
  constructor: function(){ ... }
}

1.構(gòu)造器對(duì)象原型鏈上倒數(shù)第二個(gè)__proto__是一個(gè)Function.prototype對(duì)象引用,因此可以調(diào)用Function.prototype的屬性和方法。
2.構(gòu)造器對(duì)象本身有一個(gè)prototype屬性，有這個(gè)屬性就表明該對(duì)象可以用來生成其他對(duì)象：用該構(gòu)造器實(shí)例化對(duì)象時(shí)該prototype會(huì)被實(shí)例對(duì)象的__proto__所引用，即添加到實(shí)例對(duì)象的原型鏈上。
3.構(gòu)造器對(duì)象本身是一個(gè)function對(duì)象，因此會(huì)有name,length等自身屬性。

對(duì)象的所有鍵名都是字符串，鍵名加不加引號(hào)都可以。

用于創(chuàng)建對(duì)象的下面三行語句是等價(jià)的：

var o1 = {};
var o2 = new Object();
var o3 = Object.create(Object.prototype);

String/Number/Boolean/Array/Date/Error構(gòu)造器都是Object子類對(duì)象。

自身的屬性、方法：prototype，create，keys，getOwnPropertyNames，getOwnPropertyDescriptor，getPrototypeOf

原型對(duì)象prototype的屬性和方法：constructor，toString，valueOf，hasOwnProperty，isPrototypeOf

生成的實(shí)例對(duì)象只有原型鏈屬性__proto__，沒有其他的屬性，也就是Object沒有實(shí)例對(duì)象屬性，方法。相比較而言，Array有實(shí)例對(duì)象屬性length，也就是說，Arrya類型的實(shí)例對(duì)象有length屬性。

幾個(gè)重要方法：

Object.create(proto) ： 基于原型對(duì)象創(chuàng)建新對(duì)象，傳入的是一個(gè)對(duì)象，會(huì)被作為創(chuàng)建出的對(duì)象的__proto__屬性值。

Object.keys(obj)：返回一個(gè)由obj自身所擁有的可枚舉屬性的屬性名組成的數(shù)組。比如：

var obj = { a: "aaa", b: "bbb"};
Object.keys(obj); // ["a", "b"]

var arr = ["a", "b", "c"];
Object.keys(arr); // ["0", "1", "2"]

如果想要對(duì)象上不可枚舉的屬性也被列舉出來，用Object.getOwnPropertyNames(obj)方法。比如：

var arr = ["a", "b", "c"];
Object.getOwnPropertyNames(arr); // ["0", "1", "2", "length"]

Object.getOwnPropertyDescriptor(obj, "prop") 可以讀出對(duì)象自身屬性的屬性描述對(duì)象。

var obj = { prop1: "hello"};
Object.getOwnPropertyDescriptor(obj, "prop1");
//Object {value: "a", writable: true, enumerable: true, configurable: true}

Object.getPrototypeOf(obj)獲取對(duì)象的Prototype對(duì)象。

Object.prototype.valueOf ：返回指定對(duì)象的原始值

這個(gè)方法幾乎不會(huì)手動(dòng)調(diào)用，而是JavaScript自動(dòng)去調(diào)用將一個(gè)對(duì)象轉(zhuǎn)換成原始值（primitive value）。
默認(rèn)情況下，每一個(gè)內(nèi)置對(duì)象都會(huì)覆蓋這個(gè)方法返回一個(gè)合理的值。如果對(duì)象沒有原始值，這個(gè)方法就會(huì)返回對(duì)象自身。比如：

//有原始值
var num= new Number(3);
num; // {[[PrimitiveValue]]: 3}
num.valueOf(); // 3
num + 4; // 7 valueOf()被JavaScript隱式調(diào)用了

//沒有原始值
var obj = {"a": "aaa"}
obj.valueOf(); // {"a": "aaa"}

假設(shè)你有一個(gè)對(duì)象類型的myNumberType，你想為它創(chuàng)建一個(gè)valueOf方法。下面的代碼可以自定義一個(gè)valueOf方法：

function myNumberType (n){
  this.number = n;
}
myNumberType.prototype.valueOf = function () {
  return this.number;
}
var obj = new myNumberType(4);
obj + 3; // 7 自定義的valueOf方法被JavaScript自動(dòng)調(diào)用了

Object.prototype.toString ：獲取方法調(diào)用者的標(biāo)準(zhǔn)類型

默認(rèn)情況下，toString() 方法被每個(gè)繼承自O(shè)bject的對(duì)象繼承。如果此方法在自定義對(duì)象中未被覆蓋，toString() 返回 "[object type]",其中type是對(duì)象類型。以下代碼說明了這一點(diǎn)：

var obj = {a: 1};
obj.toString(); // "[object Object]"

很多內(nèi)置對(duì)象重寫了toString方法。包括Array，Boolean，Number，Date，String例如：

var a = new Number(1)
b = a.toString(); // "1"

//可用于進(jìn)行進(jìn)制轉(zhuǎn)換
var num1 = 10;
num1.toString(16); // "a"
num1.toString(2); // "1010"
num1.toString(8); // "12"

var c = new String("abc")
d = c.toString(); // "abc"

var e = new Array(["a", "b", "c"])
f = e.toString(); // "a,b,c"

還可以用來檢查對(duì)象類型：

var toString = Object.prototype.toString;

toString.call(new Date); // [object Date]
toString.call(new String); // [object String]
toString.call(Math); // [object Math]
toString.call(1); // [object Number]
toString.call("1"); // [object String]

//Since JavaScript 1.8.5
toString.call(undefined); // [object Undefined]
toString.call(null); // [object Null]

Object.prototype.hasOwnProperty ：判斷一個(gè)屬性是對(duì)象自身屬性，還是原型上的屬性。

var obj = Object.create({a:1});
obj.b = 2;
obj.hasOwnProperty("a"); //false
obj.hasOwnProperty("b"); //true

Object.property.isPrototypeOf：判斷當(dāng)前對(duì)象是否為另一個(gè)對(duì)象的原型。

var father = { a: "aaa", b: "bbb"};
var child = Object.create(father);
father.isPrototypeOf(child); // true

delete命令用于刪除對(duì)象的屬性，不管該屬性是否存在，刪除后都返回true，只有當(dāng)該屬性的configurable: false時(shí)，刪除操作才返回false，也就是該屬性不得刪除。

var o = { p: "Hello"}
delete o.p;
o; // Object{}

注意：delete不得刪除var定義的變量。

in運(yùn)算符用于檢查對(duì)象是否包含某個(gè)屬性（這里寫的是屬性的鍵名）。存在返回true?？梢杂糜谂袛嗳肿兞渴欠翊嬖凇?/p>

var o = {p: "hello"}
"p" in o; // true

"o" in window; // true

存在的問題是：in運(yùn)算符對(duì)于繼承的屬性也返回true。

for ... in循環(huán)用來遍歷一個(gè)對(duì)象的全部屬性。

var o = { a: "hello", b: "world"};
for( var key in o) {
  console.log(key + ": " + o[key]);
}
//a: hello
//b: world

注意：會(huì)遍歷繼承來的屬性。所以一般不推薦使用。一般會(huì)用Object.keys(obj)，可以只遍歷對(duì)象本身的屬性。

使用String()和Number()方法可以將各種類型的值強(qiáng)制轉(zhuǎn)換為string或number類型。比如：

Number("222"); //222
Number(null); // 0
Number(undefined); // NaN

String(new Number(2)); // "2"
String(["a", "b"]); //"a,b"

但當(dāng)轉(zhuǎn)換的數(shù)值為對(duì)象時(shí)，轉(zhuǎn)換規(guī)則為：

Number(obj)：(簡(jiǎn)單地說值為NaN)

1.先調(diào)用對(duì)象自身的valueOf()方法，如果返回原始類型的值，那么直接對(duì)該值使用Number函數(shù)，不再進(jìn)行后續(xù)步驟。
2.如果valueOf方法返回的值類型是對(duì)象，那么調(diào)用這個(gè)對(duì)象的toString()方法，如果返回的是原始類型的值，那么對(duì)這個(gè)值使用Number()方法，不再進(jìn)行后續(xù)步驟。
3.如果toString返回的是對(duì)象，就報(bào)錯(cuò)。

var obj = {a: 1};
Number(obj); // NaN
//等同于
if(typeof obj.valueOf() === "object") {
    Number(obj.toString());
} else {
    Number(obj.valueOf());
}

String(obj)：

1.先調(diào)用對(duì)象自身的toString()方法，如果返回原始類型的值，那么直接對(duì)該值使用String函數(shù)，不再進(jìn)行后續(xù)步驟。
2.如果toString方法返回的值類型是對(duì)象，那么調(diào)用這個(gè)對(duì)象的valueOf()方法，如果返回的是原始類型的值，那么對(duì)這個(gè)值使用String()方法，不再進(jìn)行后續(xù)步驟。
3.如果valueOf返回的是對(duì)象，就報(bào)錯(cuò)。

var obj = {a: 1}
String(obj); // [object Object]
//等價(jià)于
if(typeof obj.toString() === "object") {
    String(obj.valueOf());
} else {
    String(obj.toString());
}

構(gòu)造器對(duì)象屬性、方法：prototype， fromCharCode

原型對(duì)象屬性、方法：constructor，indexOf，replace，slice，charCodeAt，toLowerCase

幾個(gè)重要方法：

1.String.prototype.indexOf：獲取子字符串在字符串中位置索引（一次只查找一個(gè)）

語法：strObj.indexOf(searchvalue,fromindex)

var str = "abcdabcd";
var idx = str.indexOf("b"); // 1
var idx2 = str.indexOf("b", idx+1); //5

2.String.prototype.replace：查找字符串替換成目標(biāo)字符（一次只替換一個(gè)）

語法：strObj.replace(regexp/searchvalue, newSubStr/function)

var str = "1 plus 1 equal 3";
str = str.replace("1","2"); // "2 plus 1 equal 3"
str = str.replace(/d+/g, "$& dollar"); //"2 dollar plus 1 dollar equal 3 dollar"

第二個(gè)參數(shù)是newSubStr時(shí)，其中

$& 代表插入當(dāng)前匹配的子串
$` 代表插入當(dāng)前匹配的子串左邊的內(nèi)容
$" 代表插入當(dāng)前匹配的子串右邊的內(nèi)容
$n 是當(dāng)?shù)谝粋€(gè)參數(shù)為regexp對(duì)象，且n為小于100的非負(fù)整數(shù)時(shí)，插入regexp第n個(gè)括號(hào)匹配到的字符串

第二個(gè)參數(shù)是function時(shí)，函數(shù)的返回值為替換的字符串，注意如果第一個(gè)參數(shù)為regexp且為全局匹配，那么每次匹配都會(huì)調(diào)用這個(gè)函數(shù)，把匹配到的值用函數(shù)的返回值替換。函數(shù)參數(shù)：

match：匹配的子串，相當(dāng)于 $&
p1,p2,...: 如果第一個(gè)參數(shù)為regexp，對(duì)應(yīng)第n個(gè)括號(hào)匹配到的字符串，相當(dāng)于$1,$2
offset: 匹配到的字符串到原字符串中的偏移量，比如 bc 相對(duì)于 abcd ，offset 為1
string: 被匹配的原字符串
//精確的參數(shù)個(gè)數(shù)取決于第一個(gè)參數(shù)是否為regexp，以及有多少個(gè)括號(hào)分組

3.String.prototype.split：按分割符將字符串分割成字符串?dāng)?shù)組

語法：strObj.split(separator, howmany)

var str = "1 plus 1 equal 3";
str.split(" "); // ["1", "plus", "1", "equal", "3"]
str.split(" ", 3); // ["1", "plus", "1"]
str.split(/d+/); //["", " plus ", " equal ", ""]

4.str.slice(beginSlice[, endSlice]) 提取一個(gè)字符串的一部分，并返回一個(gè)新的字符串

var str = "abcdefg";
str.slice(1,3); // "bc"
str; //"abcdefg"

5.str.substr(start[, length])返回從start開始，length個(gè)數(shù)的字符串

var str = "abcdefg";
str.substr(1,3); //"bcd"
str; //"abcdefg"

6.str.substring(start[, end]) 返回從start開始到end（不包括end）結(jié)束的字符串。其中，start和end都大于0.

var str = "abcdefg";
str.substring(1,3); //"bc"
str; //"abcdefg"

7.str.trim() 返回的是一個(gè)新字符串，刪除了原字符串兩端的空格

var str = "  abc  ";
str.trim(); // "abc"
str; // "  abc  "

8.str.charAt(index) 從一個(gè)字符串中返回index位置的字符，indx默認(rèn)是0

var str = "abcdefg";
str.charAt(1); //"b"

9.str.concat(string2, string3[, ..., stringN])返回新字符串，將原字符串與一個(gè)或多個(gè)字符串相連

var str = "abc";
var str2 = "123";
str.concat(str2);// "abc123"

強(qiáng)烈建議使用 賦值操作符（+, +=）代替 concat 方法。

10.str.includes(searchString[, position])判斷searchString是否包含在str中，返回布爾值。

var str = "abc";
str.includes("ab"); //true

11.str.indexOf(searchValue[, fromIndex]) 返回str中searchValue第一次出現(xiàn)的位置，沒找到返回-1

"Blue Whale".indexOf("Blute");    // returns -1
"Blue Whale".indexOf("Whale", 0); // returns  5

12.str.lastIndexOf(searchValue[, fromIndex]) 返回str中searchValue最后一次出現(xiàn)的位置，沒找到返回-1

"abcabc".lastIndexOf("a")   // returns 3
"abcabc".lastIndexOf("d")   // returns -1
"abcabc".lastIndexOf("a",2) // returns 0
"cbacba".lastIndexOf("a",0) // returns -1

13.str.endsWith(searchString [, position]);屬于ES6.判斷searchString是否是以另外一個(gè)給定的字符串結(jié)尾的，返回布爾值

var str = "To be, or not to be, that is the question.";

str.endsWith("question.");  // true
str.endsWith("to be");      // false
str.endsWith("to be", 19);  // true
str.endsWith("To be", 5);   // true

14.str.match(regexp);當(dāng)一個(gè)字符串與一個(gè)正則表達(dá)式匹配時(shí)，match()方法檢索匹配項(xiàng)。 返回一個(gè)包含了整個(gè)匹配結(jié)果以及任何括號(hào)捕獲的匹配結(jié)果的 Array ；如果沒有匹配項(xiàng)，則返回 null 。

如果正則表達(dá)式?jīng)]有 g 標(biāo)志，則 str.match() 會(huì)返回和 RegExp.exec() 相同的結(jié)果。

如果正則表達(dá)式包含 g 標(biāo)志，則該方法返回一個(gè) Array ，它包含所有匹配的子字符串而不是匹配對(duì)象。

var str = "For more information, see Chapter 3.4.5.1";
var re = /see (chapter d+(.d)*)/i;
var found = str.match(re);

console.log(found);

// logs [ "see Chapter 3.4.5.1",
//        "Chapter 3.4.5.1",
//        ".1",
//        index: 22,
//        input: "For more information, see Chapter 3.4.5.1" ]

// "see Chapter 3.4.5.1" 是整個(gè)匹配。
// "Chapter 3.4.5.1" 被"(chapter d+(.d)*)"捕獲。
// ".1" 是被"(.d)"捕獲的最后一個(gè)值。
// "index" 屬性(22) 是整個(gè)匹配從零開始的索引。
// "input" 屬性是被解析的原始字符串。

15.str.search(regexp)執(zhí)行正則表達(dá)式和String對(duì)象之間的一個(gè)搜索匹配。如果匹配成功，則 search() 返回正則表達(dá)式在字符串中首次匹配項(xiàng)的索引。否則，返回 -1。

下例記錄了一個(gè)消息字符串，該字符串的內(nèi)容取決于匹配是否成功。

function testinput(re, str){
  var midstring;
  if (str.search(re) != -1){
    midstring = " contains ";
  } else {
    midstring = " does not contain ";
  }
  console.log (str + midstring + re);
}

16.str1.localeCompare(str2) 比較兩個(gè)字符串，返回一個(gè)整數(shù)，如果小于0，表示第一個(gè)字符串小于第二個(gè)字符串；如果大于0，表示第一個(gè)字符串大于第二個(gè)字符串。

"apple".localeCompare("banana"); //-1

該方法最大的特點(diǎn)就是會(huì)考慮語言的順序?？聪旅娴睦樱?/p>

"B" > "a" // false 因?yàn)閁nicode編碼中，大寫字母都在小寫字母前面：B的碼點(diǎn)是66，而a的碼點(diǎn)是97。

"B".localeCompare("a"); //1 考慮了語言的自然順序

Number.prototype.toFixed() 用于將一個(gè)數(shù)轉(zhuǎn)換為指定位數(shù)（有效范圍為0到20）的小數(shù)，返回這個(gè)小數(shù)對(duì)應(yīng)的字符串。

var a = 1.234
a.toFixed(2);//1.23

Number.prototype.toExponential() 用于將一個(gè)數(shù)轉(zhuǎn)為科學(xué)計(jì)數(shù)法形式。參數(shù)為保留的小數(shù)位數(shù)，有效范圍0-20。

(1234).toExponential()  // "1.234e+3"
(1234).toExponential(1) // "1.2e+3"
(1234).toExponential(2) // "1.23e+3"

Number.prototype.toPrecision() 用于將一個(gè)數(shù)字轉(zhuǎn)為指定位數(shù)的有效數(shù)字。參數(shù)為有效數(shù)字的位數(shù)，范圍1-21。

(12.34).toPrecision(1) // "1e+1"
(12.34).toPrecision(2) // "12"
(12.34).toPrecision(4) // "12.34"
(12.34).toPrecision(5) // "12.340"

記?。?/p>

Boolean(undefined) // false
Boolean(null) // false
Boolean(0) // false
Boolean("") // false
Boolean(NaN) // false

Boolean(1) // true
Boolean("false") // true
Boolean([]) // true
Boolean({}) // true
Boolean(function () {}) // true
Boolean(/foo/) // true

length屬性是可寫的，如果設(shè)置length到小于數(shù)組當(dāng)前長(zhǎng)度，那么數(shù)組長(zhǎng)度會(huì)縮短。
因此，將數(shù)組清空的一個(gè)有效方法，就是將數(shù)組的length設(shè)置為0。舉例如下：

var arr = [1,2,3];
arr.length = 0;
arr; []

當(dāng)length屬性設(shè)為大于數(shù)組個(gè)數(shù)時(shí)，讀取新增的位置都會(huì)返回undefined。

注意：只要有l(wèi)ength的對(duì)象就是類數(shù)組對(duì)象。典型的類似數(shù)組的對(duì)象是函數(shù)的arguments對(duì)象，以及大多數(shù)DOM元素集，還有字符串。

將類數(shù)組對(duì)象轉(zhuǎn)化為對(duì)象的方法是：var arr = Array.prototype.slice.call(arrayLike);。

幾個(gè)常用對(duì)象方法：

Array.prototype.sort：排序，并返回?cái)?shù)組

語法： arr.sort([compareFunction])

如果compareFunction(a, b)返回值小于0，a在b前；返回值大于0，a在b后。

比較函數(shù)格式如下：

function compare(a, b) {
  if (a is less than b by some ordering criterion) {
    return -1;
  }
  if (a is greater than b by the ordering criterion) {
    return 1;
  }
  // a must be equal to b
  return 0;
}

希望比較數(shù)字而非字符串，比較函數(shù)可以簡(jiǎn)單的以 a 減 b，如下的函數(shù)將會(huì)將數(shù)組升序排列

function compareNumbers(a, b) {
  return a - b;
}

var fruit = ["cherries", "apples", "bananas"];
fruit.sort(); 
// ["apples", "bananas", "cherries"]

var scores = [1, 10, 21, 2]; 
scores.sort(); 
// [1, 10, 2, 21]
// 注意10在2之前,
// because "10" comes before "2" in Unicode code point order.

var things = ["word", "Word", "1 Word", "2 Words"];
things.sort(); 
// ["1 Word", "2 Words", "Word", "word"]
// 在Unicode中, 數(shù)字在大寫字母之前,
// 大寫字母在小寫字母之前.

var numbers = [4, 2, 5, 1, 3];
numbers.sort(function(a, b) {
  return a - b;
});
console.log(numbers);

// [1, 2, 3, 4, 5]

2.Array.prototype.splice(start[, deleteCount, item1, item2, ...])：從數(shù)組中添加、刪除或替換元素，并返回被刪除的元素列表。會(huì)更改原數(shù)組。如果deleteCount被省略，則其相當(dāng)于(arr.length - start)。

var arr = [1,2,3,4];
let deleteArr = arr.splice(1, 2, "a", "b");
deleteArr; //[2, 3]
arr; // [1, "a", "b", 4]

3.Array.prototype.forEach：遍歷數(shù)組元素并調(diào)用回調(diào)函數(shù)

語法：arr.forEach(callback[,thisArg])
function callback(value, index, array){ ... }

var arr = ["a", ,"b"];
arr.forEach(function(value, index, array){ console.log(value);}) 
//"a" 
//"b"
//空元素被跳過去了哦 (,? ? ?,) 

注意：forEach方法無法中斷執(zhí)行，總會(huì)將所有成員遍歷完，如果希望符合某種條件就中斷執(zhí)行，需要使用 for 循環(huán)。

4.arr.filter(callback) 返回一個(gè)新數(shù)組，包含通過了callback函數(shù)中的過濾條件的所有元素

語法：

let newArr = arr.filter(function(element, index, array){ ... })

function isBigEnough(value) {
  return value >= 10;
}

var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);

// filtered is [12, 130, 44]

5.arr.map(callback)返回一個(gè)新數(shù)組，結(jié)果是該數(shù)組中的每個(gè)元素調(diào)用提供的callback函數(shù)之后的結(jié)果

語法：

let newArr = arr.map(function(element, index, array){ ... })

let numbers = [1, 5, 10, 15];
let roots = numbers.map(function(x, index, array) {
    return x * 2;
});
// roots is now [2, 10, 20, 30]
// numbers is still [1, 5, 10, 15]

當(dāng)需要返回值的時(shí)候，一般使用map；不需要時(shí)，一般使用forEach。

6.arr.every(callback)測(cè)試數(shù)組的所有元素是否都通過了指定函數(shù)的測(cè)試，返回一個(gè)布爾值。

語法：

let passed = arr.every(function(element, index, array){ ... })

function isBigEnough(element, index, array) {
  return (element >= 10);
}
var passed = [12, 5, 8, 130, 44].every(isBigEnough);
// passed is false
passed = [12, 54, 18, 130, 44].every(isBigEnough);
// passed is true

7.arr.concat(arr1[, arr2, ...])合并兩個(gè)或多個(gè)數(shù)組

let arr3 = arr1.concat(arr2);

8.arr.slice(begin, end)返回一個(gè)從begin到end（不包括end）這之間的數(shù)組淺拷貝到一個(gè)新的數(shù)組對(duì)象。原始數(shù)組不會(huì)被修改。

var arr = [1,2,3,4];
let newArr = arr.slice(1,3);
arr; //[1,2,3,4];
newArr; //[2,3];

arr.slice(); // [1,2,3,4] 不加參數(shù)時(shí)返回原數(shù)組的拷貝

9.arr.indexOf(searchVal[, fromIndex = 0])返回在數(shù)組中可以找到的給定元素的第一個(gè)索引，不存在返回-1

10.arr.lastIndexOf(searchVal[, fromIndex = arr.length - 1])返回在數(shù)組中可以找到的給定元素的最后一個(gè)索引，不存在返回-1

11.arr.reduce() 從左到右依次處理數(shù)組的每個(gè)成員，最終累計(jì)為一個(gè)值。

方法的第一個(gè)參數(shù)是一個(gè)函數(shù)，這個(gè)函數(shù)接收4個(gè)參數(shù)：
1.累積變量：默認(rèn)數(shù)組的第一個(gè)變量
2.當(dāng)前變量：默認(rèn)數(shù)組的第二個(gè)變量
3.當(dāng)前位置（從0開始）
4.原數(shù)組

前兩個(gè)參數(shù)是必須的。

求數(shù)組成員之和：

var arr = [1,2,3,4,5];
arr.reduce(function(x, y) {
  console.log(x, y);
  return x + y;
})
// 1 2
// 3 3
// 6 4
// 10 5
// 15

第一輪執(zhí)行，x是數(shù)組的第一個(gè)成員，y是數(shù)組的第二個(gè)成員。從第二輪開始，x為上一輪的返回值，y為當(dāng)前數(shù)組成員，直到遍歷完所有成員，返回最后一輪計(jì)算后的x。

如果要對(duì)累積變量指定初值，可以把它放在reduce方法和reduceRight方法的第二個(gè)參數(shù)。

var arr = [1,2,3,4,5];
arr.reduce(function(x, y) {
  console.log(x, y);
  return x + y;
}, 10)
// 10 1
// 11 2
// 13 3
// 16 4
// 20 5
// 25

由于 reduce 方法依次處理每個(gè)元素，所以它實(shí)際上還可以用來搜索某個(gè)元素。比如，找出長(zhǎng)度最長(zhǎng)的數(shù)組元素：

function findLongest(entries) {
    return entries.reduce(function (longest, entry){
        return longest.length > entry.length ? longest : entry;
    })
}
findLongest(["aaa", "bbbb", "cc"])

采用function命令聲明函數(shù)時(shí)，整個(gè)函數(shù)會(huì)像變量聲明一樣被提升到代碼頭部。比如下面的代碼不會(huì)報(bào)錯(cuò)：

f();
function f() { ... }

但是下面的代碼卻會(huì)報(bào)錯(cuò)：

f();
var f = function () { ... }　　

//相當(dāng)于下面這樣
var f;
f();
f = function(){ ... }

自身屬性，方法：prototype
原型對(duì)象屬性，方法：constructor，apply，call，bind
實(shí)例對(duì)象屬性，方法：name，length，prototype ，arguments，caller

name 返回緊跟在 function 關(guān)鍵字之后的函數(shù)名。

length 返回函數(shù)定義中的參數(shù)個(gè)數(shù)。

toString() 返回函數(shù)的源碼。f.toString()

幾個(gè)常用對(duì)象方法：

語法：funcObj.apply(thisArg[, argsArray])

thisArg : 函數(shù)運(yùn)行時(shí)指定的this值
argsArray : 一個(gè)數(shù)組或類數(shù)組對(duì)象

栗子：

(1) Object.prototype.toString.apply("123");// "[object String]"

(2) 使用apply可以允許你在本來需要遍歷數(shù)組變量的任務(wù)中使用內(nèi)建的函數(shù)，比如獲得一個(gè)數(shù)組中最大的值：

var arr = [2, 3, 7, 1];
Math.max.apply(null, arr);// 7 
//這等價(jià)于 Math.max(arr[0], arr[1], arr[2], arr[3])

(3) 還可以用于 使用任意一個(gè)對(duì)象（可以不是當(dāng)前自定義對(duì)象的實(shí)例對(duì)象）去調(diào)用自定義對(duì)象中定義的方法

function Point(x, y) {
  this.x = x;
  this.y = y;
}
Point.prototype.move = function(x1, y1) {
  this.x += x1;
  this.y += y1;
} 
var p = new Point(0,0); //p是一個(gè)點(diǎn)
p.move(2,2); // p這個(gè)點(diǎn)的位置在x軸右移了2，y軸右移了2
//等價(jià)于
p.move.apply(p, [2,2]);

//現(xiàn)在我們有一個(gè)圓，原點(diǎn)位于(1,1)，半徑r=1
var c = {x: 1, y: 1, r: 1}
//要求x軸右移2，y軸右移1
p.move.apply(c, [2,1]);

語法：funcObj.bind(thisArg[, args])

thisArg : 函數(shù)運(yùn)行時(shí)指定的this值
args : 一個(gè)列表(不是數(shù)組)

栗子：

（1）綁定函數(shù)調(diào)用的this值，避免錯(cuò)誤的使用了將this指向全局作用域

this.x = 9; 
var module = {
  x: 81,
  getX: function() { return this.x; }
};

module.getX(); // 返回 81

var retrieveX = module.getX;
retrieveX(); // 返回 9, 在這種情況下，"this"指向全局作用域

// 創(chuàng)建一個(gè)新函數(shù)，將"this"綁定到module對(duì)象
// 新手可能會(huì)被全局的x變量和module里的屬性x所迷惑
var boundGetX = module.getX.bind(module);
boundGetX(); // 返回 81

（2）返回函數(shù)的引用而并不調(diào)用的另一個(gè)好處是：可以指定函數(shù)執(zhí)行的時(shí)間。比如有的需求是，在過了一段時(shí)間后執(zhí)行這個(gè)函數(shù)。

還是上面Point的例子，要求在1000ms以后移動(dòng)圓：

var c = {x: 1, y: 1, r: 1}
//要求x軸右移2，y軸右移1
var circlemove = p.move.bind(c, 2, 1);
setTimeout(circlemove, 1000);

上面例子中，調(diào)用其他對(duì)象的方法也可以通過繼承的方法實(shí)現(xiàn)：

function Circle(x, y ,r) {
  Point.apply(this, [x, y]);
  this.radius = r;
}
//將Circle的原型對(duì)象指定為Point的實(shí)例對(duì)象，這樣Circle.prototype上就有了move(x,y)方法
Circle.prototype = Object.create(Point.prototype);
//此時(shí)Circle.prototype.constructor屬性還等于function Point(x,y)，所以要手動(dòng)改成function Circle(x,y,r)
Circle.prototype.constructor = Circle;
//還可以定義一些其他的方法
Circle.prototype.area = function () {
  return Math.PI*this.radius*this.radius;
}
var c = new Circle(1,2,3);
c.move(2,2);//調(diào)用的是自己原型上從Point繼承過來的方法
c.area();

構(gòu)造器對(duì)象Circle的原型鏈：

實(shí)例對(duì)象c的原型鏈：

函數(shù)參數(shù)的三個(gè)特點(diǎn)：

形參個(gè)數(shù)不一定等于實(shí)參個(gè)數(shù)

所有參數(shù)傳遞都是值傳遞，也就是說，參數(shù)傳遞都只是在棧內(nèi)存中的操作。所以要特別小心引用類型的參數(shù)傳遞，可能會(huì)改變傳進(jìn)來的實(shí)參的值。

通過參數(shù)類型檢查實(shí)現(xiàn)函數(shù)重載

構(gòu)造方法：

/pattern/flags

new RegExp(pattarn[, flags]);

原型對(duì)象屬性、方法：test， exec

test：使用正則表達(dá)式對(duì)字符串進(jìn)行測(cè)試，并返回測(cè)試結(jié)果

語法：regObj.test(str)

var reg = /^abc/i;
reg.test("Abc123"); //true
reg.test("bc123");//false

Date.now() 返回當(dāng)前距離 1970年1月1日 00:00:00 UTC的毫秒數(shù)。

Date.parse() 解析日期字符串，返回距離待解析日期距離 1970年1月1日 00:00:00 UTC的毫秒數(shù)。

Date.parse("2017-10-10T14:48:00") // 1507618080000
Date.parse("2017-10-10") // 1507593600000
Date.parse("Aug 9, 1995") // 807897600000

Date.prototype.toString() 返回一個(gè)完整的日期字符串。

var d = new Date(2013, 0, 1);

d.toString()
// "Tue Jan 01 2013 00:00:00 GMT+0800 (CST)"

Date.prototype.toLocaleDateString() 返回一個(gè)字符串，代表日期的當(dāng)?shù)貙懛ā?/p>

var d = new Date(2013, 0, 1);

d.toLocaleDateString()
// 中文版瀏覽器為"2013年1月1日"
// 英文版瀏覽器為"1/1/2013"

Date.prototype.toLocaleTimeString() 返回一個(gè)字符串，代表時(shí)間的當(dāng)?shù)貙懛ā?/p>

var d = new Date(2013, 0, 1);

d.toLocaleTimeString()
// 中文版瀏覽器為"上午12:00:00"
// 英文版瀏覽器為"12:00:00 AM"

get類方法：

getTime()：返回距離1970年1月1日00:00:00的毫秒數(shù)，等同于valueOf方法。
getDate()：返回實(shí)例對(duì)象對(duì)應(yīng)每個(gè)月的幾號(hào)（從1開始）。
getDay()：返回星期幾，星期日為0，星期一為1，以此類推。
getYear()：返回距離1900的年數(shù)。
getFullYear()：返回四位的年份。
getMonth()：返回月份（0表示1月，11表示12月）。
getHours()：返回小時(shí)（0-23）。
getMilliseconds()：返回毫秒（0-999）。
getMinutes()：返回分鐘（0-59）。
getSeconds()：返回秒（0-59）。
getTimezoneOffset()：返回當(dāng)前時(shí)間與UTC的時(shí)區(qū)差異，以分鐘表示，返回結(jié)果考慮到了夏令時(shí)因素。

一個(gè)計(jì)算本年度還剩多少天的例子：

function leftDays() {
  var today = new Date();
  var endYear = new Date(today.getFullYear(), 11, 31, 23, 59, 59, 999);
  var msPerDay = 24 * 60 * 60 * 1000;
  return Math.round((endYear.getTime() - today.getTime()) / msPerDay);
}

var myDate = new Date();
var myDate = new Date(2017,3,1,7,1,1,100);
var year = myDate.getFullYear(); // 四位數(shù)字返回年份
vat month = myDate.getMonth(); // 0-11
var date = myDate.getDate(); // 1-31
var day = myDate.getDay(); //0-6
var h = myDate.getHours(); // 0-23
var m = myDate.getMinutes(); // 0-59
var s = myDate.getSeconds(); // 0-59
var ms = myDate.getMilliseconds(); //0-999
var allmMS = myDate.getTime(); //獲取從1970至今的毫秒數(shù) 得到的值可以用于new Date(ms);

小練習(xí)：獲取昨天的日期：
var today = new Date();
var todayms = today.getTime();
var oneDay = 24*60*60*1000;
var yesterday = new Date(todayms - oneDay);

Javascript的6種原生錯(cuò)誤類型：

SyntaxError 解析代碼時(shí)發(fā)生的語法錯(cuò)誤

ReferenceError 引用不存在的變量時(shí)發(fā)生的錯(cuò)誤

RangeError 當(dāng)一個(gè)值超出有效范圍時(shí)發(fā)生的錯(cuò)誤

TypeError 變量或參數(shù)不是預(yù)期類型時(shí)發(fā)生的錯(cuò)誤。比如 new 123

URIError URI相關(guān)函數(shù)的參數(shù)不正確時(shí)拋出的錯(cuò)誤。主要涉及encodeURI(),decodeURI(),encodeURIComponent(),decodeURIComponent(),escape()和unescape()這六個(gè)函數(shù)。

EvalError eval函數(shù)沒有被正確執(zhí)行時(shí)拋出。該錯(cuò)誤類型已不再在ES5中出現(xiàn)了。

以上6種派生錯(cuò)誤，連同原始的Error對(duì)象，都是構(gòu)造函數(shù)。

Math對(duì)象是擁有一些屬性和對(duì)象的單一對(duì)象，主要用于數(shù)字計(jì)算

常用方法：

Math.floor(num) ：向下取整

Math.ceil(num)向上取整

Math.random()返回0-1之間的一個(gè)偽隨機(jī)數(shù)，一定小于1，但可能等于0。

用處：

1.任意范圍內(nèi)生成隨機(jī)整數(shù)

function getRandomInt(min, max) {
    return Math.floor(Math.random() * (max - min +1 )) + min;
}

2.返回指定長(zhǎng)度的隨機(jī)字符：

function random_str(length) {
    var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    ALPHABET += "abcdefghijklmnopqrstuvwxyz";
    ALPHABET += "0123456789-_";
    var str = "", randIndex = "";
    for(var i=0; i < length; i++) {
        randIndex = Math.floor(Math.random() * ALPHABET.length);
        str += ALPHABET.charAt(randIndex);
    }
    return str;
}

JSON對(duì)象主要用于存儲(chǔ)和傳遞文本信息

常用方法：

JSON.parse(jsonStr)：將JSON字符串解析為JSON對(duì)象

JSON.stringify(jsonObj)：將JSON對(duì)象序列化為JSON字符串

屬性：NaN，Infinity，undefined
方法：parseInt，parseFloat，isNaN，isFinite，eval
處理URI的方法：encodeURIComponent，decodeURIComponent，encodeURI，decodeURI
構(gòu)造器屬性：Boolean，String，Number，Object，F(xiàn)unction，Array，Date，Error...
對(duì)象屬性：Math，JSON

（1）NaN不等于任何值，包括它自己本身。

（2）parseInt(string[, radix]) 用于將字符串轉(zhuǎn)換為數(shù)字，參數(shù)：要轉(zhuǎn)換的字符串，進(jìn)制（默認(rèn)十進(jìn)制）

注意：如果第一個(gè)參數(shù)不是字符串，會(huì)將其先用String(param)轉(zhuǎn)換為字符串，所以parseInt會(huì)將空字符串，true，null轉(zhuǎn)換為NaN。

parseInt("1"); //1 * 10^0 = 1
parseInt("1", 16); //1 * 16^0 = 1
parseInt("1f"); // 1 * 10^0 = 1
parseInt("1f"); //1 * 16^1 + f * 16^0 = 16 + 15 = 31
parseInt("f1"); // NaN

將非字符串先轉(zhuǎn)換為字符串還會(huì)導(dǎo)致一些意外的結(jié)果：

parseInt(0x11, 36) // 43
// 等同于
parseInt(String(0x11), 36)
parseInt("17", 36)

上面代碼中，十六進(jìn)制的0x11會(huì)被先轉(zhuǎn)為十進(jìn)制的17，再轉(zhuǎn)為字符串。然后，再用36進(jìn)制解讀字符串17，最后返回結(jié)果43。

radix取值在2-36之間，0、null、undefined都會(huì)被直接忽略，當(dāng)做默認(rèn)的10來處理:

parseInt("10", 1); // NaN
parseInt("10", 37); // NaN
parseInt("10", 0); // 10
parseInt("10", null); // 10
parseInt("10", undefined); // 10
parseInt("10", 2); // 2 ( 1*2^1 + 0*2^0 )

（3）parseFloat用于將字符串轉(zhuǎn)換為浮點(diǎn)數(shù)。注意，它與parseInt一樣，都會(huì)將空字符串，true，null轉(zhuǎn)換為NaN:

parseFloat(true)  // NaN
Number(true) // 1

parseFloat(null) // NaN
Number(null) // 0

parseFloat("") // NaN
Number("") // 0

parseFloat("123.45#") // 123.45
Number("123.45#") // NaN

（4）eval計(jì)算某個(gè)字符串，并執(zhí)行其中的Javascript代碼。

語法：eval(string)

不建議使用，會(huì)有性能問題。

（5）encodeURIComponent：用于將URI參數(shù)中的中文、特殊字符等作為URI的一部分進(jìn)行編碼

語法：encodeURIComponent(URIString)

栗子：
1.防止注入性攻擊：
var url = "http://www.xxx.com/index.html?name=" + encodeURIComponent(name);
2.依賴URL進(jìn)行參數(shù)傳遞時(shí)，對(duì)于參數(shù)中有特殊字符（如"&"，"/"）的要對(duì)其進(jìn)行編碼：
var url = "http://www.xxx.com/index.html?name=" + encodeURIComponent("Tom&Jerry") + "&src=" + encodeURIConponent("/assert/image/test.png");

介紹表達(dá)式、算術(shù)運(yùn)算符、位運(yùn)算符、布爾運(yùn)算符、關(guān)系運(yùn)算符、相等與全等、條件運(yùn)算符。

JS短語，解釋器可以執(zhí)行它并生成一個(gè)值。

算法步驟：

如果運(yùn)算子是對(duì)象先自動(dòng)轉(zhuǎn)成原始類型的值（即，先valueOf(),如果結(jié)果還是對(duì)象，就toString()；Date類型則先toString()）
兩個(gè)運(yùn)算子都為原始類型之后，如果其中一個(gè)為字符串，則兩個(gè)都轉(zhuǎn)為字符串，拼接。
否則，兩個(gè)運(yùn)算子都轉(zhuǎn)為數(shù)值，進(jìn)行加法運(yùn)算。

[1, 2] + [3]
// "1,23"

// 等同于
String([1, 2]) + String([3])
// "1,2" + "3"

加法運(yùn)算符以外的其他算術(shù)運(yùn)算符（比如減法、除法和乘法），都不會(huì)發(fā)生重載。它們的規(guī)則是：所有運(yùn)算子一律轉(zhuǎn)為數(shù)值，再進(jìn)行相應(yīng)的數(shù)學(xué)運(yùn)算。

1 - "2" // -1
1 * "2" // 2
1 / "2" // 0.5

var a = "123";
var oa = new String("123");

a === oa; // false 其中 a 為string值類型，oa為object對(duì)象類型

//undefined 與 null 都與自身嚴(yán)格相等
undefined === undefined // true
null === null // true

規(guī)則用偽代碼表示為：

function equal(a, b) {
  if a、b類型相同
    return a === b;
  else a、b類型不同
    return Number(a) === Number(b);
}

"99" == 99 //true
"abc" == new String("abc") // true

例外：
1.null == undefined //true
2.null與undefined進(jìn)行 == 運(yùn)算時(shí)不進(jìn)行類型轉(zhuǎn)換
  0 == null //false
  null == false // false
  "undefined" == undefined // false

且運(yùn)算符的運(yùn)算規(guī)則：如果第一個(gè)運(yùn)算子的布爾值為true，則返回第二個(gè)運(yùn)算子的值（注意不是布爾值）；如果第一個(gè)運(yùn)算子的布爾值為false，返回第一個(gè)運(yùn)算子的值（不是布爾值）。
或運(yùn)算符的運(yùn)算規(guī)則：如果第一個(gè)運(yùn)算子的布爾值為true，則返回第一個(gè)運(yùn)算子的值（注意不是布爾值），且不再對(duì)第二個(gè)運(yùn)算子求值；如果第一個(gè)運(yùn)算子的值為false，則返回第二個(gè)運(yùn)算子的值（不是布爾值）。

用于直接對(duì)二進(jìn)制位進(jìn)行計(jì)算。

異或運(yùn)算：^。表示當(dāng)兩個(gè)二進(jìn)制位不相同，則結(jié)果為1，否則結(jié)果為0.

常用于在不定義新變量的條件下互換兩個(gè)數(shù)的值：

var a = 3;
var b = 7;

a^=b;
b^=a;
a^=b;

a; // 7
b; // 3

位運(yùn)算符可以用作設(shè)置對(duì)象屬性的開關(guān)。

假設(shè)某個(gè)對(duì)象有4個(gè)開關(guān)，每個(gè)開關(guān)都有一個(gè)變量。那么可以設(shè)置一個(gè)四位的二進(jìn)制數(shù)，用來表示四個(gè)開關(guān)

var FLAG_A = 1; // 0001
var FLAG_B = 2; // 0010
var FLAG_C = 4; // 0100
var FLAG_D = 8; // 1000

上面代碼設(shè)置A、B、C、D四個(gè)開關(guān)，每個(gè)開關(guān)分別占有一個(gè)二進(jìn)制位。

然后就可以用與運(yùn)算檢驗(yàn)當(dāng)前是否打開了某個(gè)開關(guān)。

var flags = 5; // 0101

if(flags && FLAG_C) {
    console.log("當(dāng)前打開了C開關(guān).");
}

// 當(dāng)前打開了C開關(guān).

用于對(duì)兩個(gè)表達(dá)式求值，并返回后一個(gè)表達(dá)式的值。

var x = 0;
var y = (x++, 10);
x; // 1
y; // 10

完整表格：

大部分運(yùn)算符是從左到右計(jì)算的，少數(shù)是從右向左計(jì)算。最常見的是賦值運(yùn)算符 = 和 三元條件運(yùn)算符 ? :

var x = y = z = m;
var q = a ? b : c ? d : e ? f : g;

//其實(shí)等價(jià)于：

var x = (y = (z = m));
var q = a ? b : (c ? d : (e ? f : g));

條件控制語句

循環(huán)控制語句

for in ：遍歷對(duì)象的屬性

function Car(id, type, color) {
  this.id = id;
  this.type = type;
  this.color = color;
} 
var benz = Car(12345, "benz", "black");
for(var key in benz) {
  console.log(key + ": " + benz[key]);
}
//id: 12345
//type: benz
//color:black

//當(dāng)這個(gè)對(duì)象有函數(shù)時(shí)遍歷就會(huì)把原型對(duì)象上的方法也遍歷出來

Car.prototype.start = function() {
  console.log(this.type + "start");
}
//遍歷的時(shí)候會(huì)多一項(xiàng)
//start: function(){ ... }
//但我們通常是不需要方法的，而方法通常都是存在于原型對(duì)象上，所以可以通過hasOwnProperty判斷是否為對(duì)象本身屬性：
for(var key in benz) {
  if(benz.hasOwnProperty(key)) {
    console.log(key + ":" + benz[key]);
  }
}

異常處理語句

try catch finally
throw

with語句

通過暫時(shí)改變變量的作用域鏈(將with語句中的對(duì)象添加到作用域鏈的頭部)，來減少代碼量。

(function(){
  var a = Math.cos(3 * Math.PI) + Math.sin(Math.LN10);
});

//用with語句

(function(){
  with(Math){
    var a = cos(3 * PI) + sin(LN10);
  }
})

原型鏈如圖：

變量作用域分為靜態(tài)作用域和動(dòng)態(tài)作用域：
靜態(tài)作用域（詞法作用域）：在編譯階段就可以決定變量的引用，只跟程序定義的原始位置有關(guān)，與代碼執(zhí)行順序無關(guān)。
動(dòng)態(tài)作用域：在運(yùn)行時(shí)才能決定變量的引用。一步一步執(zhí)行代碼，把執(zhí)行到的變量和函數(shù)定義從下到上依次放到棧里面，用的時(shí)候選離自己最近的一個(gè)（比如有兩個(gè)x的定義，選離自己最近的一個(gè)）。

JS使用靜態(tài)作用域。ES5使用詞法環(huán)境管理靜態(tài)作用域。

環(huán)境記錄（record）[形參、變量、函數(shù)等]

對(duì)外部詞法環(huán)境的引用（outer）

一段代碼在執(zhí)行之前，會(huì)先初始化創(chuàng)建一個(gè)詞法環(huán)境。又因?yàn)镴S沒有塊級(jí)作用域，只有全局作用域和函數(shù)作用域，所以在JS中只有全局代碼或者函數(shù)代碼開始執(zhí)行前會(huì)先初始化詞法環(huán)境。

形參（一定要是這個(gè)函數(shù)顯式定義的形參，而不是真實(shí)傳進(jìn)來的參數(shù)，即不是實(shí)參）

函數(shù)定義（除了這個(gè)函數(shù)的形參和函數(shù)體，需要特別注意：在初始化的時(shí)候會(huì)保存當(dāng)前的作用域到函數(shù)對(duì)象中,即 scope:currentEnvironment）這也是形成閉包的必要條件呀！●▽●

變量定義（var a = xxx;）

知道了詞法環(huán)境的構(gòu)成，就可以分析代碼是如何執(zhí)行的，知道里面的變量到底引用的是什么值。

1.形參、函數(shù)定義或變量定義名稱沖突時(shí)，優(yōu)先級(jí)：函數(shù)定義 > 形參 > 變量定義
2.arguments這個(gè)對(duì)象其實(shí)也是在環(huán)境記錄中的
3.函數(shù)表達(dá)式是在執(zhí)行到函數(shù)表達(dá)式這一句代碼時(shí)才創(chuàng)建函數(shù)對(duì)象，而函數(shù)定義是在代碼初始化時(shí)就創(chuàng)建了函數(shù)對(duì)象，保存了當(dāng)前作用域。

var foo = "abc";
with({ foo: "bar" }) {
  function f() { alert foo; }
  (function() { alert foo; })(); //這就是一個(gè)函數(shù)表達(dá)式，只有在執(zhí)行到這一句時(shí)才會(huì)創(chuàng)建函數(shù)對(duì)象
  f();
}

注意函數(shù)定義與函數(shù)表達(dá)式的區(qū)別：

因?yàn)樵~法環(huán)境只會(huì)記錄【形參，函數(shù)定義，變量定義】這三項(xiàng)。
而且JS中只有全局作用域和函數(shù)作用域，沒有塊級(jí)作用域，所以所有不在函數(shù)作用域中定義的變量或者函數(shù)都是屬于全局作用域的。
而with會(huì)創(chuàng)建一個(gè)臨時(shí)的作用域，叫with的詞法環(huán)境，在with中用var定義一個(gè)變量與在with外一樣，都是在代碼初始化時(shí)就被放到詞法環(huán)境中，而函數(shù)表達(dá)式則是在執(zhí)行到那一句代碼時(shí)再放進(jìn)詞法環(huán)境中。
所以函數(shù)定義f()的詞法環(huán)境outer指向global，而函數(shù)表達(dá)式詞法環(huán)境的outer指向with。

注意：這里僅僅拿with舉例，我們不建議使用with，容易造成混淆。

catch的代碼塊與with的代碼塊很相似，也是臨時(shí)創(chuàng)建的詞法環(huán)境。

左側(cè)的 closure Environment 即為右邊紅框圈出來的函數(shù)表達(dá)式的詞法環(huán)境，outer指向catch Environment。

(function A(){
  A = 1;
  alert(A);
})();

因?yàn)锳是一個(gè)函數(shù)表達(dá)式，并不是一個(gè)函數(shù)定義，所以A不會(huì)定義到global Environment中。
然后執(zhí)行到這一句時(shí)，與之前的匿名函數(shù)表達(dá)式類似，創(chuàng)建一個(gè)該函數(shù)表達(dá)式的詞法環(huán)境，把A這個(gè)函數(shù)表達(dá)式定義到這個(gè)詞法環(huán)境中。而且在A的環(huán)境里定義的A函數(shù)不能被修改，所以A = 1是沒有用的，仍然會(huì)alert出 function A(){A=1;console.log(A);}。

參考資料：wikipedia Scope

function foo() {
  var x = 1;
  function bar() {
    console.log(x);
  }
  return bar;
}

var x = 2;
var f = foo();
f() // 1

上面代碼中，函數(shù)foo內(nèi)部聲明了一個(gè)函數(shù)bar，bar的作用域綁定foo。當(dāng)我們?cè)趂oo外部取出bar執(zhí)行時(shí)，變量x指向的是foo內(nèi)部的x，而不是foo外部的x。正是這種機(jī)制，構(gòu)成了下文要講解的“閉包”現(xiàn)象。

來自阮一峰的這篇文章

一直就沒搞懂過這個(gè)問題，看了半天MDN上的文檔，都是在說：

函數(shù)定義與函數(shù)表達(dá)式基本是一樣滴
因?yàn)槟切┰诘忍?hào)右邊的只能是表達(dá)式，所以它們是函數(shù)表達(dá)式
雖然，函數(shù)表達(dá)式一般情況下沒有名字，但是呢，它們也是可以有名字滴，有名字之后就與函數(shù)聲明的語法真的一樣了，這還怎么區(qū)分啊摔！(′Д｀) 
不信你自己看 MDN函數(shù)那一章 看的我都要哭了

直到我去翻了阮大大博客里講函數(shù)的一篇， ⊙▽⊙ 里面講立即調(diào)用的函數(shù)表達(dá)式（IIFE）一節(jié)里有這樣一句話：

為了避免解析上的歧義，JavaScript引擎規(guī)定，如果function關(guān)鍵字出現(xiàn)在行首，一律解釋成語句。因此，JavaScript引擎看到行首是function關(guān)鍵字之后，認(rèn)為這一段都是函數(shù)的定義。

所以這樣句首不是function的(function(){})();就是函數(shù)表達(dá)式啦！下面這樣也可以：

var i = function(){ return 10; }();
true && function(){ /* code */ }();
0, function(){ /* code */ }();

// 甚至這樣也可以：
!function(){ /* code */ }();
~function(){ /* code */ }();
-function(){ /* code */ }();
+function(){ /* code */ }();

閉包是由函數(shù)和它引用的外部詞法環(huán)境組合而成。

閉包允許函數(shù)訪問其引用的外部詞法環(huán)境中的變量（又稱自由變量）。

看個(gè)栗子：下面的函數(shù)add()最終return的值是一個(gè)函數(shù)，且在add函數(shù)外調(diào)用return出來的這個(gè)匿名函數(shù)時(shí)可以引用add函數(shù)內(nèi)部的環(huán)境，使用add函數(shù)內(nèi)部定義的變量i。

function add(){
  var i = 0;
  return function() {
    console.log(i++);
  }
}

var f = add();
f(); // 0
f(); // 1

一般來說，一個(gè)函數(shù)執(zhí)行完之后，內(nèi)部的局部變量都會(huì)被釋放掉，就不存在了。但是JS比較特殊，因?yàn)?b>JS中允許函數(shù)作為返回值，當(dāng)函數(shù)作為返回值，這個(gè)函數(shù)就保存了對(duì)外部詞法環(huán)境的引用，而相應(yīng)的，外部詞法環(huán)境中定義的變量就不會(huì)被釋放掉，會(huì)一直保留在內(nèi)存中。這就是JS的閉包。閉包使得它引用的函數(shù)的內(nèi)部環(huán)境一直存在，所以閉包可以看作是它引用的函數(shù)的內(nèi)部環(huán)境的一個(gè)接口。

廣義上來說，所有的JS函數(shù)都可以稱為閉包，因?yàn)樗械腏S函數(shù)創(chuàng)建后都保存了當(dāng)前的詞法環(huán)境。

閉包最大的作用有兩個(gè)，一個(gè)是可以讀取函數(shù)內(nèi)部的變量，另一個(gè)是使這些變量始終保存在內(nèi)存中。

function createIncrementor(start) {
  return function () {
    return start++;
  };
}

var inc = createIncrementor(5);

inc() // 5
inc() // 6
inc() // 7

start 存在于 createIncrementor 的詞法環(huán)境中，通過閉包inc被保留在內(nèi)存中，因此可以累加。

var addHandlers = function(nodes) {
  for(var i=0; i
jsfiddle自己試試
試過會(huì)發(fā)現(xiàn)：每次彈出的都是3，所以這樣寫是不能實(shí)現(xiàn)的。因?yàn)镴S沒有塊級(jí)作用域，所以每次for循環(huán)不會(huì)形成多帶帶的作用域，因此最內(nèi)層的匿名function函數(shù)中所有的i共享它的外部詞法環(huán)境addHandler函數(shù)中的同一個(gè)變量i。而當(dāng)onclick被調(diào)用時(shí)，循環(huán)早已結(jié)束，所以i的值也就是循環(huán)結(jié)束后的nodes.length。
想要更清晰一些，可以把for循環(huán)拆開看看：
var addHandler = function(nodes){
  var i = 0;
  nodes[i].onclick = function(){
    alert(i); 
  }
  //等價(jià)于
  //nodes[0].onclick = function(){
  //  alert(i); 注意這里還是i，當(dāng)onclick被調(diào)用，循環(huán)已經(jīng)結(jié)束了，也就是addHandler函數(shù)執(zhí)行到最后了，所以i是3
  //}
  i = 1;
  nodes[i].onclick = function(){
    alert(i);
  }
  i = 2;
  nodes[i].onclick = function(){
    alert(i);
  }
  i = 3;
}
addHandler(document.getElementsByTagName("a"));
這樣總可以理解了吧。
如何改進(jìn)？
既然問題出在每一次for循環(huán)沒有能夠形成多帶帶的作用域來保存每一次for循環(huán)的變量i的值，那么要解決的就是這個(gè)問題。
方法就是用剛剛學(xué)的閉包：在內(nèi)層匿名函數(shù)外面與for循環(huán)之間加一個(gè)幫助函數(shù)helper，helper有一個(gè)形參i，在每一次for循環(huán)時(shí)，都調(diào)用一次helper(i)，傳入本次循環(huán)的i，helper接收了這個(gè)形參之后，把它存到自己的詞法環(huán)境中，內(nèi)部的匿名function函數(shù)就可以訪問這個(gè)形參，再將這個(gè)匿名函數(shù)return出去，這就形成了一個(gè)閉包。這樣就做到了每次循環(huán)都形成一個(gè)閉包。因此就可以把傳入的i的值給保存下來。將來當(dāng)onclick事件被觸發(fā)時(shí)，就會(huì)調(diào)用helper函數(shù)return出來的匿名函數(shù)，也就可以使用helper函數(shù)的內(nèi)部詞法環(huán)境，彈出當(dāng)時(shí)存進(jìn)去的那個(gè)i的值。
劃重點(diǎn)：
每一次for循環(huán)，調(diào)用一次helper(i)函數(shù)；
每一次onclick事件被觸發(fā)，調(diào)用helper內(nèi)部return出來的匿名函數(shù)，這個(gè)匿名函數(shù)的outer指向helper函數(shù)內(nèi)部。
var addHandlers = function(nodes) {
  var helper = function(i) {
    return function(){
      alert(i);
    }
  }
  for(var i=0; i
jsfiddle里置幾試試
如果還是無法理解，那么我們?cè)賮戆裦or循環(huán)拆開看看
var addHandler = function(nodes){
  var helper = function(i){
    return function(){
      alert(i);
    }
  }
  var i = 0;
  nodes[i].onclick = helper(i); // 等價(jià)于 nodes[0].onclick = helper(0);
  i = 1;
  nodes[i].onclick = helper(i);// 等價(jià)于 nodes[1].onclick = helper(1);
  i = 2;
  nodes[i].onclick = helper(i);
  i = 3;
}
addHandler(document.getElementsByTagName("a"));
那么，你能不能再想出一種使用閉包解決這個(gè)問題的寫法呢？想想看 (??ω?)??
參考寫法：
var addHandler = function(nodes){
  var helper2 = function(i) {
    nodes[i].onclick = function(){
      alert(i);
    }
  }
  for(var i=0; i
注意，外層函數(shù)每次運(yùn)行，都會(huì)生成一個(gè)新的閉包，而這個(gè)閉包又會(huì)保留外層函數(shù)的內(nèi)部變量，所以內(nèi)存消耗很大。因此不能濫用閉包，否則會(huì)造成網(wǎng)頁的性能問題。
3.封裝
共享函數(shù)，私有變量。
var observer = (function(){
  var observerList = [];
  return {
    add: function(obj){
      observerList.push(obj);
    },
    empty: function(obj){
      observerList = [];
    },
    get: function(obj){
      return observerList;
    }
  }
})
可以參考阮大大講的閉包
面向?qū)ο?/b>
//Teacher constructor
function Teacher() {
  this.courses = [];
  this.job = "teacher";
  this.setName = function(name){
    this.name = name;
  }
  this.addCourse = function(course){
    this.courses.push(course);
  }
}
var bill = new Teacher();
bill.setName("Bill");
bill.addCourse("math");

var tom = new Teacher();
tom.setName("Tom");
tom.addCourse("physics");
這樣完全使用構(gòu)造函數(shù)來構(gòu)造實(shí)例對(duì)象，他們的存儲(chǔ)是這樣的：

這樣一來，每個(gè)實(shí)例對(duì)象都會(huì)存儲(chǔ)一遍所有的屬性和方法，對(duì)于所有的實(shí)例對(duì)象來說，都耗用了一遍內(nèi)存，這是很浪費(fèi)的。實(shí)際上我們可以看到屬性job和方法setName，addCourse其實(shí)是所有實(shí)例對(duì)象可以共用的，那么如何實(shí)現(xiàn)呢？這就引出了原型。
原型
原型是構(gòu)造器對(duì)象的一個(gè)屬性，叫prototype，JS中每個(gè)構(gòu)造器對(duì)象都有這樣一個(gè)屬性。這個(gè)屬性的值就是實(shí)例對(duì)象的原型，用于實(shí)現(xiàn)原型繼承，讓同一個(gè)構(gòu)造器創(chuàng)建出的多個(gè)實(shí)例對(duì)象共享同一個(gè)原型，這些實(shí)例對(duì)象就有了共同的屬性和方法。
用原型改寫上面的Teacher構(gòu)造器：
//Teacher prototype
function Teacher(){
  this.courses = [];
}
Teacher.prototype = {
  job: "teacher",
  setName: function(name) {
    this.name = name;
  },
  addCourses: function(course){
    this.cour