摘要：引用類型的值對象是引用類型的一個實例。引用類型是一種數據結構，用于將數據和功能組織在一起。對數組中的每一項運行給定函數，如果該函數對任一項返回，則返回。組零始終代表整個表達式。所以，使用非捕獲組較使用捕獲組更節省內存。

引用類型的值（對象）是引用類型的一個實例。

引用類型是一種數據結構，用于將數據和功能組織在一起。它同行被稱為類，但這種稱呼并不妥當，盡管ECMAScript從技術上講是一門面向對象的語言，但他不具備傳統的面向對象語言所支持的接口等基本結構。

引用類型有時候也被稱為對象定義

關于typeof中的"object"和Object()構造函數的個人理解：

typeof操作符返回的"object"值指的是數據類型

在new Object()中"Object"表示的是數據結構（引用類型），所以new Object()返回的是基于Object引用類型的一個實例

typeof返回的"function" 和 Function()構造函數 同理

創建對象的方法一個new Object()，另一個是對象字面量表示法

字面量表示法的最后一個屬性不能添加逗號，這樣會在IE7以前和Opera中導致錯誤

屬性名會自動轉換為字符串

屬性名中包含關鍵字、保留字會報錯

通常，除非必須使用變量來訪問屬性，否則我們建議使用點表示法

// 這里所有的屬性名都會自動轉為字符串
var person = {
    "name": "Nicholas",
    age: 29,
    5: true
}

// 不會報錯，但這個屬性不能使用person.name的方式
person["first name"] 

創建數組的基本方式有兩種。使用Array構造函數，字面量表示法

var colors = new Array();
var colors = new Array(20);                        // 傳入一個數值 創建一個length為20的空數組
var colors = new Array("red");                     // 傳入非數值 因此為元素的數組
var colors = new Array("red", "blue", "green");

var colors = ["red", "blue", "green"];
colors.length = 2;
alert(colors[2]);        // undefined

var colors = ["red", "blue", "green"];
colors[colors.length] = "black";
colors[colors.length] = "brown";            // 添加新項

var colors = ["red", "blue", "green"];
colors[99] = "black";
alert(colors.length);            // 100 位置3到98的值都不存在，都將返回undefined

對于一個網頁或者一個全局作用域而言，使用instanceof操作符就能得到結果

if (value instanceof Array) {
    ...
}

如果網頁中包含多個 框架，實際上就存在兩個以上的不同全局執行環境，從而存在兩個以上不同版本的Array構造函數，為此ECMAScript5新增了Array.isArray()方法.IE9+,Firefox4+,safari5+,Opera10.5+ Chrome

if (Array.isArray(value)) {
    ...
}

所有對象都據歐toLocaleString(),toString(),valueOf()方法。toString()返回由逗號拼接的字符串，valueOf()返回的還是數組

join() 如果傳入undefined，默認逗號分隔，IE7以前的版本會錯誤的以undefined分隔

如果數組中某一項是null或者undefined，那么該值在join(),toLocaleString(),toString(),valueOf()方法返回的結果以空字符串表示

棧是一種LIFO（Last-In-First-Out 后進先出）的數據結構。而棧中的插入（推入）和移除（彈出），只發生在一個位置——棧的頂部。ECMAScript為數組專門提供了push()和pop()方法

var colors = ["red", "blue", "green"];
var item = colors.pop();
alert(colors.length);        //    2
alert(item)                  //    “black”取得最后一項

隊列數據結構的訪問規則是FIFO(First-In-First-Out 先進先出)

shift()方法能移出數組的第一項并返回該項，結合使用shift()和push()方法可以實現

unshift()方法能在數組前端添加任意個項并返回新數組的長度, IE7以下的版本總是返回undefined，IE8在非兼容模式下會返回正確的長度值

var colors = ["red", "blue", "green"];
colors.push("black");
var item = colors.shift();
console.log(colors);        //  ["blue", "green", "black"]
console.log(item)                  //    “red”取得最后一項

var colors = new Array();
colors.unshift("red", "green");        // 推入兩項
console.log(colors.length);            // 2

數組存在兩個直接重排序的方法 reverse() sort()

reverse()直接返回將原數組倒序排列

sort() 調用每項的toString()轉型方法，按照升序排列，即使數組中的每一項都是數值，sort()方法比較的也是字符串

sort()可傳入一個比較函數，比較函數接受兩個參數，如果第一個參數應該位于第二個之前

var values = [0, 1, 5, 10, 15];
values.sort();
console.log(values);         // 0,1,10,15,5

// 使用比較函數是sort的最佳使用方式
function compare(value1, value2) {
    if (value1 < value2) {
        return -1;
    } else if (value1 > value2) {
        return 1;
    } else {
        return 0;
    }
}
var values = [0, 1, 10, 15,  5];
values.sort(compare);
console.log(values);         // 0,1,5,10,15

// 對于數值類型或者其valueOf()方法會返回數值類型的對象類型
// 可以使用一個更簡單的比較函數
function compare(value1, value2) {
    return value2 - value1
}

concat() 先創建一個數組副本，再將傳入的元素添加到新數組的末尾

var colors = ["red", "green", "blue"];
var colors2 = colors.concat("yellow", ["black", "brown"]);

alert(colors); // red,green,blue
alert(colors2);    // red,green,blue,yellow,black,brown

slice()可以接收一個或兩個參數，基于當前數組創建新數組，返回指定位置之間的所有項，slice()方法不會影響原數組

如果slice參數有一個負數，則用數組長度加上該數來確定相應的位置

var colors = ["red", "green", "blue", "yellow", "purple"];
var colors2 = colors.slice(1);            //    green,blue,yellow,purple
var colors3 = colors.slice(1,4);          //    green,blue,yellow

splice() 最強大的數組方法，始終返回一個數組，該數組中包含從原始數組中刪除的項（沒有就返回空數組）

刪除：可以刪除任意數量的項，只需指定2個參數：要刪除的第一項的位置和要刪除的項數

插入：可以向指定位置插入任意數量的項，只需提供3個參數：起始位置、0（插入操作沒有要刪除的項所以是0）和要插入的項，多個可以傳任意個數的參數

替換：可以向指定位置插入任意數量的項，且同時刪除任意數量的項，刪除的項數不必與插入的項數相等

var colors = ["red", "green", "blue"];
var removed = colors.splice(0, 1);                    // 刪除第一項 removed 為 ["red"]
alert(colors);                                        // ["green", "blue"]

removed = colors.splice(1, 0, "yellow", "orange");    // 從位置1開始插入兩項
console.log(colors);                                  // green,yellow,orange,blue
console.log(removed);                                 // 返回空數組

removed = colors.splice(1, 1, "red", "purple");       // 插入兩項，刪除一項
console.log(colors);                                  // green,red,purple,orange,blue
console.log(removed);                                 // ["yellow"]

數組有兩個位置方法，都接收兩個參數：要查找的項和（可選）表示查找氣墊位置的索引，返回查找對應項的位置，沒有找到返回-1。在比較第一個參數與數組中的每一項時，會使用全等操作符；

indexOf() 從開頭（位置0）查找

lastIndexOf() 從末尾開始向前查找

支持的瀏覽器 IE9+, Firefox2+, safari3+, Opera9.5+ Chrome

var numbers = [1,2,3,4,5,4,3,2,1];
alert(numbers.indexOf(4));            //    3
alert(numbers.lastIndexOf(4));        //    5

alert(numbers.indexOf(4, 4));            //    5
alert(numbers.lastIndexOf(4, 4));        //    3

var person = { name: "Nicholas" };
var people = [{ name: "Nicholas" }];

var morePeople = [people];

alert(people.indexOf(person));            // -1
alert(morePeople.indexOf(person));        // 0 

// 兩個引用類型對象值完全相同，但引用的內存地址不同
var a = { name: "obj" }
var b = { name: "obj" }
a == b                    //   false
a === b                    //   false

ECMAScript5位數組定義了5個迭代方法，每個方法都接收兩個參數：要在每一項上運行的函數和（可選的）運行該函數的作用域對象——影響this的值。傳入這些方法中的函數會接收三個參數：數組項的值，該項在數組中的位置和數組對象本身。

every():對數組中的每一項運行給定函數，如果該函數對每一項都返回true，則返回true

filter():對數組中的每一項運行給定函數，返回該函數會返回true的項組成的數組

forEach():對數組中的每一項運行給定函數。這個方法沒有返回值

map():對數組中的每一項運行給定函數，返回每次函數調用的結果組成的數組。

some():對數組中的每一項運行給定函數，如果該函數對任一項返回true，則返回true。

以上方法都不會修改數組中的包含的值

支持的瀏覽器 IE9+, Firefox2+, safari3+, Opera9.5+ Chrome

ECMAScript5新增了兩個歸并數組的方法 reduce()和reduceRight()。迭代數組的所有項，然后構建一個最終返回的值

reduce() 從數組的第一項開始，逐個遍歷到最后

reduceRight() 則從最后一項開始

支持的瀏覽器 IE9+, Firefox3+, safari4+, Opera10.5+ Chrome

var values = [1,2,3,4,5];
// prev 前一項， cur 迭代的當前項
// 第一次執行回調函數，prev是1，cur是2
var sum = values.reduce(function(prev, cur, index, array) {
    return prev + cur;
});
alert(sum);         // 15

下面兩行代碼是等價的，Date構造函數會在后臺調用Date.parse()

不用Date.parse()或Date.UTC() 都是基于系統設置本地時區創建的

Date.now() 返回調用時日期和時間的毫秒數，支持的瀏覽器IE9+, Firefox3+, safari3+, Opera10.5+ Chrome

var someDate = new Date(Date.parse("May 25, 2004"));
var someDate = new Date("May 25, 2004");

// GMT時間200年1月1日午夜零時
var y2k = new Date(Date.UTC(2000, 0));
var y2k = new Date(2000, 0);

// GMT時間2005年5月5日下午5:55:55
var allFives = new Date(Date.UTC(2005, 4, 5, 17, 55, 55));
var allFives = new Date(005, 4, 5, 17, 55, 55);

// Date.now()在不支持的瀏覽器中如下寫法
var start = +new Date();
start           // 返回毫秒數
typeof start     // "number"

toLocaleString()和toSring()的這一差別僅在調試代碼時比較有用

valueOf()方法，不返回字符串，返回日期的毫秒表示

var date1 = new Date(2007, 0, 1);        // "January 1 , 2007"
var date2 = new Date(2007, 1, 1);        // "February 1, 2007"

console.log(date1 < date2);             // true
console.log(date1 > date2);             // false

toDateString() 特定格式顯示星期幾、月、日和年

toTimeString() 特定格式顯示 時、分、秒和時區

toLocaleDateString() 特定于地區格式顯示星期幾、月、日和年

toLocaleTimeString() 特定于地區實現的格式顯示時、分、秒

toUTCString() 特定于實現的格式UTC日期

圖表略...

ECMAScript通過regExp類型來支持正則表達式

每個正則表達式都可帶有一或多個標志（flags）

g：表示全局模式（global），即模式將被應用于所有字符串，而非在發現第一個匹配項時立即停止

i:表示不區分大小寫（case-insensitive）模式，即在確定匹配項時忽略模式與字符串的大小寫

m:表示多行模式（multiline），即在到達一行文本末尾時還會繼續查找下一行中是否存在于模式匹配的項

// 匹配字符串中所有“at”的實例
var pattern1 = /at/g;

// 匹配第一個"bat"或"cat"，不區分大小寫
var pattern2 = /[bc]at/i;

// 匹配所有以"at"結尾的3個字符的組合，不區分大小寫
var pattern3 = /.at/gi;

模式中使用的所有元字符都必須轉義：( [ { ^ $ | ) ? * + . ] }

使用RegExp構造函數，兩個參數都必須是字符串，所有元字符都要雙重轉義

// 匹配第一個"bat"或"cat", 不區分大小寫
var patter1 = /[bc]at/i;

// 匹配第一個"[bc]at", 不區分大小寫
var pattern2 = /[bc]at/i;

// 匹配所有以"at"結尾的3個字符的組合，不區分大小寫
var pattern3 = /.at/gi

// 匹配所有".at",不區分大小寫
var pattern4 = /.at/gi;
// 使用RegExp構造函數，所有元字符都要雙重轉義
// 兩個參數都必須是字符串
var pattern4 = new RegExp(".at", "i");

我們可以使用小括號"()"來指定要重復的子表達式，然后對這個子表達式進行重復，例如：(abc)? 表示0個或1個abc 這里一 個括號的表達式就表示一個分組 。分組可以分為兩種形式，捕獲組和非捕獲組。

捕獲組可以通過從左到右計算其開括號來編號 。例如，在表達式 (A)(B(C)) 中，存在四個這樣的組。組零始終代表整個表達式。之所以這樣命名捕獲組是因為在匹配中，保存了與這些組匹配的輸入序列的每個子序列。在表達式中使用，也可以在匹配操作完成后從匹配器檢索。

以 (?) 開頭的組是純的非捕獲組(?:Pattern)，它不捕獲文本 ，也不針對組合計進行計數。就是說，如果小括號中以?號開頭，那么這個分組就不會捕獲文本，當然也不會有組的編號。非捕獲組則不會捕獲文本，也不會將它匹配到的內容多帶帶分組來放到內存中。所以，使用非捕獲組較使用捕獲組更節省內存。

RegExp的每個實例都具有下列屬性，通過這些屬性可以取得有關模式的各種信息

global 布爾值 表示是否設置了g標志

ignoreCase 布爾值 表示是否設置了i標志

lastIndex 整數 表示開始搜索下一個匹配項字符位置，從0算起

multiline 布爾值 表示是否設置了m標志

source 正則表達式的字符串表示，按照字面量形式而非傳入構造函數中的字符串模式返回

var pattern1 = /[bc]at/i;
console.log(pattern1.global);            // false
console.log(pattern1.ignoreCase);        // true
console.log(pattern1.multiline);         // false
console.log(pattern1.lastIndex);         // 0
console.log(pattern1.source);            // "[bc]at"

exec() 專門為捕獲組而設計的，接收一個參數，即要應用模式的字符串，然后返回包含第一個匹配項信息的數組；或者在沒有匹配項的情況下返回null

返回的數組雖然是Array的實例，但包含兩個額外的屬性：index和input

index表示匹配項在字符串中的位置

input表示表達式的字符串

即使在模式中設置了全局標志(g)，exec()每次也只會返回一個匹配項，不設置g的時候，每次都返回第一個匹配項，設置了g的情況下，每次調用exec()則都會在字符串中繼續查找新匹配項

var txt = "mom and dad and baby";
var pattern = /mom( and dad( and baby)?)?/gi;

var matches = pattern.exec(txt);
console.log(matches);            
//    ["mom and dad and baby", " and dad and baby", " and baby", index: 0, input: "mom and dad and baby", groups: undefined]

test() 接收字符串參數，匹配返回true不匹配返回false

var txt = "000-00-0000";
var pattern = /d{3}-d{2}-d{4}/;
if (pattern.test(txt)) {
    alert("The pattern was matched.");
}

toString() toLocaleString() 都會返回正則表達式的字面量，與創建表達式的方式無關

valueOf() 返回正則表達式本身

RegExp構造函數包含一些屬性，適用于作用域中的所有表達式，并且基于所執行的最近一次正則表達式操作而變化

這些屬性分別有一個長屬性名和一個短屬性名（Opera例外，不支持短屬性）

使用這些屬性可以從exec() test()執行的操作中提取更具體的信息

var txt = "this has been a short summer";
var pattern = /(.)hort/g;

// Oper不支持input,lastMatch,lastParen,multiline
// IE不支持multiline
if (pattern.test(txt)) {
    console.log(RegExp.input);                            // this has been a short summer
    console.log(RegExp.leftContext);                      // this has been a
    console.log(RegExp.rightContext);                     // summer
    console.log(RegExp.lastMatch);                        // short
    console.log(RegExp.lastParen);                        // s
    console.log(RegExp.multiline);                        // false
}

短屬性名打斗不是有效的ECMAScript標識符，因此必須通過方括號語法來訪問

var txt = "this has been a short summer";
var pattern = /(.)hort/g;


// Oper不支持input,lastMatch,lastParen,multiline
// IE不支持multiline
if (pattern.test(txt)) {
    console.log(RegExp.$_);                            // this has been a short summer
    console.log(RegExp.["$`"]);                      // this has been a
    console.log(RegExp.["$""]);                     // summer
    console.log(RegExp.["$&"]);                        // short
    console.log(RegExp.["$+"]);                        // s
    console.log(RegExp.["$*"]);                        // false
}

除了上面介紹的幾個屬性之外，還有多達9個用于存儲捕獲組的構造函數屬性：RegExp.$1,RegExp.$2......RegExp.$9

var txt = "this has been a short summer";
var pattern = /(..)or(.)/g;

// 這里創建了一個包含兩個捕獲組的模式，并用該模式測試了一個字符串。
// 即使test()方法只返回一個布爾值，但RegExp構造函數的屬性$1和$2也會被匹配相應捕獲組的字符串自動填充
if (pattern.test(txt)) {
    console.log(RegExp.$1);        // sh
    console.log(RegExp.$2);        // t
}

盡管ECMACScript中的正則表達式功能還是比較完備的，但仍然缺少某些語言所支持的高級正則表達式特性

下面列出了不支持的特性

匹配字符串開始和結尾A 和 Z 錨 （但支持以插入符號 ^ 和美元符號 $ 來匹配字符串的開始和結尾）

向后查找（lookbehind） （但完全支持向前查找lookahead）

并集和交集

原子組（atomic grouping）

Unicode支持（耽擱字符串除外， 如 uFFFF）

命名的捕獲組（但支持編號的捕獲組）

s（single，單行）和 x （free-spacing， 無間隔）匹配模式

條件匹配

正則表達式注釋

每個函數都是Function類型的實例，而且都與其他引用類型一樣具有屬性和方法

由于函數是對象，因此函數名實際上也是只想函數對象的指針，不會與某個函數綁定

function sum (num1, num2) {
    return num1 + num2;
}

// 下面使用函數表達式定義函數的方式幾乎相差無幾
// function后面沒必要使用函數名，通過變量sum即可飲用函數
// 函數末尾有一個分號，就像聲明其他變量一樣
var sum = function(num1, num2) {
    return num1 + num2;
};

不推薦 最后一種固定翼函數的方式是使用Function構造函數，可以接收任意數量的參數，但最后一個參數始終但被看成是函數體，而前面的參數則枚舉出了新函數的參數。這樣會導致解析兩次代碼，第一次是解析常規ECMAScript代碼，第二次是解析傳入構造函數中的字符串，從而影響性能。

// 不推薦
var sum = new Function("num1", "num2", "return num1 + num2");

函數名是指向函數的指針，因此函數名與包含對象指針的其他變量沒有區別。一個函數可能會有多個名字

function sum (num1, num2) {
    return num1 + num2;
}

var anotherSum = sum;                    // 函數指針的副本賦給了anotherSum

sum = null;                              // 清除了sum變量 anotherSum依然有效
console.log(anotherSum(10, 10));         // 20

function addSomeNumber(num) {
    return num + 100;
}
function addSomeNumber(num) {
    return numm + 200;
}
var result = addSomeNumber(100);    // 300

// 這個例子中聲明了兩個同名函數，而結果是后面的函數覆蓋了前面的函數
// 以下代碼等同于上面的代碼

var addSomeNumber = function (num ) {
    return num + 100;
};
addSomeNumber = function (num ) {
    return num + 200;
};
var result = addSomeNumber(100);    // 300

在創建第二個函數時，實際上覆蓋了引用第一個函數的變量addSomeNumber

解析器會先解讀函數聲明，并使其在執行任何代碼之前可用

函數表達式，則必須等到解析器執行到它所在的代碼行，才會真正被解釋執行

也可以同時使用函數聲明和函數表達式，（var sum = function sum () {};）不過在Safari中會導致錯誤

// 不會報錯
alert(sum(10, 10));
function sum(num1, mun2) {
    return num1 + num2;
}

// 報錯
alert(sum(10, 10));
var sum = function (num1, mun2) {
    return num1 + num2;
};

函數名本身就是變量，所以函數也可以作為值來使用。也就是說，不僅可以像傳遞參數一樣把一個函數傳遞給另一個函數，而且可以將一個函數作為另一個函數的結果返回

function callSomeFunction(someFunction, someArgument) {
    return someFunction(someArgument);
}

function add10(num) {
    return num + 10;
}

// 傳入函數指針，就不能加()，所以這里是add10
var result1 = callSomeFunction(add10, 10);

可以從一個函數中返回另一個函數

function createComparisonFunction(propertyName) {
    return function(object1, object2) {
        var value1 = object1[propertyName];
        var value2 = object2[propertyName];
        
        if (value1 < value2) {
            return -1;
        } else if (value1 > value2) {
            return 1;
        } else {
            return 0;
        }
    }
}

在函數內部，有兩個特殊的對象：arguments this

arguments的主要用途保存函數參數，這個對象還有一個屬性callee，該屬性是一個指針，指向擁有這個arguments對象的函數

// 經典的階乘函數
function factorial(num) {
    if (num <= 1) {
        return 1;
    } else {
        return num * factorial(num-1);
    }
}

// 如上面代碼，在函數有名字，而且名字以后也不會變的情況下，這樣定義沒有問題
// 但這個函數的執行與函數名factorial緊緊耦合在了一起
// 下面的寫法可以避免這種問題
function factorial(num) {
    if (num <= 1) {
        return 1;
    } else {
        return num * arguments.callee(num-1);
    }
}

var trueFactorial = factorial;

fatorial = function () {
    return 0;
};

console.log(trueFactorial(5));        // 120
console.log(fatorial(5));             // 0

this 引用的是函數執行的環境對象——或者說是this 值（當在網頁全局作用域中調用函數時，this對象引用的是window）

window.color = "red"
var o = { color: "blue" };

function sayColor() {
    console.log(this.color);
}

sayColor();        // "red"

o.sayColor = sayColor;
o.sayColor();        // "blue"

ECMAScript 5 規范化了另一個函數對象的屬性：caller 。Opera早起版本不支持，其他瀏覽器都支持這個ECMAScript 3并沒有定義的屬性。caller保存著調用當前函數的函數引用，在全局作用用戶中調用當前函數，它的值為null

function outer() {
    inner();
}

function inner() {
    console.log(inner.caller);
}

// 打印出outer()函數的源碼
// 因為outer調用了inner，所以inner.caller就指向outer()。
outer();

// 為了實現更松散的耦合，也可以通過arguments.callee.caller來訪問
function outer() {
    inner();
}
function inner() {
    console.log(arguments.callee.caller);
}
outer();

當函數再嚴格模式下運行時，訪問arguments.callee會導致錯誤。ECMAScript 5 還定義了arguments.caller屬性，嚴格模式下也會導致錯誤，而在非嚴格模式下這個屬性始終是undefined。定義這個屬性是為了分清arguments.caller和函數的caller屬性。以上變化都是為了加強這門語言的安全性，這樣第三方代碼就不能再相同的環境里窺視其他代碼了。

嚴格模式還有一個限制：不能為函數caller屬性賦值，否則會導致錯誤。

每個函數都包含兩個屬性：length 和 prototype

length表示函數希望接收的命名參數的個數

prototype 對于引用各類型而言，prototype是保存它們所有實例方法的真正所在。換言之，注入toString() valueOf()等方法實際上都保存在prototype名下，只不過是通過各自對象的實例訪問罷了。在創建自定義引用類型以及實現繼承時，prototype屬性的作用是極為重要的。

在ECMAScript 5 中，prototype屬性是不可枚舉的，因此使用for-in無法發現。

每個函數都包含兩個非繼承而來的方法：apply() call()。這兩個方法的用途都是在特定的作用域中調用函數，實際上等于設置函數體內this對象的值。

apply()方法接收兩個參數：一個是在其中運行函數的作用域，另一個是參數數組。其中，第二個參數可以是Array的實例，也可以是arguments對象

在嚴格模式下，未指定對象而調用函數，則this值不會轉型為window。除非明確把函數添加到某個對象或者調用apply() 或 call()，否則this值將是undefined。

call()方法與apply()的作用相同，它們的區別僅在于接收參數的方式不同。對于call()而言，第一個參數是this值沒有變化，不同的是其余參數都直接傳遞給函數。換言之，在使用call()方法時，傳遞給函數的參數必須逐個列舉出來

// callSum1()在執行sum()函數時傳入了this作為this值,所以傳入的就是window對象
function sum(num1, num2) {
    return num1 + num2;
}
function callSum1(num1, num2) {
    return sum.apply(this, arguments);                //    傳入arguments對象
}

function callSum2(num1, num2) {
    return sum.apply(this, [num1, num2]);            //     傳入數組
}

function callSum3(num1, num2) {
    return sum.call(this, num1, num2);            //     傳入數組
}

// 在全局環境下調用函數，此時this就是window
callSum1(10, 10));                                    // 20
callSum2(10, 10));                                    // 20
callSum3(10, 10));                                    // 20

apply() call() 真正強大的地方是能夠擴充函數賴以運行的作用域。

window.color = "red";
var o = { color: "blue" };

function sayColor() {
    console.log(this.color);
}

sayColor();        // red
sayColor.call(this);        // red
sayColor.call(window);      // red
sayColor.call(o);           // blue

使用call() apply() 來擴充作用域的最大好處，就是對象不需要與方法有任何耦合關系

ECMAScript 5 還定義了一個方法： bind() 這個方法會創建一個函數的實例，其this值會被綁定到傳給bind()函數的值.支持bind（）方法的瀏覽器IE9+, Firefox 4+,Safari 5.1+, Opera 12+ Chrome

window.color = "red";
var o = { color: "blue" };
function sayColor() {
    console.log(this.color);
}

var objectSayColor = sayColor.bind(o);
objectSayColor();        // blue

每個函數繼承的toLocaleString() 和 toString() valueOf() 方法都之中返回函數的代碼。

為了便于操作基本類型值，ECMAScript還提供了3個特殊的引用類型： Boolean, Number, String

每當讀取一個基本類型值得時候，后臺就會創建一個對應的基本包裝類型的對象，從而讓我們能夠調用一些方法來操作這些數據。

// 后臺自動完成下列處理
// 創建String類型的一個實例
// 在實例上調用指定的方法
// 銷毀這個實例
var s1 = "some text";
var s2 = s1.substring(2);

// 可以想象執行了以下代碼
var s1 = new String("some text");
var s2 = s1.substring(2);
s1 = null;
// 經過此番處理，基本的字符串值就變得跟對象一樣了。

以上步驟也分別適用于Boolean Number類型對應的布爾值和數字值

引用類型與基本包裝類型的主要區別就是對象的生存期。使用new操作符創建的引用類型的實例，在執行流離開當前作用域之前都一直保存在內存中。而自動創建的基本包裝類型的對象，則只存在于一行代碼的執行瞬間，然后立即銷毀。這意味著我們不能再運行時為基本類型值添加屬性和方法

var s1 = "some text";
// 這里創建的String對象在執行第三行代碼時就已經被銷毀了
s1.color = "red";
// 這里又創建了自己的String對象，而該對象沒有color屬性
console.log(s1.color);          // undefined

可以顯式的調用Boolean,Number,String來創建基本包裝類型的對象。但應該在必要的時候這樣做，因為很容易分不清實在處理基本類型還是引用類型的值。

對基本包裝類型的實例調用typeof會返回"object"，而且所有基本包裝類型的對象都會被轉為布爾值true

Object構造函數也會像工廠方法一樣，根據傳入值的類型返回相應基本包裝類型的實例。

var obj = new Object("some text");
console.log(obj instanceof String);         // true

使用new調用基本包裝類型的構造函數，與直接調用同名的轉型函數是不一樣的

// number中保存的是基本類型的值25
// obj中保存的是Number的實例（對象）
var value = "25";
var number = Number(value);     // 轉型函數
console.log(typeof number);     // "number"

var obj = new Number(value);    // 構造函數
console.log(typeof obj);        // "object"

Boolean類型的實例重寫了valueOf()方法，返回基本類型值true或false

重寫了toString()方法，返回字符串"true" "false"

可是Boolean對象在ECMAScript中的用處不大，因為經常造成誤解。其中最常見的問題就是在布爾表達式中使用Boolean對象

基本類型與引用類型的布爾值還有兩個區別。

typeof操作符對基本類型返回"boolean", 引用類型返回"object"

由于Boolean對象是Boolean類型的實例，所以使用instanceof操作符測試Boolean對象會返回true，而測試基本類型的布爾值則返回false

// 使用Boolean對象生成的實例，在布爾表達式中，等同于一個普通對象
// 所以result1 返回true
var falseObject = new Boolean(false);
var result1 = falseObject && true;                   // true

var falseValue = false;
var result2 = falseValue && true;                   // false

console.log(typeof falseOjbect);                    // object
console.log(typeof falseValue);                     // boolean
console.log(falseObject instanceof Boolean);        // true
console.log(falseValue instanceof Boolean);         // false

理解基本類型的布爾值與Boolean對象之間的區別非常重要——當然，我們建議是永遠不要使用Boolean對象

toLocaleString() toString() 返回字符串形式的數值

valueOf() 返回基本類型的數值

toString() 傳遞一個表示基數的參數，告訴它返回幾進制的字符串形式

var num = 10;
console.log(num.toString());                      // "10"
console.log(num.toString(2));                     // "1010"
console.log(num.toString(8));                     // "12"
console.log(num.toString(10));                    // "10"
console.log(num.toString(16));                    // "a"

除了繼承的方法，NUmber類型還提供了一些用于將數值格式化為字符串的方法。

toFixed() 按照指定的小數位返回數值的字符串表示。

超出位數的會進行攝入，舍入規則因瀏覽器而異，IE8及之前不能正確舍入的范圍在{(-0.94,-0.5],[0.5,0.94)])},在這個范圍內，IE會返回0，而不是-1或1，IE9修復了這個問題。

標準實現的規范，toFixed() 尅表示帶有0到20個小數位的數值，有些瀏覽器可以實現更多

toExponential() 返回以指數表示法（也稱e表示法）表示的數值的字符串形式。同樣接受一個參數，制定輸出結果的小數位

var num = 10;
console.log(num.toExponentail(1));                // "1.0e+1"

toPrecision() 這個方法會返回一個合適的表達方式 返回固定大小（fixed）格式，也可能返回指數（exponential）格式

var num = 99;
console.log(num.toPrecision(1));                 // "1e+2"
console.log(num.toPrecision(2));                 // "99"
console.log(num.toPrecision(3));                 // "99.0"

同樣，我們不建議直接實例化Number類型，原因與創建Boolean對象一樣

var numberObject = new Number(10);
var numberValue = 10;
console.log(typeof numberObject);        // "object"
console.log(typeof numberValue);         // "number"
console.log(numberObject instanceof Number);         // true
console.log(numberValue instanceof Number);          // false

繼承的方法 valueOf() toLocaleString() toString() 都返回字符串所表示你的基本字符串值

String類型每個實例都有一個length屬性，表示字符串中包含多少個字符。即使字符串中包含雙字節字符串（不是占一個字節的ASCII字符），每個字符也仍然算一個字符。

var stringValue = "hello world";
console.log(stringValue.length);         // "11"

兩個用于訪問字符串中特定字符的方法是 charAt() charCodeAt() 都接受一個參數，基于0的字符位置。

charAt() 方法以單字符字符串的形式返回給定位置的那個字符（ECMAScript中沒有字符類型）

var stringValue = "hello world";
console.log(stringValue.charAt(1));     // "e"

charCodeAt() 返回字符編碼

var stringValue = "hello world";
console.log(stringValue.charCodeAt(1));     // "101" 小寫e的字符編碼

ECMAscript還定義了方括號訪問字符的方法 IE7及以前的版本會返回undefined值

var stringValue = "hello world";
console.log(stringValue[1]);     // "e" 

concat() 用于將一個或多個字符串拼接起來，返回拼接得到的新字符串，可以接受任意多個參數。雖然concat()實現了拼接方法，但實踐中更多還是使用加號操作符（+），簡單易行。

var stringValue = "hello ";
var result1 = stringValue.concat("world");     // "hello world"
var result2 = stringValue.concat("world", "!");     // "hello world!"
console.log(stringValue);                     // "hello

ECMAscript還提供了三個基于子字符串創建新字符串的方法 slice() substr() substring()

這個三個方法都會返回被操作符字符串的一個子字符串，而且也都接收一個或兩個參數。第一個參數制定字符串的開始位置，第二個（可選）表示子字符串到哪里結束

三個方法都不會修改字符串本身的值——它們只是返回一個基本類型的字符串值，對于原始字符串沒有任何影響

slice() substring() 的第二個參數制定的是字符串最后一個字符后的位置

substr() 的第二個參數制定的則是返回的字符個數

var stringValue = "hello world";
console.log(stringValue.slice(3));       // "lo world"
console.log(stringValue.substring(3));   // "lo world"
console.log(stringValue.substr(3));      // "lo world"

// substr() 方法第二個參數制定是要返回的字符個數
// 而slice()  substring() 指定的是結束位置 
// "world"中的o處于位置7，因此結果中不包含o
console.log(stringValue.slice(3, 7));       // "lo w"
console.log(stringValue.substring(3, 7));   // "lo w"
console.log(stringValue.substr(3, 7));      // "lo worl"

在參數是負值的情況下，它們的行為就不盡相同了

var stringValue = "hello world";

// slice() 會將傳入的負值與字符串的長度相加
// substring() 會將傳入的負值轉換為0
// substr() 第一個參數如果是負值會加上字符串長度，第二個參數如果是負值，就會轉換為0
console.log(stringValue.slice(-3));       // "rld"
console.log(stringValue.substring(-3));   // "hello world"
console.log(stringValue.substr(-3));      // "rld" 

console.log(stringValue.slice(3, -4));       // "lo w"
// 這里實際上相當于substring(3, 0)，而這個方法會將較小的參數作為開始位置
console.log(stringValue.substring(3, -4));   // "hel"
console.log(stringValue.substr(3, -4));      // ""

indexOf() lastIndexOf() 從一個字符串搜索給定的字符串，然后返回字符串的位置（沒有找到就返回-1）。lastIndexOf() 從末尾向前搜索

兩個方法都可以接受第二個參數，表示從字符串中的哪個位置開始搜索。indexOf() 會忽略置頂位置之前的向后搜索，而lastIndexOf() 則相反

var stringValue = "hello world";
console.log(stringValue.indexOf("o"));       // 4
console.log(stringValue.lastIndexOf("o"));   // 7

console.log(stringValue.indexOf("o", 6));       // 7
console.log(stringValue.lastIndexOf("o", 6));   // 4

在使用第二個參數的情況下，可以通過循環調用indexOf()或lastIndexOf()來找到所有匹配的子字符串

var stringValue = "Lorem ipsum dolor sit amet, consectetur adipisicing elit";
var positions = new Array();
var pos = stringValue.indexOf("e");

while(pos > -1) {
  positions.push(pos);
  pos = stringValue.indexOf("e", pos + 1);
}

console.log(posisionts);                 // [3, 24, 32, 35, 52]

ECMAScript為所有字符串定義了trim()方法。創建一個字符串的副本，刪除前置及后綴的所有空格，然后返回結果

IE9+, Firefox3.5+, Safari5+, Opera10.5+, Chrome 8+ 還支持trimLeft() trimRight()

var str = "    hello world     "     
str.trim();                           // "hello world"
console.log(str);                     // "    hello world     "     

toLowerCase(), toUpperCase() 是兩個經典方法，借鑒自java.lang.String的同名方法

toLocaleLowerCase(), toLocaleUpperCase() 方法則是針對特定地區的實現。部分地區(包括簡體中文)，和上面兩個方法得到的值相同，但少數語言（如土耳其語）會為Unicode大小寫轉換應用特殊的規則，這時就必須使用針對地區的方法來保證實現的正確的轉換

var stringValue = "hello world";
console.log(stringValue.toLocaleUpperCase());                 // "HELLO WORLD"
console.log(stringValue.toUpperCase());                       // "HELLO WORLD"
console.log(stringValue.toLocaleLowerCase());                 // "hello world"
console.log(stringValue.toLowerCase());                       // "hello world"

match() 在字符串上調用這個方法，本質上與調用RegExp的exec()方法相同。只接收一個參數，要么是一個正則表達式，要么是一個RegExp對象

var txt = "cat, bat, sat, fat";
var pattern = /.at/;

// 與pattern.exec()相同
var matches = txt.match(pattern);
console.log(matches.index);                  // 0
console.log(matches[0]);                     // "cat"
console.log(matches.lastIndex);              // 0

另一個用于查找模式的方法是search() 唯一的參數與match()相同，返回字符串中第一個匹配項的索引；如果沒有返回-1

var txt = "cat, bat, sat, fat";
var pos = txt.search(/at/);
console.log(pos);                  // 1

為了簡化替換子字符串的操作，ECMAscript提供了replace()方法，兩個參數，一個是RegExp對象或者一個字符串（這個字符串不會被轉成正則表達式），第二個參數可以是一個字符串或者一個函數。如果第一個參數是字符串，那么只會替換掉第一個子字符串。要想替換所有子字符串，唯一的辦法就是提供一個正則表達式，而起要制定全局標識（g）

var txt = "cat, bat, sat,  fat";
var result = txt.replace("at", "ond");             // "cound, bat, sat, fat"
result = txt.replace(/at/g, "ond");                // "cond, bond, sond, fond"

第二個參數是字符串，還可以使用一些特殊子反復序列，將正則表達式操作得到的值插入到結果字符串中。

| 字符序列 | 替換文本 |
| -------- | ----------------------------------------------------------------------------------------------------------- |
| $$ | $ |
| $& | 匹配整個模式的子字符串。與RegExp.lastMatch的值相同 |
| $" | 匹配子字符串之前的字符串。與RegExp.leftContext的值相同 |
| $` | 匹配子字符串之后的字符串。與RegExp.rightContext的值相同 |
| $n | 匹配第n個捕獲組的子字符串，其中n等于0~9。$0,$1...$9 。如果正則表達式中沒有定義捕獲組，則使用空字符串 |
| $nn | 匹配第nn個捕獲組的子字符串，其中n等于01~99。$01,$02...$99 。如果正則表達式中沒有定義捕獲組，則使用空字符串 |

var txt = "cat, bat, sat, fat";
result = txt.replace(/(.at)/g, "word ($1)");         
// word (cat), word (bat), word (sat), word (fat)

第二個參數是函數。在只有一個匹配項（即與模式匹配的字符串）的情況下，會向這個函數傳遞三個參數：模式的匹配項（定義了多個捕獲組，這里就會有多個）、模式匹配項在字符串中的位置和原始字符串。

function htmlEscape(text) {
  return text.replace(/[<>"&]/g, function(match, pos, orginalText) {
    switch (match) {
      case "<":
        return "<";
      case ">":
        return ">";
      case "&":
        return "&";
      case """:
        return """;
    }
  });
}
console.log(htmlEscape("
Hello world!
"))
//  
Hello world!

split() 方法可以基于指定的分隔符將一個字符串分割成多個子字符串，并將結果放在一個數組中。分隔符可以是字符串，也可以是一個RegExp對象（這個方法不會將字符串看成正則表達式）。split() 方法可以接受可選的第二個參數，用于指定數組的大小，以便確保返回的數組不會超過既定大小。

var colorText = "red,blue,green,yellow";
var colors1 = colorText.split(",");                  // ["red", "blue", "green", "yellow"]
var colors2 = colorText.split(",", 2);               // ["red", "blue"]

// 需要注意的是，返回結果第一項和最后一項是空字符串
// /[^,]+/ 表示匹配逗號之前的單詞 不包括逗號 匹配項就是
// "red" "blue" “green" "yellow"
// "red"之前和“yellow"之后沒有字符，所以第一項和最后一項是空字符串
var colors3 = colorText.split(/[^,]+/);             // ["", ",", ",", ",", ""]

這個方法比較兩個字符串，并返回下列值中的一個：

如果字符串在字母表中應該排在字符串參數之前，則返回一個負數，（大多數情況下是-1，具體的值要視實現而定）

如果字符串等于字符串參數，則返回0

如果字符串在字母表中應該排在字符串參數之后，則返回一個正數（大多數情況下是1， 具體的值同樣要視實現而定）。

var stringValue = "yellow";
console.log(stringValue.localeCompare("brick"));                        // 1
console.log(stringValue.localeCompare("yellow"));                       // 0
console.log(stringValue.localeCompare("zoo"));                          // -1

再次強調，因為localeCompared() 返回的數值取決于實現，所以最好是像下面所示

function determineOrder(value) {
  var result = stringValue.localeCompare(value);
  if (result < 0) {
    console.log("The string "yellow" comes before the string "" + value + "".");
  } else if (result > 0) {
    console.log("The string "yellow" comes after the string "" + value + "".");
  } else {
    console.log("The string "yellow" is equal to the string "" + value + "".");
  }
}

determineOrder("brick");
determineOrder("yellow");
determineOrder("zoo");

這個方法的任務是接收一或多個字符編碼，然后將它們轉換成一個字符串

console.log(String.fromCharCode(104, 101, 108, 108, 111));    // "hello"

早期的web瀏覽器實現了一些專門用于簡化HTML格式化任務的方法，不建議使用

ECMA-262對內置對象的定義：“由ECMAScript實現提供的、不依賴于宿主環境的對象，這些對象在ECMAScript程序執行之前就已經存在了。”意思是開發者不必顯式的實例化內置對象，因為它們已經實例化了。

ECMAScript中的Global對象在某種意義上是作為一個終極的“兜底兒對象”。不屬于任何其他對象的屬性和方法，最終都是它的屬性和方法。

所有在全局作用域中定義的屬性和函數都是Global對象的屬性。

諸如 isNaN(), isFinite(), parseInt(), parseFloat() 實際上全都是Global對象的方法。除此之外，Global還包含其他一些方法。

Gloabal對象的encodeURI() 和 encodeURIComponent() 方法可以對URI(Uniform Resource Identifiers, 通用資源標識符)進行編碼，以便發送給瀏覽器。有效的URI中不能包含某些字符，例如空格。而這兩個URI編碼方法就可以對URI進行編碼，它們特殊的UTF-8編碼替換所有無效的字符，從而讓瀏覽器能夠接受和理解。

encodeURI() 主要用于整個URI（例如 http://www.wrox.com/illegal value.htm) 不會對本身屬性URI的特殊字符進行編碼，例如冒號、正斜杠、問好和井字號

encodeURIComponent() 主要用于對URI中的某一段（例如前面URI中的illegal value.htm）進行編碼。會對發現的任何非標準字符進行編碼。

var uri = "http://www.wrox.com/illegal value.htm#start";
encodeURI(rui);                  // "http://www.wrox.com/illegal%20value.htm#start"
encodeURIComponent(rui);        // "http%3A%2F%2Fwww.wrox.com%2Fillegal%20value.htm%23start"

// encodeURI 只對空格編碼
// encodeURIComponents 所有非字母數字字符

與encodeURI() 和 encodeURIComponent() 方法對應的是 decodeURI() decodeURIComponent()

dencodeURI() 只能對encodeURI()替換的字符進行編碼。%20替換成一個空格，但不會對%23（#）作處理

decodeURIComponent() 能解碼所有字符

最后一個，大概也是ECMAScript中最強大的方法。它只接受一個參數，即，要執行的的ECMAScript（或 JavaScript）字符串

eval() 中創建的任何變量或函數都不會被提升，因為在解析代碼的時候，它們被包含在一個字符串中，只在eval() 執行的時候創建

eval("var msg = "hello world";");
console.log(msg);                       // hello world

eval("function sayHi() { alert("hi"); }");
sayHi();

嚴格模式下，在外部訪問不到eval()中創建的任何變量或函數，因此前面兩個例子都會導致錯誤。

在嚴格模式下，為eval賦值也會導致錯誤

"use strict"
eval = "hi";           // causes error

使用eval()時必須極為謹慎，特別實在用它執行用戶輸入數據的情況下。否則可能會有惡意用戶輸入威脅你的站點或應用程序安全的代碼（即所謂的代碼注入）

有些屬性之前介紹過，諸如 undefined, NaN, Infinity 都是Global對象的屬性。此外所有原生引用類型的構造函數，像Object Function也都是Global對象的屬性

ECMAScript 5 明確進制給undefined, NaN 和 Infinity 賦值， 這樣做即使在非嚴格模式下也會導致錯誤。

ECMAScript 雖然沒有指出如何直接訪問global對象，但Web瀏覽器都是將這個全局對象作為window對象的一部分加以實現。因此全局作用域中聲明的所有變量和函數，就都成為了window對象的屬性

另一種取得Global對象的方法是使用this

var global = function() {
  return this;
}();

與JavaScript直接編寫的計算功能相比，Math對象提供的計算功能執行起來要快的多。

Math對象的屬性

min() max() 方法用于確定一組數值中的最小值和最大值。可以接收任意個數值參數。

var max = Math.max(3, 54, 32, 16);  // 54
var min = Math.min(3, 54, 32, 16);  // 3

找到數組中的最大或最小值，可以像下面這樣使用

這個技巧的關鍵是把Math作為apply()的第一個參數，從而正確的設置this值，然后可以將任何數組作為第二個參數（作為arguments對象）

var values = [1, 2, 3, 5, 6, 7, 8];
// 這個寫法相當于 把數組的項作為一個個數值參數傳給函數
// Math.max(1, 2, 3, 5, 6, 7, 8)
var max = Math.max.apply(Math, values);
var min = Math.min.apply(Math, values);

舍入方法 將小數值舍入為整數的幾個方法：Math.ceil(), Math.floor(), Math.round()

Math.ceil() 執行向上舍入，即它總是將數值向上舍入為最接近的整數

Math.floor() 執行向下舍入，即它總是將數值向下舍入為最接近的整數

Math.round() 執行標準舍入，即它總是將數值四舍五入為最接近的整數

random() 返回大于等于0小于1的一個隨機數

// 隨機生成一個1到10之間的數值
var num = Math.floor(Math.random() * 10 + 1);

function selectFrom(lowerValue, upperValue) {
  var choices = upperValue - lowerValue + 1;
  return Math.floor(Math.random() * choices + lowerValue);
}
var num = selectFrom(2, 10);                   // 介于2和10之間（包括2和10）的一個數值

// 利用這個函數可以方便的從數組中隨機取出一項
var colors = ["red", "green", "blue", "yellow", "black", "purple", "brown"]
var color = colors[selectFrom(0, colors.length - 1)];