Javascript學習筆記（一）

一、<script>元素：該元素定義了下列6個屬性
<1>async:表示應該當即下載腳本，但不該妨礙頁面中的其餘操做，好比下載其餘資源或等待加載其餘腳本。只對外部腳本文件有效。
<2>charset:表示src屬性指定的代碼字符集。
<3>defer:表示腳本能夠延遲到文檔徹底被解析和顯示以後在執行。只對外部腳本有效。IE7及更早版本對嵌入腳本也支持這個屬性
<4>language
<5>src:表示包含要執行代碼的外部文件。
<6>type:表示編寫代碼使用的腳本語言內容類型。
延遲腳本：defer屬性的用途是表示腳本在執行時不會影響頁面的構造。也就是說腳本會被延遲到整個頁面都解析完畢後再運行。至關於告訴瀏覽器當即下載，但延遲執行。
異步腳本：async屬性同defer屬性相似，都用於改變處理腳本的行爲。async的腳本都不保證按照指定他們的前後順序執行。
二、嵌入代碼和外部文件
應儘量使用外部文件來包含JavaScript代碼，優勢是：
1.可維護行：遍佈不一樣HTML頁面的JavaScript會形成維護問題。但把全部JavaScript文件都放在一個文件夾中，維護起來輕鬆多了。並且開發人員所以也可以在不觸及HTML標記的狀況下，集中精力編輯JavaScript代碼；
2.可緩存：瀏覽器可以根據具體的設置緩存連接的全部外部JavaScript文件。也就是說，若是有兩個頁面都使用同一個文件，那麼這個文件只需下載一次。所以，最終結果就是可以加快頁面加載的速度。
3.適應將來：經過外部文件來包含JavaScript無須使用前面提到XHTML或註釋hack。HTML和XHTML包含外部文件的語法是相同的。
三、<noscript>元素：noscript元素中的內容只有在下列狀況下才會顯示出來：
瀏覽器不支持腳本；
瀏覽器支持腳本，但腳本被禁用。
四、基本概念、區分大小寫
五、關鍵字和保留字（*爲新增關鍵字）

====================關鍵字=========================
break do instanceof typeof
case else new var
catch finally return void
continue for switch while
debugger* function this with
default if throw
delete in try

=====================保留字=========================
abstract enum int short
boolean export interface static
byte extends long super
char final native synchronized
class float package throws
const goto private transient
debugger implements protected volatile
double import public
六、數據類型
undefined：值未定義（對還沒有聲明過的變量，只能執行一項操縱，即便用typeof操做符檢測其數據類型）
boolean：布爾值（區分大小寫；字面值爲true和false）
string：字符串
number：數值
object：對象或null
function：函數
注：對未初始化和未聲明的變量指定typeof操做符都返回了undefined值。
1.數值轉換：非數值轉換爲數值函數：Number(),parseInt() 和 parseFloat()。
Number()函數的轉換規則以下：
一、若是是Boolean值，true和false將分別被轉換爲1和0.
二、若是是數字值，只是簡單的傳入和返回；
三、如實是null值，返回0；
四、若是是undefined，返回NaN；
五、若是是字符串，則遵循下列規則：
若是字符串中只包含數字（包括前面帶正號或負號的狀況），則將其轉換爲十進制數值，即"1"會變成 1，"123"會變成 123，而"011"會變成 11（注意：前導的零被忽略了）；
 若是字符串中包含有效的浮點格式，如"1.1"，則將其轉換爲對應的浮點數值（一樣，也會忽略前導零）；
 若是字符串中包含有效的十六進制格式，例如"0xf"，則將其轉換爲相同大小的十進制整數值；
 若是字符串是空的（不包含任何字符），則將其轉換爲 0；
 若是字符串中包含除上述格式以外的字符，則將其轉換爲 NaN。
六、若是是對象，則調用對象的valueOf()方法，而後依照前面的規則轉換返回的值。若是轉換的結果是NaN，則調用對象的toString()方法，而後再次依照前面的規則轉換返回的字符串值。

實例：
var num1 = Number("Hello world!"); //NaN
var num2 = Number(""); //0
var num3 = Number("000011"); //11
var num4 = Number(true); //1
parseInt()函數的轉換規則以下：
parseInt()函數在轉換字符串時，更多的是看其是否符合數值模式。它會忽略字符串前面的空格，直至找到第一個非空格字符。若是第一個字符不是數字字符或者負號，parseInt()就會返回 NaN；
也就是說，用 parseInt()轉換空字符串會返回 NaN（Number()對空字符返回 0）。若是第一個字符是數字字符，parseInt()會繼續解析第二個字符，直到解析完全部後續字符或者遇到了一個非數字字符。
例如，"1234blue"會被轉換爲 1234，由於"blue"會被徹底忽略。相似地，"22.5"會被轉換爲 22，由於小數點並非有效的數字字符。若是字符串中的第一個字符是數字字符，
parseInt()也可以識別出各類整數格式（即前面討論的十進制、八進制和十六進制數）。也就是說，若是字符串以"0x"開頭且後跟數字字符，就會將其看成一個十六進制整數；
若是字符串以"0"開頭且後跟數字字符，則會將其看成一個八進制數來解析。

實例：
var num1 = parseInt("1234blue"); // 1234
var num2 = parseInt(""); // NaN
var num3 = parseInt("0xA"); // 10（十六進制數）
var num4 = parseInt(22.5); // 22
var num5 = parseInt("070"); // 56（八進制數）
var num6 = parseInt("70"); // 70（十進制數）
var num7 = parseInt("0xf"); // 15（十六進制數）

指定基數會影響到轉換的輸出結果。例如：
var num1 = parseInt("10", 2); //2 （按二進制解析）
var num2 = parseInt("10", 8); //8 （按八進制解析）
var num3 = parseInt("10", 10); //10 （按十進制解析）
var num4 = parseInt("10", 16); //16 （按十六進制解析）
注：不指定基數意味着讓 parseInt()決定如何解析輸入的字符串，所以爲了不錯誤的解析，咱們建議不管在什麼狀況下都明確指定基數。

parseFloat()函數的轉換規則以下：
與 parseInt()函數相似，parseFloat()也是從第一個字符（位置0）開始解析每一個字符。並且也是一直解析到字符串末尾，或者解析遇到一個無效的浮點數字字符爲止。也就是說，字符串中第一個小數點是有效的，
而第二個小數點就是無效的了，所以他後面的字符串將被忽略。舉例來講，"22.34.5"將會被轉換爲 22.34。
除了第一個小數點有效以外，parseFloat()與 parseInt()的第二個區別在於它始終都會忽略前導的零。parseFloat()能夠識別前面討論過的全部浮點數值格式，也包括十進制整數格式。
但十六進制格式的字符串則始終會被轉換成 0。因爲 parseFloat()只解析十進制值，所以它沒有用第二個參數指定基數的用法。最後還要注意一點：若是字符串包含的是一個可解析爲整數的數（沒有小數點，或者小數點後
都是零），parseFloat()會返回整數。如下是使用 parseFloat()轉換數值的幾個典型示例。

實例：
var num1 = parseFloat("1234blue"); //1234 （整數）
var num2 = parseFloat("0xA"); //0
var num3 = parseFloat("22.5"); //22.5
var num4 = parseFloat("22.34.5"); //22.34
var num5 = parseFloat("0908.5"); //908.5
var num6 = parseFloat("3.125e7"); //31250000

String()函數遵循下列轉換規則：
若是值有 toString()方法，則調用該方法（沒有參數）並返回相應的結果；
 若是值是 null，則返回"null"；
 若是值是 undefined，則返回"undefined"。

實例：
var value1 = 10;
var value2 = true;
var value3 = null;
var value4;
alert(String(value1)); // "10"
alert(String(value2)); // "true"
alert(String(value3)); // "null"
alert(String(value4)); // "undefined"
注：null 和 undefined 沒有 toString()方法，因此 String()函數就返回了這兩個值的字面量。

七、相等操做符
相等和不相等（!= and ==）--先轉換再比較，全等和不全等（!== and ===）--僅比較而不轉換。
八、基本概念小結
1.ECMAScript 中的基本數據類型包括 Undefined、Null、Boolean、Number 和 String。與其餘語言不一樣，ECMScript 沒有爲整數和浮點數值分別定義不一樣的數據類型，Number 類型可用於表示全部數值。
 2.ECMAScript 中也有一種複雜的數據類型，即 Object 類型，該類型是這門語言中全部對象的基礎類型。嚴格模式爲這門語言中容易出錯的地方施加了限制。
 3.ECMAScript 提供了不少與 C 及其餘類 C 語言中相同的基本操做符，包括算術操做符、布爾操做符、關係操做符、相等操做符及賦值操做符等。
 4.ECMAScript 從其餘語言中借鑑了不少流控制語句，例如 if 語句、for 語句和 switch 語句等。
5.ECMAScript 中的函數與其餘語言中的函數有諸多不一樣之處。無須指定函數的返回值，由於任何 ECMAScript 函數均可以在任什麼時候候返回任何值。實際上，未指定返回值的函數返回的是一個特殊的 undefined 值。
 6.ECMAScript 中也沒有函數簽名的概念，由於其函數參數是以一個包含零或多個值的數組的形式傳遞的。能夠向 ECMAScript 函數傳遞任意數量的參數，而且能夠經過 arguments 對象來訪問這些參數。因爲不存在函數簽名的特性，ECMAScript 函數不能重載。
九、基本類型和引用類型的值
基本類型指的是簡單的數據段（Undefined,Null,Boolean,Number,String），而引用類型指那些可能由多個值構成的對象。
十、執行環境及做用域
執行環境的類型總共只有兩種--全局和局部（函數）。
當執行流進入下列任何一種語句時，做用域鏈就會獲得加長：
1.try-catch 語句的 catch 塊；
2.with 語句。
十一、沒有塊級做用域：Javascript沒有塊級做用域常常會致使理解上的困惑。
經典實例：
if (true) {
var color = "blue";
}
alert(color); //"blue"

for (var i=0; i < 10; i++){
doSomething(i);
}
alert(i); //10
1.聲明變量
使用var聲明的變量會自動被添加到最近的環境中。在函數內部，最接近的環境就是函數的局部環境；在with語句中，最接近的環境是函數環境。若是初始化變量時沒有使用var聲明，該變量會自動被添加到全局環境。
注：在編寫JavaScript代碼的過程當中，不聲明而直接初始化變量是一個常見的錯誤作法，由於這樣可能會致使意外。咱們建議在初始化變量以前，必定要先聲明，這樣就能夠避免相似問題。
在嚴格模式下，初始化未經聲明的變量會致使錯誤。
2.查詢標識符：就近原則，延做用鏈域向上搜索。搜索過程會一直追溯到全局環境的變量對象，若是全局環境中沒有找到標識符，則意味着該變量還沒有聲明。
在搜索過程當中，若是存在一個局部的變量的定義，則搜索會自動中止，再也不進入另外一個變量對象。及局部環境中存在着同名標識符，則不會使用父環境中的標識符。
經典實例：
var color = "blue";
function getColor(){
var color = "red";
return color;
}
alert(getColor()); //"red"
3.JavaScript垃圾收集原理：
找出那些不在繼續使用的變量，而後釋放其佔用的內存。垃圾收集器會按照固定的時間間隔（或代碼執行中預約的收集時間），週期性的執行這一操做。
用於標示無用變量的策略可能會因實現而異，而具體到瀏覽器中的實現，而一般有兩個策略。
標記清除；
垃圾回收器在運行的時候會給存儲在內存中的全部變量都加上標記（固然，可使用任何標記方式）。而後，他會去掉環境中的變量引用的變量和標記。而在次以後再被加上標記的變量將被視爲準備刪除的變量，
緣由是環境中的變量已經沒法訪問到這些變量了。最後，垃圾收集器完成內存清除工做，銷燬哪些帶標記的值並回收它們所佔用的內存空間。
引用計數
管理內存：緣由--分配給Web瀏覽器的可用內存數量一般要比分配給桌面應用程序的少。
十二、變量、做用域和內存問題小結：
JavaScript 變量能夠用來保存兩種類型的值：基本類型值和引用類型值。基本類型的值源自如下 5 種基本數據類型：Undefined、Null、Boolean、Number 和 String。基本類型值和引用類型值具備如下特色：
 一、基本類型值在內存中佔據固定大小的空間，所以被保存在棧內存中：從一個變量向另外一個變量複製基本類型的值，會建立這個值的一個副本；
 二、引用類型的值是對象，保存在堆內存中；
 三、包含引用類型值的變量實際上包含的並非對象自己，而是一個指向該對象的指針；
 四、從一個變量向另外一個變量複製引用類型的值，複製的實際上是指針，所以兩個變量最終都指向同一個對象；
五、肯定一個值是哪一種基本類型可使用 typeof 操做符，而肯定一個值是哪一種引用類型可使用instanceof 操做符。
全部變量（包括基本類型和引用類型）都存在於一個執行環境（也稱爲做用域）當中，這個執行環境決定了變量的生命週期，以及哪一部分代碼能夠訪問其中的變量。如下是關於執行環境的幾點總結：
 一、執行環境有全局執行環境（也稱爲全局環境）和函數執行環境之分；
 二、每次進入一個新執行環境，都會建立一個用於搜索變量和函數的做用域鏈；
 三、函數的局部環境不只有權訪問函數做用域中的變量，並且有權訪問其包含（父）環境，乃至全局環境；
 四、全局環境只能訪問在全局環境中定義的變量和函數，而不能直接訪問局部環境中的任何數據；
 五、變量的執行環境有助於肯定應該什麼時候釋放內存。
JavaScript 是一門具備自動垃圾收集機制的編程語言，開發人員沒必要關心內存分配和回收問題。能夠對 JavaScript 的垃圾收集例程做以下總結。
一、離開做用域的值將被自動標記爲能夠回收，所以將在垃圾收集期間被刪除。
 二、「標記清除」是目前主流的垃圾收集算法，這種算法的思想是給當前不使用的值加上標記，而後再回收其內存。
 三、另外一種垃圾收集算法是「引用計數」，這種算法的思想是跟蹤記錄全部值被引用的次數。JavaScript引擎目前都再也不使用這種算法；但在 IE 中訪問非原生 JavaScript 對象（如 DOM 元素）時，這種算法仍然可能會致使問題。
 四、當代碼中存在循環引用現象時，「引用計數」算法就會致使問題。
 五、解除變量的引用不只有助於消除循環引用現象，並且對垃圾收集也有好處。爲了確保有效地回收內存，應該及時解除再也不使用的全局對象、全局對象屬性以及循環引用變量的引用。

 

1三、引用類型
引用類型是一種結構，用於將數據和功能組織在一塊兒。
1.Object 類型:
建立 Object 實例的方式有兩種：第一種是使用 new 操做符後跟 Object 構造函數。
var person=new Object();
person.name="Rain";
person.age=29;

另外一種方式是使用對象字面量表示法。對象字面量是對象定義的一種簡寫形式，目的在於簡化建立包含大量屬性的對象的過程。
var person={
name:"Rain",
age:29
};
注：在對象最後一個屬性後邊不須要添加逗號，不然會在IE7及更早的版本和Opera中致使錯誤。

JavaScript中使用方括號表示法來訪問對象的屬性。使用時，將要訪問的屬性以字符串的形式放在方括號中。
alert(person["name"]); //"Rain"
alert(person.name); //"Rain"
當屬性名中包含關鍵字或空格時，不能經過點表示法來訪問它。這時候也須要用到方括號訪問對象。
一般，除非必須使用變量來訪問屬性，不然咱們建議使用點表示法。

2.Array ；類型
同其餘語言數組不一樣的是ECMScript數組的每一項能夠保存任何類型的數據。
建立 Array 數組的基本方式有兩種。
第一種是使用 Array 構造函數：
var colors=new Array(20); //建立length值爲20的數組。
var colors=new Array("red","blue","green"); //建立包含3個字符串的數組
在使用 Array 構造函數時也能夠省略 new 操做符：
var colors=Array(20);
var colors=Array("red","blue","green");

第二種是使用數組字面量表示法：
var colors = ["red", "blue", "green"]; //建立一個包含 3 個字符串的數組
Array 對象中的 length 屬性不是隻讀的。經過設置這個屬性，能夠從數組的末尾移除項或向數組中添加項。
var colors = ["red", "blue", "green"];
colors.length=2; //異常colors中的最後一項，使數組長度變爲2
alert(colors[2]); //undefined
注：數組最多能夠包含 4 294 967 295 個項，這幾乎已經知足任何編程需求了。若是想添加的項數超過這個上限值，就會發生異常。
而建立一個初始大小與這個上限值接近的數組，則可能會致使運行時間超長的腳本錯誤。

檢測數組：
使用 instanceof 操做符就能獲得滿意的結果。
if(value instanceof Array){
//操做數組
}
網頁中包含多個框架，那實際上就存在兩個以上不一樣的全局執行環境，從而存在兩個以上不一樣版本的 Array 構造函數。
爲了解決這個問題，ECMAScript 5 新增了 Array.isArray() 方法。這個方法的目的是最終肯定某個值究竟是不是數組，
而無論它是在那個全局執行環境中建立的。
if(Array.isArray(value)){
//操做數組
}
支持 Array.isArray()方法的瀏覽器有 IE9+、Firefox 4+、Safari 5+、Opera 10.5+和 Chrome。要在還沒有實現這個方法中的瀏覽器中準確檢測數組。
轉換方法：
toLocaleString()、toString() 和 valueOf() 方法。（返回由數組中每一個值的字符串形式拼接而成的一個以逗號分隔的字符串）
var colors=["red","blue","green"];
alert(colors.toString()); //red,blue,green
alert(colors.valueOf()); //red,blue,green
alert(colors); //red,blue,green
toLocaleString()方法常常也會返回與 toString()和 valueOf()方法相同的值，但也不老是如此。當調用數組的 toLocaleString()方法時，
它也會建立一個數組值的以逗號分隔的字符串。而與前兩個方法惟一的不一樣之處在於，這一次爲了取得每一項的值，調用的是每一項的 toLocaleString()方法，
而不是toString()方法。
var person1 = {
toLocaleString : function () {
return "Nikolaos";
},

toString : function() {
return "Nicholas";
}
};
var person2 = {
toLocaleString : function () {
return "Grigorios";
},

toString : function() {
return "Greg";
}
};
var people = [person1, person2];
alert(people); //Nicholas,Greg
alert(people.toString()); //Nicholas,Greg
alert(people.toLocaleString()); //Nikolaos,Grigorios

join():該方法只接收一個參數，即用做分隔符的字符串，而後返回包含全部數組項的字符串。
var colors=["red","green","blue"];
alert(colors.join(",")); //red,green,blue
alert(colors.join("||")); //red||green||blue
注：若是數組中的某一項的值是 null 或者 undefined，那麼該值在 join()、toLocaleString() 和 valueOf() 方法返回的結果中以空字符串表示。

棧方法（LIFO 後進先出）
push() 方法能夠接收任意數量的參數，把他們逐個添加到數組末尾，並返回修改數組的長度。
pop() 方法則從數組末尾移除最後一項，減小數組的 length 值，而後返回移除的項。
實例：
var colors = new Array(); // 建立一個數組
var count = colors.push("red", "green"); // 推入兩項
alert(count); //2
count = colors.push("black"); // 推入另外一項
alert(count); //3
var item = colors.pop(); // 取得最後一項
alert(item); //"black"
alert(colors.length); //2

隊列方法（FIFL 先進先出）
shift() 移除數組第一項並返回該項，同時將數組長度減1.
unshift() 它能在數組前端添加任意個項並返回新數組的長度。
實例：
var colors = new Array(); //建立一個數組
var count = colors.unshift("red", "green"); //推入兩項
alert(count); //2
count = colors.unshift("black"); //推入另外一項
alert(count); //3
var item = colors.pop(); //取得最後一項
alert(item); //"green"
alert(colors.length); //2
注：IE7 及更早版本對 JavaScript 的實現中存在一個誤差，其 unshift()方法老是返回 undefined 而不是數組的新長度。IE8 在非兼容模式下會返回正確的長度值。

重排序方法：
reverse() 反轉數組的順序
sort() 按照升序排列數組項。其原理是先調用每一個數組項的 toString() 轉型方法，而後比較獲得的字符串，以肯定如何排序。所以就存在一個問題，即便數組中的每一項
都是數值，sort() 方法比較的也是字符串。
var values=[0,5,2,36,11,9,8,14];
values.sort();
alert(values); //0,11,14,2,36,5,8,9

解決該問題須要添加一個比較函數，並將其做爲參數傳遞給 sort() 方法便可。
實例：
function asc(value1, value2) {
return value1 - value2; //升序
}

function desc(value1, value2) {
return value2 - value1; //降序
}

jsapp.sortAscArray = function() {
var values = [0, 5, 2, 36, 11, 9, 8, 14];
values.sort(asc);
alert(values); //0,2,5,8,9,11,14,36
}

jsapp.sortDescArray = function() {
var values = [0, 5, 2, 36, 11, 9, 8, 14];
values.sort(desc);
alert(values); //36,14,11,9,8,5,2,0
}
注：reverse()和 sort()方法的返回值是通過排序以後的數組。

操做方法：
concat() 方法能夠基於當前數組中的全部項建立一個新數組。（先建立當前數組的一個副本，而後將接收到的參數添加到這個副本的末尾，最後返回新構建的數組。）
slice(start, end) 它可以基於當前數組中的一或多個項建立一個新數組。
slice()方法能夠接受一或兩個參數，即要返回項的起始和結束位置。在只有一個參數的狀況下，slice()方法返回從該參數指定位置開始到當前數組末尾的全部項。
若是有兩個參數，該方法返回起始和結束位置之間的項——但不包括結束位置的項。注意，slice()方法不會影響原始數組。
實例：
var colors = ["red", "green", "blue", "yellow", "purple"];
var colors2 = colors.slice(1);
var colors3 = colors.slice(1,4);
alert(colors2); //green,blue,yellow,purple
alert(colors3); //green,blue,yellow

splice() 方法：使用這種方法的方式主要有以下三種：
1.刪除：能夠刪除任意數量的項，只需指出兩個參數：要刪除的第一項的位置和要刪除的項數。例如：splice(0,2) 會刪除數組中的前兩項。
2.插入：能夠向指定位置插入任意數量的項，只需提供三個參數：起始位置、0（要刪除的項數）和要插入的項。若是要插入多個項，能夠再傳入第4、第五，以致任意多項。
例如，splice(2,0,"red","green")會從當前數組的位置 2 開始插入字符串"red"和"green"。
3.替換：能夠向指定位置插入任意數量的項，且同時刪除任意數量的項，只需指定 3 個參數：起始位置、要刪除的項數和要插入的任意數量的項。插入的項數沒必要與刪除的項數相等。
例如，splice(2,1,"red","green") 會刪除當前數組位置2的項，而後再從位置2開始插入字符串"red"和"green".

splice() 方法始終都會返回一個數組，該數組中包含從原始數組中刪除的項（若是沒有刪除任何項，則返回一個空數組）。

位置方法：
indexOf() 方法從數組的開頭（位置0）開始向後查找
lastIndexOf() 方法則從數組的末尾開始向前查找
這兩個方法都返回要查找的項在數組中的位置，或者在沒找到的狀況下返回-1.（要求查找的項必須嚴格相等，就像=== 同樣）
實例：
var _arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
alert(_arr.lastIndexOf(5, 2)); //-1:lastIndexOf方法查找的方向是從結尾反序查找元素，當前方法的其實位置是2，從位置2倒序查找元素5是找不到的，則返回-1

迭代方法：
ECMAScript 5 爲數組定義了 5 個迭代方法.每一個方法都接收兩個參數：要在每一項上運行的函數和（可選的）運行在該函數的做用域對象---影響 this 的值。
參入這些方法中的函數會接收三個參數：數組項的值、該項在數組中的位置和數組對象自己。
1.every(): 對數組中的每一項運行給定函數，若是該函數對每一項都返回true，則返回true。
2.filter():對數組中的每一項運行給定函數，返回該函數會返回true的項組成的數組。
3.forEach():對數組中的每一項運行給定函數，這個函數沒有返回值。
4.map():對數組中的每一項運行給定的函數，返回每次函數調用的結果組成的數組。
5.some():對數組中的每一項運行給定的函數，若是該函數對任一項返回true，則返回true。
注：以上方法都不會修改數組中的包含的值。

var _arr = [5, 12, 16, 85, 296, 856, 75];
var result = _arr.map(function(item, index, array) {
return item - 500;
});
alert("item - 500:" + result);

歸併函數：
reduce() 從數組的第一項開始，逐個遍歷到最後。
redeceRight() 從數組的最後一項開始，向前遍歷到第一項。
這兩個方法都接收兩個參數：一個在每一項上調用的函數和（可選的）做爲歸併基礎的初始值。
傳給reduce() 和 redeceRight() 的函數接收4個參數：前一個值、當前值、項的索引和數組對象。
這個函數返回的任何值都會做爲第一個參數自動傳給下一項。第一次迭代發生在數組的第二項上，所以第一個參數是數組的第一項，第二個參數就是數組的第二項。
reduce()和reduceRight()主要的區別是從那個方向開始遍歷數組，除此以外，它們徹底相同。

3.Date 類型
日期/時間主鍵組件方法
方 法 說 明
--------------------------------------------------------------------------------------------
getTime() 返回表示日期的毫秒數；與valueOf()方法返回的值相同
setTime(毫秒) 以毫秒數設置日期，會改變整個日期
getFullYear() 取得4位數的年份（如2007而非僅07）
getUTCFullYear() 返回UTC日期的4位數年份
setFullYear(年) 設置日期的年份。傳入的年份值必須是4位數字（如2007而非僅07）
setUTCFullYear(年) 設置UTC日期的年份。傳入的年份值必須是4位數字（如2007而非僅07）
getMonth() 返回日期中的月份，其中0表示一月，11表示十二月
getUTCMonth() 返回UTC日期中的月份，其中0表示一月，11表示十二月
setMonth(月) 設置日期的月份。傳入的月份值必須大於0，超過11則增長年份
setUTCMonth(月) 設置UTC日期的月份。傳入的月份值必須大於0，超過11則增長年份
getDate() 返回日期月份中的天數（1到31）
getUTCDate() 返回UTC日期月份中的天數（1到31）
setDate(日) 設置日期月份中的天數。若是傳入的值超過了該月中應有的天數，則增長月份
setUTCDate(日) 設置UTC日期月份中的天數。若是傳入的值超過了該月中應有的天數，則增長月份
getDay() 返回日期中星期的星期幾（其中0表示星期日，6表示星期六）
getUTCDay() 返回UTC日期中星期的星期幾（其中0表示星期日，6表示星期六）
getHours() 返回日期中的小時數（0到23）
getUTCHours() 返回UTC日期中的小時數（0到23）
setHours(時) 設置日期中的小時數。傳入的值超過了23則增長月份中的天數
setUTCHours(時) 設置UTC日期中的小時數。傳入的值超過了23則增長月份中的天數
getMinutes() 返回日期中的分鐘數（0到59）
getUTCMinutes() 返回UTC日期中的分鐘數（0到59）
setMinutes(分) 設置日期中的分鐘數。傳入的值超過59則增長小時數
setUTCMinutes(分) 設置UTC日期中的分鐘數。傳入的值超過59則增長小時數
getSeconds() 返回日期中的秒數（0到59）
getUTCSeconds() 返回UTC日期中的秒數（0到59）
setSeconds(秒) 設置日期中的秒數。傳入的值超過了59會增長分鐘數
setUTCSeconds(秒) 設置UTC日期中的秒數。傳入的值超過了59會增長分鐘數
getMilliseconds() 返回日期中的毫秒數
getUTCMilliseconds() 返回UTC日期中的毫秒數
setMilliseconds(毫秒) 設置日期中的毫秒數
setUTCMilliseconds(毫秒) 設置UTC日期中的毫秒數
getTimezoneOffset() 返回本地時間與UTC時間相差的分鐘數。例如，美國東部標準時間返回300。在某地進入夏令時的狀況下，這個值會有所變化
------------------------------------------------------------------------------------------------------------------------------------

4.RegExp 類型 用來支持正則表達式。略過

5.Function 類型
函數實際是對象，所以函數名實際上也是一個指向函數對象的指針，不會與某個函數綁定。
解析器在想執行環境中加載數據時，對函數聲明和函數表達式並不是一視同仁。解析器會率先讀取函數聲明，並使其在執行任何代碼以前可用（可訪問）；
至於函數表達式，則必須等到解析器執行到它所在的代碼行，纔會真正被解釋執行。

做爲值的函數
由於ECMAScript中的函數名自己就是變量，因此函數也能夠做爲值來使用。所以，能夠像傳遞參數同樣把一個函數傳遞給另外一個函數，並且能夠將一個函數做爲另外一個函數結果返回。

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

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

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

函數的名字僅僅是一個包含指針的變量，即便是在不一樣的環境中執行，全局的 syaColor()函數和 o.sysColor()指向的仍然是同一個函數。

函數對象的另外一個屬性caller,這個屬性中保存着調用當前函數的函數的引用，若是在全局做用域中調用當前函數，它的值爲null。

函數的屬性和方法
函數都包含兩個屬性：length ：表示當前函數但願接收的命名參數的個數；
prototype：保存函數全部實例方法的真是所在。該屬性是不可枚舉的，所以使用 for-in 沒法發現。

每一個函數都包含了兩個非繼承而來的方法：apply() 和 call().

apply() 方法接收兩個參數：一個是在其中運行函數的做用域，另外一個是參數數組。其中第二個參數能夠是 Array 的實例，也能夠是 arguments 對象來訪問這些參數。因爲不存在函數簽名的特性，ECMAScript

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

function callSum1(num1,num2){
return sum.apply(this,arguments);
}

function callSum2(num1,num2){
return sum.apply(this,[num1,num2]);
}

function callSum3(num1,num2){
return sum.call(this,num1,num2);
}

alert(callSum1(10,10)); //20
alert(callSum2(10,10)); //20
alert(callSum3(10,10)); //20

call() 方法與 apply() 方法的做用相同，它們的區別僅在與接收參數的方式不一樣。第一個參數是 this 值沒有變化，變化的是其他參數都直接傳遞給函數，必須逐個列舉出來。

bind() 方法會建立一個函數的實例，其 this 值會被綁定到傳給 bind() 函數在轉換字符串時，更多的是看其是否符合數值模式。它會忽略字符串前面的空格，直至找到第一個非空格字符。若是第一個字符不是數字字符或者負號，parseInt

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

function sayColor(){
alert(this.color);
}

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

1四、基本類型

6.Number 類型
方法：toString()
var num = 10;
alert(num.toString()); //"10"
alert(num.toString(2)); //"1010"
alert(num.toString(8)); //"12"
alert(num.toString(10)); //"10"
alert(num.toString(16)); //"a"

toFixed()會按照指定的小數位返回數值的字符串表示
alert(num.toFixed(2)); //"10.00"

toExponential()該方法返回以指數表示法（也稱e 表示法）表示的數值的字符串形式。
alert(num.toExponential(1)); //"1.0e+1"

toPrecision()
alert(num.toPrecision(1)); //"1e+2"
alert(num.toPrecision(2)); //"99"
alert(num.toPrecision(3)); //"99.0"

7.String 類型
字符串方法；
charAt() :
charCodeAt() :這兩個方法都是訪問字符串中的特定字符（接收的參數是基於 0 的字符位置）
concat() :用於將一個或多個字符串拼接起來，返回拼接獲得的新字符串。
slice(start, end) :
substr(start,len) :
substring(start,end) :這三個方法都會返回被操做字符串的一個子字符串，並且也都接受一或兩個參數。
當傳遞的參數是負值的狀況下，它們的行爲就不盡相同了。
slice()方法會將傳入的負值與字符串的長度相加，substr()方法將負的第一個參數加上字符串的長度，而將負的第二個參數轉換爲 0，
substring()方法會把全部負值參數都轉換爲0.

實例：
var stringValue = "hello world";
alert(stringValue.slice(3)); //"lo world"
alert(stringValue.substring(3)); //"lo world"
alert(stringValue.substr(3)); //"lo world"
alert(stringValue.slice(3, 7)); //"lo w"
alert(stringValue.substring(3,7)); //"lo w"
alert(stringValue.substr(3, 7)); //"lo worl"

var stringValue = "hello world";
alert(stringValue.slice(-3)); //"rld"
alert(stringValue.substring(-3)); //"hello world"
alert(stringValue.substr(-3)); //"rld"
alert(stringValue.slice(3, -4)); //"lo w"
alert(stringValue.substring(3, -4)); //"hel"
alert(stringValue.substr(3, -4)); //""（空字符串）

字符串位置函數
indexOf()：從前向後檢索
lastIndexOf()：從後向前檢索
trim()：建立一個字符串的副本，刪除前置及後綴的全部空格，而後返回結果。

字符串大小寫轉換方法
toLowerCase()：轉換爲小寫
toLocaleLowerCase():
toUpperCase()：轉換爲大寫
toLocaleUpperCase()：

字符串的模式匹配方法
match()：與RegExp 的 exec() 方法相同。match() 方法只接受一個參數，要麼是一個正則表達式，要麼是一個 RegExp 對象來訪問這些參數。
該方法返回一個數組，保存着與正則表達式中的捕獲組匹配的字符串。

search()：參數與 match() 相同，返回字符串中第一個匹配項的索引。該方法始終是從字符串開頭向後查找模式。

replace()：這個方法接受兩個參數：第一個參數能夠是一個RegExp 對象或者一個字符串（這個字符串不會被轉換成正則表達式），第二個參
數能夠是一個字符串或者一個函數。若是第一個參數是字符串，那麼只會替換第一個子字符串。
要想替換全部子字符串，惟一的辦法就是提供一個正則表達式，並且要指定全局（g）標誌。

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

localeCompare() 方法：比較兩個字符串
返回值爲下列值中的一個：
若是字符串在字母表中應該排在字符串參數以前，則返回一個負數（一般爲-1）
若是字符串等於字符串參數，則返回0
若是字符串在字母表中應該排在字符串參數以後，則返回一個正數（一般爲1）

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

fromCharCode() 方法：接收一或多個字符編碼，而後將他們轉換成一個字符串。
從本質上看，這個方法與實例方法 charCodeAt() 執行的是相反的操做。

八、單體內置對象
由ECMAScript實現提供的、不依賴於宿主環境的對象，這些對象在ECMAScript程序執行以前就已經存在了。
程序員沒必要顯式地實例化內置對象，由於他們已經實例化了。（Object 、Array 、String 、Global 和 Math）

1.Global對象：全部全局做用域中定義的屬性和函數都是Global對象的屬性。
1.1 URI編碼方法：對URI（Uniform Resource Identifiers,通用資源標識符）進行編碼，一邊發送給瀏覽器。
encodeURI():主要用於整個URI編碼，不會對自己屬於URI的特殊字符進行編碼。
encodeURIComponent():主要用於對URI中的某一段進行編碼，會對任何非標準字符進行編碼。

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

使用encodeURI()編碼後的結果是除了空格以外的其餘字符都原封不動，只有空格被替換成了%20。而encodeURIComponent()方法則會使用對應的編碼替換全部非字母數字字符。這也正是能夠
對整個URI 使用encodeURI()，而只能對附加在現有URI 後面的字符串使用encodeURIComponent()的緣由所在。

注：encodeURIComponent()使用比較多，由於實踐中更多的是對查詢字符串參數而不是對基礎URI進行編碼。

1.2 URI解碼方法：
decodeURI():
decodeURIComponent():

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

1.3 eval() 方法 就像一個完整的ECMAScript解析器，它只接受一個參數，即要執行的ECMAScript（或JavaScript）字符串。

var msg = "hello world";
eval("alert(msg)"); //"hello world"

2.window 對象

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

3.Math 對象：提供了數學公式和信息
min():獲取最小值
max():獲取最大值
實例：
var values = [1, 2, 3, 4, 5, 6, 7, 8];
var max = Math.max.apply(Math, values);

4.舍入方法
ceil():執行向上舍入，即它老是將數值向上舍入爲最接近的整數；
floor():執行向下舍入，即它老是將數值向下舍入爲最接近的整數；
round():執行標準舍入，即他老是將數值四捨五入爲最接近的整數。

5.隨機方法
random():返回大於等於0小於1的一個隨機數。

小結：
>一、引用類型與傳統面向對象程序設計中的類類似，但實現不一樣；
>二、Object 是一個基礎類型，其中全部類型都從 Object 繼承了基本的行爲；
>三、Array 類型是一組值得有序列表，同時還提供了操做轉換這些值得功能；
>四、Date 類型提供了有關日期和時間的信息包括當前日期和時間以及相關的計算功能；
>五、RegExp 類型是ECMAScript支持正則表達式的一個接口，提供了最基本的和一些高級的正則表達式功能。

函數其實是Function 類型的實例，所以函數也是對象；而這一點正是JavaScript 最有特點的地 方。因爲函數是對象，因此函數也擁有方法，能夠用來加強其行爲。 由於有了基本包裝類型，因此JavaScript 中的基本類型值能夠被看成對象來訪問。三種基本包裝類 型分別是：Boolean、Number 和String。如下是它們共同的特徵： >一、每一個包裝類型都映射到同名的基本類型； >二、在讀取模式下訪問基本類型值時，就會建立對應的基本包裝類型的一個對象，從而方便了數據 操做； >三、操做基本類型值的語句一經執行完畢，就會當即銷燬新建立的包裝對象。 在全部代碼執行以前，做用域中就已經存在兩個內置對象：Global 和Math。在大多數ECMAScript 實現中都不能直接訪問Global 對象；不過，Web 瀏覽器實現了承擔該角色的window 對象。全局變 量和函數都是Global 對象的屬性。Math 對象提供了不少屬性和方法，用於輔助完成複雜的數學計算 任務。