摘要：引用類(lèi)型的值對(duì)象是引用類(lèi)型的一個(gè)實(shí)例。引用類(lèi)型是一種數(shù)據(jù)結(jié)構(gòu)，用于將數(shù)據(jù)和功能組織在一起。對(duì)數(shù)組中的每一項(xiàng)運(yùn)行給定函數(shù)，如果該函數(shù)對(duì)任一項(xiàng)返回，則返回。組零始終代表整個(gè)表達(dá)式。所以，使用非捕獲組較使用捕獲組更節(jié)省內(nèi)存。

引用類(lèi)型的值（對(duì)象）是引用類(lèi)型的一個(gè)實(shí)例。

引用類(lèi)型是一種數(shù)據(jù)結(jié)構(gòu)，用于將數(shù)據(jù)和功能組織在一起。它同行被稱(chēng)為類(lèi)，但這種稱(chēng)呼并不妥當(dāng)，盡管ECMAScript從技術(shù)上講是一門(mén)面向?qū)ο蟮恼Z(yǔ)言，但他不具備傳統(tǒng)的面向?qū)ο笳Z(yǔ)言所支持的接口等基本結(jié)構(gòu)。

引用類(lèi)型有時(shí)候也被稱(chēng)為對(duì)象定義

關(guān)于typeof中的"object"和Object()構(gòu)造函數(shù)的個(gè)人理解：

typeof操作符返回的"object"值指的是數(shù)據(jù)類(lèi)型

在new Object()中"Object"表示的是數(shù)據(jù)結(jié)構(gòu)（引用類(lèi)型），所以new Object()返回的是基于Object引用類(lèi)型的一個(gè)實(shí)例

typeof返回的"function" 和 Function()構(gòu)造函數(shù) 同理

創(chuàng)建對(duì)象的方法一個(gè)new Object()，另一個(gè)是對(duì)象字面量表示法

字面量表示法的最后一個(gè)屬性不能添加逗號(hào)，這樣會(huì)在IE7以前和Opera中導(dǎo)致錯(cuò)誤

屬性名會(huì)自動(dòng)轉(zhuǎn)換為字符串

屬性名中包含關(guān)鍵字、保留字會(huì)報(bào)錯(cuò)

通常，除非必須使用變量來(lái)訪問(wèn)屬性，否則我們建議使用點(diǎn)表示法

// 這里所有的屬性名都會(huì)自動(dòng)轉(zhuǎn)為字符串
var person = {
    "name": "Nicholas",
    age: 29,
    5: true
}

// 不會(huì)報(bào)錯(cuò)，但這個(gè)屬性不能使用person.name的方式
person["first name"] 

創(chuàng)建數(shù)組的基本方式有兩種。使用Array構(gòu)造函數(shù)，字面量表示法

var colors = new Array();
var colors = new Array(20);                        // 傳入一個(gè)數(shù)值 創(chuàng)建一個(gè)length為20的空數(shù)組
var colors = new Array("red");                     // 傳入非數(shù)值 因此為元素的數(shù)組
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";            // 添加新項(xiàng)

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

對(duì)于一個(gè)網(wǎng)頁(yè)或者一個(gè)全局作用域而言，使用instanceof操作符就能得到結(jié)果

if (value instanceof Array) {
    ...
}

如果網(wǎng)頁(yè)中包含多個(gè) 框架，實(shí)際上就存在兩個(gè)以上的不同全局執(zhí)行環(huán)境，從而存在兩個(gè)以上不同版本的Array構(gòu)造函數(shù)，為此ECMAScript5新增了Array.isArray()方法.IE9+,Firefox4+,safari5+,Opera10.5+ Chrome

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

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

join() 如果傳入undefined，默認(rèn)逗號(hào)分隔，IE7以前的版本會(huì)錯(cuò)誤的以u(píng)ndefined分隔

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

棧是一種LIFO（Last-In-First-Out 后進(jìn)先出）的數(shù)據(jù)結(jié)構(gòu)。而棧中的插入（推入）和移除（彈出），只發(fā)生在一個(gè)位置——棧的頂部。ECMAScript為數(shù)組專(zhuān)門(mén)提供了push()和pop()方法

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

隊(duì)列數(shù)據(jù)結(jié)構(gòu)的訪問(wèn)規(guī)則是FIFO(First-In-First-Out 先進(jìn)先出)

shift()方法能移出數(shù)組的第一項(xiàng)并返回該項(xiàng)，結(jié)合使用shift()和push()方法可以實(shí)現(xiàn)

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

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

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

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

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

sort() 調(diào)用每項(xiàng)的toString()轉(zhuǎn)型方法，按照升序排列，即使數(shù)組中的每一項(xiàng)都是數(shù)值，sort()方法比較的也是字符串

sort()可傳入一個(gè)比較函數(shù)，比較函數(shù)接受兩個(gè)參數(shù)，如果第一個(gè)參數(shù)應(yīng)該位于第二個(gè)之前

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

// 使用比較函數(shù)是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

// 對(duì)于數(shù)值類(lèi)型或者其valueOf()方法會(huì)返回?cái)?shù)值類(lèi)型的對(duì)象類(lèi)型
// 可以使用一個(gè)更簡(jiǎn)單的比較函數(shù)
function compare(value1, value2) {
    return value2 - value1
}

concat() 先創(chuàng)建一個(gè)數(shù)組副本，再將傳入的元素添加到新數(shù)組的末尾

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()可以接收一個(gè)或兩個(gè)參數(shù)，基于當(dāng)前數(shù)組創(chuàng)建新數(shù)組，返回指定位置之間的所有項(xiàng)，slice()方法不會(huì)影響原數(shù)組

如果slice參數(shù)有一個(gè)負(fù)數(shù)，則用數(shù)組長(zhǎng)度加上該數(shù)來(lái)確定相應(yīng)的位置

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() 最強(qiáng)大的數(shù)組方法，始終返回一個(gè)數(shù)組，該數(shù)組中包含從原始數(shù)組中刪除的項(xiàng)（沒(méi)有就返回空數(shù)組）

刪除：可以刪除任意數(shù)量的項(xiàng)，只需指定2個(gè)參數(shù)：要?jiǎng)h除的第一項(xiàng)的位置和要?jiǎng)h除的項(xiàng)數(shù)

插入：可以向指定位置插入任意數(shù)量的項(xiàng)，只需提供3個(gè)參數(shù)：起始位置、0（插入操作沒(méi)有要?jiǎng)h除的項(xiàng)所以是0）和要插入的項(xiàng)，多個(gè)可以傳任意個(gè)數(shù)的參數(shù)

替換：可以向指定位置插入任意數(shù)量的項(xiàng)，且同時(shí)刪除任意數(shù)量的項(xiàng)，刪除的項(xiàng)數(shù)不必與插入的項(xiàng)數(shù)相等

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

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

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

數(shù)組有兩個(gè)位置方法，都接收兩個(gè)參數(shù)：要查找的項(xiàng)和（可選）表示查找氣墊位置的索引，返回查找對(duì)應(yīng)項(xiàng)的位置，沒(méi)有找到返回-1。在比較第一個(gè)參數(shù)與數(shù)組中的每一項(xiàng)時(shí)，會(huì)使用全等操作符；

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

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

支持的瀏覽器 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 

// 兩個(gè)引用類(lèi)型對(duì)象值完全相同，但引用的內(nèi)存地址不同
var a = { name: "obj" }
var b = { name: "obj" }
a == b                    //   false
a === b                    //   false

ECMAScript5位數(shù)組定義了5個(gè)迭代方法，每個(gè)方法都接收兩個(gè)參數(shù)：要在每一項(xiàng)上運(yùn)行的函數(shù)和（可選的）運(yùn)行該函數(shù)的作用域?qū)ο蟆绊憈his的值。傳入這些方法中的函數(shù)會(huì)接收三個(gè)參數(shù)：數(shù)組項(xiàng)的值，該項(xiàng)在數(shù)組中的位置和數(shù)組對(duì)象本身。

every():對(duì)數(shù)組中的每一項(xiàng)運(yùn)行給定函數(shù)，如果該函數(shù)對(duì)每一項(xiàng)都返回true，則返回true

filter():對(duì)數(shù)組中的每一項(xiàng)運(yùn)行給定函數(shù)，返回該函數(shù)會(huì)返回true的項(xiàng)組成的數(shù)組

forEach():對(duì)數(shù)組中的每一項(xiàng)運(yùn)行給定函數(shù)。這個(gè)方法沒(méi)有返回值

map():對(duì)數(shù)組中的每一項(xiàng)運(yùn)行給定函數(shù)，返回每次函數(shù)調(diào)用的結(jié)果組成的數(shù)組。

some():對(duì)數(shù)組中的每一項(xiàng)運(yùn)行給定函數(shù)，如果該函數(shù)對(duì)任一項(xiàng)返回true，則返回true。

以上方法都不會(huì)修改數(shù)組中的包含的值

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

ECMAScript5新增了兩個(gè)歸并數(shù)組的方法 reduce()和reduceRight()。迭代數(shù)組的所有項(xiàng)，然后構(gòu)建一個(gè)最終返回的值

reduce() 從數(shù)組的第一項(xiàng)開(kāi)始，逐個(gè)遍歷到最后

reduceRight() 則從最后一項(xiàng)開(kāi)始

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

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

下面兩行代碼是等價(jià)的，Date構(gòu)造函數(shù)會(huì)在后臺(tái)調(diào)用Date.parse()

不用Date.parse()或Date.UTC() 都是基于系統(tǒng)設(shè)置本地時(shí)區(qū)創(chuàng)建的

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

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

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

// GMT時(shí)間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()在不支持的瀏覽器中如下寫(xiě)法
var start = +new Date();
start           // 返回毫秒數(shù)
typeof start     // "number"

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

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() 特定格式顯示 時(shí)、分、秒和時(shí)區(qū)

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

toLocaleTimeString() 特定于地區(qū)實(shí)現(xiàn)的格式顯示時(shí)、分、秒

toUTCString() 特定于實(shí)現(xiàn)的格式UTC日期

圖表略...

ECMAScript通過(guò)regExp類(lèi)型來(lái)支持正則表達(dá)式

每個(gè)正則表達(dá)式都可帶有一或多個(gè)標(biāo)志（flags）

g：表示全局模式（global），即模式將被應(yīng)用于所有字符串，而非在發(fā)現(xiàn)第一個(gè)匹配項(xiàng)時(shí)立即停止

i:表示不區(qū)分大小寫(xiě)（case-insensitive）模式，即在確定匹配項(xiàng)時(shí)忽略模式與字符串的大小寫(xiě)

m:表示多行模式（multiline），即在到達(dá)一行文本末尾時(shí)還會(huì)繼續(xù)查找下一行中是否存在于模式匹配的項(xiàng)

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

// 匹配第一個(gè)"bat"或"cat"，不區(qū)分大小寫(xiě)
var pattern2 = /[bc]at/i;

// 匹配所有以"at"結(jié)尾的3個(gè)字符的組合，不區(qū)分大小寫(xiě)
var pattern3 = /.at/gi;

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

使用RegExp構(gòu)造函數(shù)，兩個(gè)參數(shù)都必須是字符串，所有元字符都要雙重轉(zhuǎn)義

// 匹配第一個(gè)"bat"或"cat", 不區(qū)分大小寫(xiě)
var patter1 = /[bc]at/i;

// 匹配第一個(gè)"[bc]at", 不區(qū)分大小寫(xiě)
var pattern2 = /[bc]at/i;

// 匹配所有以"at"結(jié)尾的3個(gè)字符的組合，不區(qū)分大小寫(xiě)
var pattern3 = /.at/gi

// 匹配所有".at",不區(qū)分大小寫(xiě)
var pattern4 = /.at/gi;
// 使用RegExp構(gòu)造函數(shù)，所有元字符都要雙重轉(zhuǎn)義
// 兩個(gè)參數(shù)都必須是字符串
var pattern4 = new RegExp(".at", "i");

我們可以使用小括號(hào)"()"來(lái)指定要重復(fù)的子表達(dá)式，然后對(duì)這個(gè)子表達(dá)式進(jìn)行重復(fù)，例如：(abc)? 表示0個(gè)或1個(gè)abc 這里一 個(gè)括號(hào)的表達(dá)式就表示一個(gè)分組 。分組可以分為兩種形式，捕獲組和非捕獲組。

捕獲組可以通過(guò)從左到右計(jì)算其開(kāi)括號(hào)來(lái)編號(hào) 。例如，在表達(dá)式 (A)(B(C)) 中，存在四個(gè)這樣的組。組零始終代表整個(gè)表達(dá)式。之所以這樣命名捕獲組是因?yàn)樵谄ヅ渲?，保存了與這些組匹配的輸入序列的每個(gè)子序列。在表達(dá)式中使用，也可以在匹配操作完成后從匹配器檢索。

以 (?) 開(kāi)頭的組是純的非捕獲組(?:Pattern)，它不捕獲文本 ，也不針對(duì)組合計(jì)進(jìn)行計(jì)數(shù)。就是說(shuō)，如果小括號(hào)中以?號(hào)開(kāi)頭，那么這個(gè)分組就不會(huì)捕獲文本，當(dāng)然也不會(huì)有組的編號(hào)。非捕獲組則不會(huì)捕獲文本，也不會(huì)將它匹配到的內(nèi)容多帶帶分組來(lái)放到內(nèi)存中。所以，使用非捕獲組較使用捕獲組更節(jié)省內(nèi)存。

RegExp的每個(gè)實(shí)例都具有下列屬性，通過(guò)這些屬性可以取得有關(guān)模式的各種信息

global 布爾值 表示是否設(shè)置了g標(biāo)志

ignoreCase 布爾值 表示是否設(shè)置了i標(biāo)志

lastIndex 整數(shù) 表示開(kāi)始搜索下一個(gè)匹配項(xiàng)字符位置，從0算起

multiline 布爾值 表示是否設(shè)置了m標(biāo)志

source 正則表達(dá)式的字符串表示，按照字面量形式而非傳入構(gòu)造函數(shù)中的字符串模式返回

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() 專(zhuān)門(mén)為捕獲組而設(shè)計(jì)的，接收一個(gè)參數(shù)，即要應(yīng)用模式的字符串，然后返回包含第一個(gè)匹配項(xiàng)信息的數(shù)組；或者在沒(méi)有匹配項(xiàng)的情況下返回null

返回的數(shù)組雖然是Array的實(shí)例，但包含兩個(gè)額外的屬性：index和input

index表示匹配項(xiàng)在字符串中的位置

input表示表達(dá)式的字符串

即使在模式中設(shè)置了全局標(biāo)志(g)，exec()每次也只會(huì)返回一個(gè)匹配項(xiàng)，不設(shè)置g的時(shí)候，每次都返回第一個(gè)匹配項(xiàng)，設(shè)置了g的情況下，每次調(diào)用exec()則都會(huì)在字符串中繼續(xù)查找新匹配項(xiàng)

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() 接收字符串參數(shù)，匹配返回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() 都會(huì)返回正則表達(dá)式的字面量，與創(chuàng)建表達(dá)式的方式無(wú)關(guān)

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

RegExp構(gòu)造函數(shù)包含一些屬性，適用于作用域中的所有表達(dá)式，并且基于所執(zhí)行的最近一次正則表達(dá)式操作而變化

這些屬性分別有一個(gè)長(zhǎng)屬性名和一個(gè)短屬性名（Opera例外，不支持短屬性）

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

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標(biāo)識(shí)符，因此必須通過(guò)方括號(hào)語(yǔ)法來(lái)訪問(wèn)

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
}

除了上面介紹的幾個(gè)屬性之外，還有多達(dá)9個(gè)用于存儲(chǔ)捕獲組的構(gòu)造函數(shù)屬性：RegExp.$1,RegExp.$2......RegExp.$9

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

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

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

下面列出了不支持的特性

匹配字符串開(kāi)始和結(jié)尾A 和 Z 錨 （但支持以插入符號(hào) ^ 和美元符號(hào) $ 來(lái)匹配字符串的開(kāi)始和結(jié)尾）

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

并集和交集

原子組（atomic grouping）

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

命名的捕獲組（但支持編號(hào)的捕獲組）

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

條件匹配

正則表達(dá)式注釋

每個(gè)函數(shù)都是Function類(lèi)型的實(shí)例，而且都與其他引用類(lèi)型一樣具有屬性和方法

由于函數(shù)是對(duì)象，因此函數(shù)名實(shí)際上也是只想函數(shù)對(duì)象的指針，不會(huì)與某個(gè)函數(shù)綁定

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

// 下面使用函數(shù)表達(dá)式定義函數(shù)的方式幾乎相差無(wú)幾
// function后面沒(méi)必要使用函數(shù)名，通過(guò)變量sum即可飲用函數(shù)
// 函數(shù)末尾有一個(gè)分號(hào)，就像聲明其他變量一樣
var sum = function(num1, num2) {
    return num1 + num2;
};

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

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

函數(shù)名是指向函數(shù)的指針，因此函數(shù)名與包含對(duì)象指針的其他變量沒(méi)有區(qū)別。一個(gè)函數(shù)可能會(huì)有多個(gè)名字

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

var anotherSum = sum;                    // 函數(shù)指針的副本賦給了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

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

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

在創(chuàng)建第二個(gè)函數(shù)時(shí)，實(shí)際上覆蓋了引用第一個(gè)函數(shù)的變量addSomeNumber

解析器會(huì)先解讀函數(shù)聲明，并使其在執(zhí)行任何代碼之前可用

函數(shù)表達(dá)式，則必須等到解析器執(zhí)行到它所在的代碼行，才會(huì)真正被解釋執(zhí)行

也可以同時(shí)使用函數(shù)聲明和函數(shù)表達(dá)式，（var sum = function sum () {};）不過(guò)在Safari中會(huì)導(dǎo)致錯(cuò)誤

// 不會(huì)報(bào)錯(cuò)
alert(sum(10, 10));
function sum(num1, mun2) {
    return num1 + num2;
}

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

函數(shù)名本身就是變量，所以函數(shù)也可以作為值來(lái)使用。也就是說(shuō)，不僅可以像傳遞參數(shù)一樣把一個(gè)函數(shù)傳遞給另一個(gè)函數(shù)，而且可以將一個(gè)函數(shù)作為另一個(gè)函數(shù)的結(jié)果返回

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

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

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

可以從一個(gè)函數(shù)中返回另一個(gè)函數(shù)

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;
        }
    }
}

在函數(shù)內(nèi)部，有兩個(gè)特殊的對(duì)象：arguments this

arguments的主要用途保存函數(shù)參數(shù)，這個(gè)對(duì)象還有一個(gè)屬性callee，該屬性是一個(gè)指針，指向擁有這個(gè)arguments對(duì)象的函數(shù)

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

// 如上面代碼，在函數(shù)有名字，而且名字以后也不會(huì)變的情況下，這樣定義沒(méi)有問(wèn)題
// 但這個(gè)函數(shù)的執(zhí)行與函數(shù)名factorial緊緊耦合在了一起
// 下面的寫(xiě)法可以避免這種問(wèn)題
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 引用的是函數(shù)執(zhí)行的環(huán)境對(duì)象——或者說(shuō)是this 值（當(dāng)在網(wǎng)頁(yè)全局作用域中調(diào)用函數(shù)時(shí)，this對(duì)象引用的是window）

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

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

sayColor();        // "red"

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

ECMAScript 5 規(guī)范化了另一個(gè)函數(shù)對(duì)象的屬性：caller 。Opera早起版本不支持，其他瀏覽器都支持這個(gè)ECMAScript 3并沒(méi)有定義的屬性。caller保存著調(diào)用當(dāng)前函數(shù)的函數(shù)引用，在全局作用用戶中調(diào)用當(dāng)前函數(shù)，它的值為null

function outer() {
    inner();
}

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

// 打印出outer()函數(shù)的源碼
// 因?yàn)閛uter調(diào)用了inner，所以inner.caller就指向outer()。
outer();

// 為了實(shí)現(xiàn)更松散的耦合，也可以通過(guò)arguments.callee.caller來(lái)訪問(wèn)
function outer() {
    inner();
}
function inner() {
    console.log(arguments.callee.caller);
}
outer();

當(dāng)函數(shù)再?lài)?yán)格模式下運(yùn)行時(shí)，訪問(wèn)arguments.callee會(huì)導(dǎo)致錯(cuò)誤。ECMAScript 5 還定義了arguments.caller屬性，嚴(yán)格模式下也會(huì)導(dǎo)致錯(cuò)誤，而在非嚴(yán)格模式下這個(gè)屬性始終是undefined。定義這個(gè)屬性是為了分清arguments.caller和函數(shù)的caller屬性。以上變化都是為了加強(qiáng)這門(mén)語(yǔ)言的安全性，這樣第三方代碼就不能再相同的環(huán)境里窺視其他代碼了。

嚴(yán)格模式還有一個(gè)限制：不能為函數(shù)caller屬性賦值，否則會(huì)導(dǎo)致錯(cuò)誤。

每個(gè)函數(shù)都包含兩個(gè)屬性：length 和 prototype

length表示函數(shù)希望接收的命名參數(shù)的個(gè)數(shù)

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

在ECMAScript 5 中，prototype屬性是不可枚舉的，因此使用for-in無(wú)法發(fā)現(xiàn)。

每個(gè)函數(shù)都包含兩個(gè)非繼承而來(lái)的方法：apply() call()。這兩個(gè)方法的用途都是在特定的作用域中調(diào)用函數(shù)，實(shí)際上等于設(shè)置函數(shù)體內(nèi)this對(duì)象的值。

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

在嚴(yán)格模式下，未指定對(duì)象而調(diào)用函數(shù)，則this值不會(huì)轉(zhuǎn)型為window。除非明確把函數(shù)添加到某個(gè)對(duì)象或者調(diào)用apply() 或 call()，否則this值將是undefined。

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

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

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

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

// 在全局環(huán)境下調(diào)用函數(shù)，此時(shí)this就是window
callSum1(10, 10));                                    // 20
callSum2(10, 10));                                    // 20
callSum3(10, 10));                                    // 20

apply() call() 真正強(qiáng)大的地方是能夠擴(kuò)充函數(shù)賴(lài)以運(yùn)行的作用域。

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() 來(lái)擴(kuò)充作用域的最大好處，就是對(duì)象不需要與方法有任何耦合關(guān)系

ECMAScript 5 還定義了一個(gè)方法： bind() 這個(gè)方法會(huì)創(chuàng)建一個(gè)函數(shù)的實(shí)例，其this值會(huì)被綁定到傳給bind()函數(shù)的值.支持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

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

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

每當(dāng)讀取一個(gè)基本類(lèi)型值得時(shí)候，后臺(tái)就會(huì)創(chuàng)建一個(gè)對(duì)應(yīng)的基本包裝類(lèi)型的對(duì)象，從而讓我們能夠調(diào)用一些方法來(lái)操作這些數(shù)據(jù)。

// 后臺(tái)自動(dòng)完成下列處理
// 創(chuàng)建String類(lèi)型的一個(gè)實(shí)例
// 在實(shí)例上調(diào)用指定的方法
// 銷(xiāo)毀這個(gè)實(shí)例
var s1 = "some text";
var s2 = s1.substring(2);

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

以上步驟也分別適用于Boolean Number類(lèi)型對(duì)應(yīng)的布爾值和數(shù)字值

引用類(lèi)型與基本包裝類(lèi)型的主要區(qū)別就是對(duì)象的生存期。使用new操作符創(chuàng)建的引用類(lèi)型的實(shí)例，在執(zhí)行流離開(kāi)當(dāng)前作用域之前都一直保存在內(nèi)存中。而自動(dòng)創(chuàng)建的基本包裝類(lèi)型的對(duì)象，則只存在于一行代碼的執(zhí)行瞬間，然后立即銷(xiāo)毀。這意味著我們不能再運(yùn)行時(shí)為基本類(lèi)型值添加屬性和方法

var s1 = "some text";
// 這里創(chuàng)建的String對(duì)象在執(zhí)行第三行代碼時(shí)就已經(jīng)被銷(xiāo)毀了
s1.color = "red";
// 這里又創(chuàng)建了自己的String對(duì)象，而該對(duì)象沒(méi)有color屬性
console.log(s1.color);          // undefined

可以顯式的調(diào)用Boolean,Number,String來(lái)創(chuàng)建基本包裝類(lèi)型的對(duì)象。但應(yīng)該在必要的時(shí)候這樣做，因?yàn)楹苋菀追植磺鍖?shí)在處理基本類(lèi)型還是引用類(lèi)型的值。

對(duì)基本包裝類(lèi)型的實(shí)例調(diào)用typeof會(huì)返回"object"，而且所有基本包裝類(lèi)型的對(duì)象都會(huì)被轉(zhuǎn)為布爾值true

Object構(gòu)造函數(shù)也會(huì)像工廠方法一樣，根據(jù)傳入值的類(lèi)型返回相應(yīng)基本包裝類(lèi)型的實(shí)例。

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

使用new調(diào)用基本包裝類(lèi)型的構(gòu)造函數(shù)，與直接調(diào)用同名的轉(zhuǎn)型函數(shù)是不一樣的

// number中保存的是基本類(lèi)型的值25
// obj中保存的是Number的實(shí)例（對(duì)象）
var value = "25";
var number = Number(value);     // 轉(zhuǎn)型函數(shù)
console.log(typeof number);     // "number"

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

Boolean類(lèi)型的實(shí)例重寫(xiě)了valueOf()方法，返回基本類(lèi)型值true或false

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

可是Boolean對(duì)象在ECMAScript中的用處不大，因?yàn)榻?jīng)常造成誤解。其中最常見(jiàn)的問(wèn)題就是在布爾表達(dá)式中使用Boolean對(duì)象

基本類(lèi)型與引用類(lèi)型的布爾值還有兩個(gè)區(qū)別。

typeof操作符對(duì)基本類(lèi)型返回"boolean", 引用類(lèi)型返回"object"

由于Boolean對(duì)象是Boolean類(lèi)型的實(shí)例，所以使用instanceof操作符測(cè)試Boolean對(duì)象會(huì)返回true，而測(cè)試基本類(lèi)型的布爾值則返回false

// 使用Boolean對(duì)象生成的實(shí)例，在布爾表達(dá)式中，等同于一個(gè)普通對(duì)象
// 所以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

理解基本類(lèi)型的布爾值與Boolean對(duì)象之間的區(qū)別非常重要——當(dāng)然，我們建議是永遠(yuǎn)不要使用Boolean對(duì)象

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

valueOf() 返回基本類(lèi)型的數(shù)值

toString() 傳遞一個(gè)表示基數(shù)的參數(shù)，告訴它返回幾進(jìn)制的字符串形式

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類(lèi)型還提供了一些用于將數(shù)值格式化為字符串的方法。

toFixed() 按照指定的小數(shù)位返回?cái)?shù)值的字符串表示。

超出位數(shù)的會(huì)進(jìn)行攝入，舍入規(guī)則因?yàn)g覽器而異，IE8及之前不能正確舍入的范圍在{(-0.94,-0.5],[0.5,0.94)])},在這個(gè)范圍內(nèi)，IE會(huì)返回0，而不是-1或1，IE9修復(fù)了這個(gè)問(wèn)題。

標(biāo)準(zhǔn)實(shí)現(xiàn)的規(guī)范，toFixed() 尅表示帶有0到20個(gè)小數(shù)位的數(shù)值，有些瀏覽器可以實(shí)現(xiàn)更多

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

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

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

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

同樣，我們不建議直接實(shí)例化Number類(lèi)型，原因與創(chuàng)建Boolean對(duì)象一樣

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類(lèi)型每個(gè)實(shí)例都有一個(gè)length屬性，表示字符串中包含多少個(gè)字符。即使字符串中包含雙字節(jié)字符串（不是占一個(gè)字節(jié)的ASCII字符），每個(gè)字符也仍然算一個(gè)字符。

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

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

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

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

charCodeAt() 返回字符編碼

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

ECMAscript還定義了方括號(hào)訪問(wèn)字符的方法 IE7及以前的版本會(huì)返回undefined值

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

concat() 用于將一個(gè)或多個(gè)字符串拼接起來(lái)，返回拼接得到的新字符串，可以接受任意多個(gè)參數(shù)。雖然concat()實(shí)現(xiàn)了拼接方法，但實(shí)踐中更多還是使用加號(hào)操作符（+），簡(jiǎn)單易行。

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

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

這個(gè)三個(gè)方法都會(huì)返回被操作符字符串的一個(gè)子字符串，而且也都接收一個(gè)或兩個(gè)參數(shù)。第一個(gè)參數(shù)制定字符串的開(kāi)始位置，第二個(gè)（可選）表示子字符串到哪里結(jié)束

三個(gè)方法都不會(huì)修改字符串本身的值——它們只是返回一個(gè)基本類(lèi)型的字符串值，對(duì)于原始字符串沒(méi)有任何影響

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

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

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() 方法第二個(gè)參數(shù)制定是要返回的字符個(gè)數(shù)
// 而slice()  substring() 指定的是結(jié)束位置 
// "world"中的o處于位置7，因此結(jié)果中不包含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"

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

var stringValue = "hello world";

// slice() 會(huì)將傳入的負(fù)值與字符串的長(zhǎng)度相加
// substring() 會(huì)將傳入的負(fù)值轉(zhuǎn)換為0
// substr() 第一個(gè)參數(shù)如果是負(fù)值會(huì)加上字符串長(zhǎng)度，第二個(gè)參數(shù)如果是負(fù)值，就會(huì)轉(zhuǎn)換為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"
// 這里實(shí)際上相當(dāng)于substring(3, 0)，而這個(gè)方法會(huì)將較小的參數(shù)作為開(kāi)始位置
console.log(stringValue.substring(3, -4));   // "hel"
console.log(stringValue.substr(3, -4));      // ""

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

兩個(gè)方法都可以接受第二個(gè)參數(shù)，表示從字符串中的哪個(gè)位置開(kāi)始搜索。indexOf() 會(huì)忽略置頂位置之前的向后搜索，而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

在使用第二個(gè)參數(shù)的情況下，可以通過(guò)循環(huán)調(diào)用indexOf()或lastIndexOf()來(lái)找到所有匹配的子字符串

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()方法。創(chuàng)建一個(gè)字符串的副本，刪除前置及后綴的所有空格，然后返回結(jié)果

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() 是兩個(gè)經(jīng)典方法，借鑒自java.lang.String的同名方法

toLocaleLowerCase(), toLocaleUpperCase() 方法則是針對(duì)特定地區(qū)的實(shí)現(xiàn)。部分地區(qū)(包括簡(jiǎn)體中文)，和上面兩個(gè)方法得到的值相同，但少數(shù)語(yǔ)言（如土耳其語(yǔ)）會(huì)為Unicode大小寫(xiě)轉(zhuǎn)換應(yīng)用特殊的規(guī)則，這時(shí)就必須使用針對(duì)地區(qū)的方法來(lái)保證實(shí)現(xiàn)的正確的轉(zhuǎn)換

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() 在字符串上調(diào)用這個(gè)方法，本質(zhì)上與調(diào)用RegExp的exec()方法相同。只接收一個(gè)參數(shù)，要么是一個(gè)正則表達(dá)式，要么是一個(gè)RegExp對(duì)象

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

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

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

為了簡(jiǎn)化替換子字符串的操作，ECMAscript提供了replace()方法，兩個(gè)參數(shù)，一個(gè)是RegExp對(duì)象或者一個(gè)字符串（這個(gè)字符串不會(huì)被轉(zhuǎn)成正則表達(dá)式），第二個(gè)參數(shù)可以是一個(gè)字符串或者一個(gè)函數(shù)。如果第一個(gè)參數(shù)是字符串，那么只會(huì)替換掉第一個(gè)子字符串。要想替換所有子字符串，唯一的辦法就是提供一個(gè)正則表達(dá)式，而起要制定全局標(biāo)識(shí)（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"

第二個(gè)參數(shù)是字符串，還可以使用一些特殊子反復(fù)序列，將正則表達(dá)式操作得到的值插入到結(jié)果字符串中。

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

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

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

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() 方法可以基于指定的分隔符將一個(gè)字符串分割成多個(gè)子字符串，并將結(jié)果放在一個(gè)數(shù)組中。分隔符可以是字符串，也可以是一個(gè)RegExp對(duì)象（這個(gè)方法不會(huì)將字符串看成正則表達(dá)式）。split() 方法可以接受可選的第二個(gè)參數(shù)，用于指定數(shù)組的大小，以便確保返回的數(shù)組不會(huì)超過(guò)既定大小。

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

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

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

如果字符串在字母表中應(yīng)該排在字符串參數(shù)之前，則返回一個(gè)負(fù)數(shù)，（大多數(shù)情況下是-1，具體的值要視實(shí)現(xiàn)而定）

如果字符串等于字符串參數(shù)，則返回0

如果字符串在字母表中應(yīng)該排在字符串參數(shù)之后，則返回一個(gè)正數(shù)（大多數(shù)情況下是1， 具體的值同樣要視實(shí)現(xiàn)而定）。

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

再次強(qiáng)調(diào)，因?yàn)閘ocaleCompared() 返回的數(shù)值取決于實(shí)現(xiàn)，所以最好是像下面所示

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");

這個(gè)方法的任務(wù)是接收一或多個(gè)字符編碼，然后將它們轉(zhuǎn)換成一個(gè)字符串

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

早期的web瀏覽器實(shí)現(xiàn)了一些專(zhuān)門(mén)用于簡(jiǎn)化HTML格式化任務(wù)的方法，不建議使用

ECMA-262對(duì)內(nèi)置對(duì)象的定義：“由ECMAScript實(shí)現(xiàn)提供的、不依賴(lài)于宿主環(huán)境的對(duì)象，這些對(duì)象在ECMAScript程序執(zhí)行之前就已經(jīng)存在了?！币馑际情_(kāi)發(fā)者不必顯式的實(shí)例化內(nèi)置對(duì)象，因?yàn)樗鼈円呀?jīng)實(shí)例化了。

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

所有在全局作用域中定義的屬性和函數(shù)都是Global對(duì)象的屬性。

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

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

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

encodeURIComponent() 主要用于對(duì)URI中的某一段（例如前面URI中的illegal value.htm）進(jìn)行編碼。會(huì)對(duì)發(fā)現(xiàn)的任何非標(biāo)準(zhǔn)字符進(jìn)行編碼。

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 只對(duì)空格編碼
// encodeURIComponents 所有非字母數(shù)字字符

與encodeURI() 和 encodeURIComponent() 方法對(duì)應(yīng)的是 decodeURI() decodeURIComponent()

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

decodeURIComponent() 能解碼所有字符

最后一個(gè)，大概也是ECMAScript中最強(qiáng)大的方法。它只接受一個(gè)參數(shù)，即，要執(zhí)行的的ECMAScript（或 JavaScript）字符串

eval() 中創(chuàng)建的任何變量或函數(shù)都不會(huì)被提升，因?yàn)樵诮馕龃a的時(shí)候，它們被包含在一個(gè)字符串中，只在eval() 執(zhí)行的時(shí)候創(chuàng)建

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

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

嚴(yán)格模式下，在外部訪問(wèn)不到eval()中創(chuàng)建的任何變量或函數(shù)，因此前面兩個(gè)例子都會(huì)導(dǎo)致錯(cuò)誤。

在嚴(yán)格模式下，為eval賦值也會(huì)導(dǎo)致錯(cuò)誤

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

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

有些屬性之前介紹過(guò)，諸如 undefined, NaN, Infinity 都是Global對(duì)象的屬性。此外所有原生引用類(lèi)型的構(gòu)造函數(shù)，像Object Function也都是Global對(duì)象的屬性

ECMAScript 5 明確進(jìn)制給undefined, NaN 和 Infinity 賦值， 這樣做即使在非嚴(yán)格模式下也會(huì)導(dǎo)致錯(cuò)誤。

ECMAScript 雖然沒(méi)有指出如何直接訪問(wèn)global對(duì)象，但Web瀏覽器都是將這個(gè)全局對(duì)象作為window對(duì)象的一部分加以實(shí)現(xiàn)。因此全局作用域中聲明的所有變量和函數(shù)，就都成為了window對(duì)象的屬性

另一種取得Global對(duì)象的方法是使用this

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

與JavaScript直接編寫(xiě)的計(jì)算功能相比，Math對(duì)象提供的計(jì)算功能執(zhí)行起來(lái)要快的多。

Math對(duì)象的屬性

min() max() 方法用于確定一組數(shù)值中的最小值和最大值?？梢越邮杖我鈧€(gè)數(shù)值參數(shù)。

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

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

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

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

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

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

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

Math.round() 執(zhí)行標(biāo)準(zhǔn)舍入，即它總是將數(shù)值四舍五入為最接近的整數(shù)

random() 返回大于等于0小于1的一個(gè)隨機(jī)數(shù)

// 隨機(jī)生成一個(gè)1到10之間的數(shù)值
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）的一個(gè)數(shù)值

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