摘要：復(fù)習(xí)基礎(chǔ)到底是什么的應(yīng)用場(chǎng)合極其廣泛。常量不可以通過(guò)重新賦值改變其值，也不可以在代碼運(yùn)行時(shí)重新聲明。布爾對(duì)象是原始布爾數(shù)據(jù)類型的一個(gè)包裝器整數(shù)整數(shù)可以用十進(jìn)制基數(shù)為十六進(jìn)制基數(shù)為八進(jìn)制基數(shù)為以及二進(jìn)制基數(shù)為表示。

JavaScript 的應(yīng)用場(chǎng)合極其廣泛。簡(jiǎn)單到幻燈片、照片庫(kù)、浮動(dòng)布局和響應(yīng)按鈕點(diǎn)擊。復(fù)雜到游戲、2D 和 3D 動(dòng)畫(huà)、大型數(shù)據(jù)庫(kù)驅(qū)動(dòng)程序，等等。

JavaScript 相當(dāng)簡(jiǎn)潔，卻非常靈活。開(kāi)發(fā)者們基于 JavaScript 核心編寫(xiě)了大量實(shí)用工具，可以使 開(kāi)發(fā)工作事半功倍。其中包括：

瀏覽器應(yīng)用程序接口（API）—— 瀏覽器內(nèi)置的 API 提供了豐富的功能，比如：動(dòng)態(tài)創(chuàng)建 HTML 和設(shè)置 CSS 樣式、從用戶的攝像頭采集處理視頻流、生成3D 圖像與音頻樣本，等等。

第三方 API —— 讓開(kāi)發(fā)者可以在自己的站點(diǎn)中整合其它內(nèi)容提供者（Twitter、Facebook 等）提供的功能。

第三方框架和庫(kù) —— 用來(lái)快速構(gòu)建網(wǎng)站和應(yīng)用。

在應(yīng)用程序中，使用變量來(lái)作為值的符號(hào)名。變量的名字又叫做標(biāo)識(shí)符，其需要遵守一定的規(guī)則。

一個(gè) JavaScript 標(biāo)識(shí)符必須以字母、下劃線（_）或者美元符號(hào)（$）開(kāi)頭；后續(xù)的字符也可以是數(shù)字（0-9）。因?yàn)?JavaScript 語(yǔ)言是區(qū)分大小寫(xiě)的，所以字母可以是從“A”到“Z”的大寫(xiě)字母和從“a”到“z”的小寫(xiě)字母。

字符串轉(zhuǎn)換為數(shù)字
有一些方法可以將內(nèi)存中表示一個(gè)數(shù)字的字符串轉(zhuǎn)換為對(duì)應(yīng)的數(shù)字。parseInt()和parseFloat()

parseInt 方法只能返回整數(shù)，所以使用它會(huì)丟失小數(shù)部分。另外，調(diào)用 parseInt 時(shí)最好總是帶上進(jìn)制(radix) 參數(shù)，這個(gè)參數(shù)用于指定使用哪一種進(jìn)制。

將字符串轉(zhuǎn)換為數(shù)字的另一種方法是使用一元加法運(yùn)算符。

"1.1" + "1.1" = "1.11.1"
(+"1.1") + (+"1.1") = 2.2   
// 注意：加入括號(hào)為清楚起見(jiàn)，不是必需的。

var 聲明全局變量和局部變量
let 聲明塊作用域的局部變量
const 聲明一個(gè)常量

使用var和let聲明的變量時(shí)沒(méi)有賦予初始值的，其值為undefined，

var a;
console.log("The value of a is " + a); // a 的值是 undefined

console.log("The value of b is " + b);// b 的值是 undefined 
var b;


console.log("The value of c is " + c); // 未捕獲的引用錯(cuò)誤： c 未被定義

let x;
console.log("The value of x is " + x); // x 的值是 undefined

console.log("The value of y is " + y);// 未捕獲的引用錯(cuò)誤： y 未被定義
let y;

你可以使用 undefined 來(lái)判斷一個(gè)變量是否已賦值。在以下的代碼中，變量input未被賦值，因此 if 條件語(yǔ)句的求值結(jié)果是 true

var input;
if(input === undefined){
  doThis();
} else {
  doThat();
}

undefined 值在布爾類型環(huán)境中會(huì)被當(dāng)作 false 。

數(shù)值類型環(huán)境中 undefined 值會(huì)被轉(zhuǎn)換為 NaN。

當(dāng)你對(duì)一個(gè) null 變量求值時(shí)，空值 null 在數(shù)值類型環(huán)境中會(huì)被當(dāng)作0來(lái)對(duì)待，而布爾類型環(huán)境中會(huì)被當(dāng)作 false

var n = null;
console.log(n * 32); // 在控制臺(tái)中會(huì)顯示 0

在函數(shù)之外聲明的變量，叫做全局變量，因?yàn)樗杀划?dāng)前文檔中的任何其他代碼所訪問(wèn)。在函數(shù)內(nèi)部聲明的變量，叫做局部變量，因?yàn)樗荒茉诋?dāng)前函數(shù)的內(nèi)部訪問(wèn)。

ECMAScript 6 之前的 JavaScript 沒(méi)有 語(yǔ)句塊 作用域；相反，語(yǔ)句塊中聲明的變量將成為語(yǔ)句塊所在函數(shù)（或全局作用域）的局部變量。例如，如下的代碼將在控制臺(tái)輸出 5，因?yàn)?x 的作用域是聲明了 x 的那個(gè)函數(shù)（或全局范圍），而不是 if 語(yǔ)句塊。

if (true) {
  var x = 5;
}
console.log(x); // 5

如果使用 ECMAScript 6 中的 let 聲明，上述行為將發(fā)生變化。

if (true) {
  let y = 5;
}
console.log(y); // ReferenceError: y 沒(méi)有被聲明

JavaScript 變量的另一個(gè)不同尋常的地方是，你可以先使用變量稍后再聲明變量而不會(huì)引發(fā)異常。這一概念稱為變量提升；JavaScript 變量感覺(jué)上是被“提升”或移到了函數(shù)或語(yǔ)句的最前面。但是，提升后的變量將返回 undefined 值。因此在使用或引用某個(gè)變量之后進(jìn)行聲明和初始化操作，這個(gè)被提升的變量仍將返回 undefined 值。

/**
 * 例子1
 */
console.log(x === undefined); // true
var x = 3;


/**
 * 例子2
 */
// will return a value of undefined
var myvar = "my value";

(function() {
  console.log(myvar); // undefined
  var myvar = "local value";
})();


//詳細(xì)解釋就是
/**
 * 例子1
 */
var x;
console.log(x === undefined); // true
x = 3;
 
/**
 * 例子2
 */
var myvar = "my value";
 
(function() {
  var myvar;
  console.log(myvar); // undefined
  myvar = "local value";
})();

由于存在變量提升，一個(gè)函數(shù)中所有的var語(yǔ)句應(yīng)盡可能地放在接近函數(shù)頂部的地方。這個(gè)習(xí)慣將大大提升代碼的清晰度。

在 ECMAScript 6 中，let（const）將不會(huì)提升變量到代碼塊的頂部。因此，在變量聲明之前引用這個(gè)變量，將拋出引用錯(cuò)誤（ReferenceError）。這個(gè)變量將從代碼塊一開(kāi)始的時(shí)候就處在一個(gè)“暫時(shí)性死區(qū)”，直到這個(gè)變量被聲明為止。

console.log(x); // ReferenceError
let x = 3;

對(duì)于函數(shù)來(lái)說(shuō)，只有函數(shù)聲明會(huì)被提升到頂部，而函數(shù)表達(dá)式不會(huì)被提升。

/* 函數(shù)聲明 */

foo(); // "bar"

function foo() {
  console.log("bar");
}


/* 函數(shù)表達(dá)式 */

baz(); // 類型錯(cuò)誤：baz 不是一個(gè)函數(shù)

var baz = function() {
  console.log("bar2");
};

你可以用關(guān)鍵字 const 創(chuàng)建一個(gè)只讀的常量。常量標(biāo)識(shí)符的命名規(guī)則和變量相同：必須以字母、下劃線（_）或美元符號(hào)（$）開(kāi)頭并可以包含有字母、數(shù)字或下劃線。

const PI = 3.14;

常量不可以通過(guò)重新賦值改變其值，也不可以在代碼運(yùn)行時(shí)重新聲明。它必須被初始化為某個(gè)值。

常量的作用域規(guī)則與 let 塊級(jí)作用域變量相同。若省略const關(guān)鍵字，則該標(biāo)識(shí)符將被視為變量。

在同一作用域中，不能使用與變量名或函數(shù)名相同的名字來(lái)命名常量。

然而，對(duì)象屬性被賦值為常量是不受保護(hù)的，所以下面的語(yǔ)句執(zhí)行時(shí)不會(huì)產(chǎn)生錯(cuò)誤。

const MY_OBJECT = {"key": "value"};
MY_OBJECT.key = "otherValue";

同樣的，數(shù)組的被定義為常量也是不受保護(hù)的，所以下面的語(yǔ)句執(zhí)行時(shí)也不會(huì)產(chǎn)生錯(cuò)誤。

const MY_ARRAY = ["HTML","CSS"];
MY_ARRAY.push("JAVASCRIPT");
console.log(MY_ARRAY); //logs ["HTML","CSS","JAVASCRIPT"];

譯注：字面量是由語(yǔ)法表達(dá)式定義的常量；或，通過(guò)由一定字詞組成的語(yǔ)詞表達(dá)式定義的常量

在JavaScript中，你可以使用各種字面量。這些字面量是腳本中按字面意思給出的固定的值，而不是變量。（譯注：字面量是常量，其值是固定的，而且在程序腳本運(yùn)行中不可更改

數(shù)組字面值是一個(gè)封閉在方括號(hào)對(duì)([])中的包含有零個(gè)或多個(gè)表達(dá)式的列表，其中每個(gè)表達(dá)式代表數(shù)組的一個(gè)元素。當(dāng)你使用數(shù)組字面值創(chuàng)建一個(gè)數(shù)組時(shí)，該數(shù)組將會(huì)以指定的值作為其元素進(jìn)行初始化，而其長(zhǎng)度被設(shè)定為元素的個(gè)數(shù)。

下面的示例用3個(gè)元素生成數(shù)組coffees，它的長(zhǎng)度是3。

var coffees = ["French Roast", "Colombian", "Kona"];

var a=[3];

console.log(a.length); // 1

console.log(a[0]); // 3
//注意 這里的數(shù)組字面值也是一種對(duì)象初始化器。

若在頂層（全局）腳本里用字面值創(chuàng)建數(shù)組，JavaScript語(yǔ)言將會(huì)在每次對(duì)包含該數(shù)組字面值的表達(dá)式求值時(shí)解釋該數(shù)組。另一方面，在函數(shù)中使用的數(shù)組，將在每次調(diào)用函數(shù)時(shí)都會(huì)被創(chuàng)建一次。

數(shù)組字面值同時(shí)也是數(shù)組對(duì)象。有關(guān)數(shù)組對(duì)象的詳情請(qǐng)參見(jiàn)數(shù)組對(duì)象一文。

數(shù)組字面值中的多余逗號(hào)
（譯注：聲明時(shí)）你不必列舉數(shù)組字面值中的所有元素。若你在同一行中連寫(xiě)兩個(gè)逗號(hào)（,），數(shù)組中就會(huì)產(chǎn)生一個(gè)沒(méi)有被指定的元素，其初始值是undefined。以下示例創(chuàng)建了一個(gè)名為fish的數(shù)組：

var fish = ["Lion", , "Angel"];

在這個(gè)數(shù)組中，有兩個(gè)已被賦值的元素，和一個(gè)空元素（fish[0]是"Lion"，fish[1]是undefined，而fish[2]是"Angel"；譯注：此時(shí)數(shù)組的長(zhǎng)度屬性fish.length是3)。

如果你在元素列表的尾部添加了一個(gè)逗號(hào)，它將會(huì)被忽略。在下面的例子中，數(shù)組的長(zhǎng)度是3，并不存在myList[3]這個(gè)元素（譯注：這是指數(shù)組的第4個(gè)元素噢，作者是在幫大家復(fù)習(xí)數(shù)組元素的排序命名方法）。元素列表中其它所有的逗號(hào)都表示一個(gè)新元素（的開(kāi)始）。

注意：尾部的逗號(hào)在早期版本的瀏覽器中會(huì)產(chǎn)生錯(cuò)誤，因而編程時(shí)的最佳實(shí)踐方式就是移除它們。

(譯注：而“現(xiàn)代”的瀏覽器似乎鼓勵(lì)這種方式，這也很好解釋原因。尾部逗號(hào)可以減少向數(shù)組的最后添加元素時(shí)，因?yàn)橥洖檫@最后一個(gè)元素加逗號(hào) 所造成的錯(cuò)誤。)

var myList = ["home", , "school", ];

在下面的例子中，數(shù)組的長(zhǎng)度是4，元素myList[0]和myList[2]缺失（譯注：沒(méi)被賦值，因而是undefined）。

var myList = [ , "home", , "school"];

再看一個(gè)例子。在這里，該數(shù)組的長(zhǎng)度是4，元素myList[1]和myList[3]被漏掉了。（但是）只有最后的那個(gè)逗號(hào)被忽略。

var myList = ["home", , "school", , ];

理解多余的逗號(hào)（在腳本運(yùn)行時(shí)會(huì)被如何處理）的含義，對(duì)于從語(yǔ)言層面理解JavaScript是十分重要的。但是，在你自己寫(xiě)代碼時(shí)：顯式地將缺失的元素聲明為undefined，將大大提高你的代碼的清晰度和可維護(hù)性。

布爾類型有兩種字面量：true和false。

不要混淆作為布爾對(duì)象的真和假與布爾類型的原始值true和false。布爾對(duì)象是原始布爾數(shù)據(jù)類型的一個(gè)包裝器

整數(shù)可以用十進(jìn)制（基數(shù)為10）、十六進(jìn)制（基數(shù)為16）、八進(jìn)制（基數(shù)為8）以及二進(jìn)制（基數(shù)為2）表示。

十進(jìn)制整數(shù)字面量由一串?dāng)?shù)字序列組成，且沒(méi)有前綴0。

八進(jìn)制的整數(shù)以 0（或0O、0o）開(kāi)頭，只能包括數(shù)字0-7。

十六進(jìn)制整數(shù)以0x（或0X）開(kāi)頭，可以包含數(shù)字（0-9）和字母 a~f 或 A~F。

二進(jìn)制整數(shù)以0b（或0B）開(kāi)頭，只能包含數(shù)字0和1。

嚴(yán)格模式下，八進(jìn)制整數(shù)字面量必須以0o或0O開(kāi)頭，而不能以0開(kāi)頭。

整數(shù)字面量舉例：

0, 117 and -345 (十進(jìn)制, 基數(shù)為10)
015, 0001 and -0o77 (八進(jìn)制, 基數(shù)為8) 
0x1123, 0x00111 and -0xF1A7 (十六進(jìn)制, 基數(shù)為16或"hex")
0b11, 0b0011 and -0b11 (二進(jìn)制, 基數(shù)為2)

對(duì)象字面值是封閉在花括號(hào)對(duì)({})中的一個(gè)對(duì)象的零個(gè)或多個(gè)"屬性名-值"對(duì)的（元素）列表。你不能在一條語(yǔ)句的開(kāi)頭就使用對(duì)象字面值，這將導(dǎo)致錯(cuò)誤或產(chǎn)生超出預(yù)料的行為， 因?yàn)榇藭r(shí)左花括號(hào)（{）會(huì)被認(rèn)為是一個(gè)語(yǔ)句塊的起始符號(hào)。（譯者：這 里需要對(duì)語(yǔ)句statement、塊block等基本名詞的解釋）

以下是一個(gè)對(duì)象字面值的例子。對(duì)象car的第一個(gè)元素（譯注：即一個(gè)屬性/值對(duì)）定義了屬性myCar；第二個(gè)元素，屬性getCar，引用了一個(gè)函數(shù)（即CarTypes("Honda")）；第三個(gè)元素，屬性special，使用了一個(gè)已有的變量（即Sales）。

var Sales = "Toyota";

function CarTypes(name) {
  return (name === "Honda") ?
    name :
    "Sorry, we don"t sell " + name + "." ;
}

var car = { myCar: "Saturn", getCar: CarTypes("Honda"), special: Sales };

console.log(car.myCar);   // Saturn
console.log(car.getCar);  // Honda
console.log(car.special); // Toyota

更進(jìn)一步的，你可以使用數(shù)字或字符串字面值作為屬性的名字，或者在另一個(gè)字面值內(nèi)嵌套上一個(gè)字面值。如下的示例中使用了這些可選項(xiàng)。

var car = { manyCars: {a: "Saab", "b": "Jeep"}, 7: "Mazda" };

console.log(car.manyCars.b); // Jeep
console.log(car[7]); // Mazda

對(duì)象屬性名字可以是任意字符串，包括空串。如果對(duì)象屬性名字不是合法的javascript標(biāo)識(shí)符，它必須用""包裹。屬性的名字不合法，那么便不能用.訪問(wèn)屬性值，而是通過(guò)類數(shù)組標(biāo)記("[]")訪問(wèn)和賦值。

var unusualPropertyNames = {
  "": "An empty string",
  "!": "Bang!"
}
console.log(unusualPropertyNames."");   // 語(yǔ)法錯(cuò)誤: Unexpected string
console.log(unusualPropertyNames[""]);  // An empty string
console.log(unusualPropertyNames.!);    // 語(yǔ)法錯(cuò)誤: Unexpected token !
console.log(unusualPropertyNames["!"]); // Bang!

字符串字面量是由雙引號(hào)（"）對(duì)或單引號(hào)（"）括起來(lái)的零個(gè)或多個(gè)字符。字符串被限定在同種引號(hào)之間；也即，必須是成對(duì)單引號(hào)或成對(duì)雙引號(hào)。下面的例子都是字符串字面值：

"foo"
"bar"
"1234"
"one line 
 another line"
"John"s cat"

你可以在字符串字面值上使用字符串對(duì)象的所有方法——JavaScript會(huì)自動(dòng)將字符串字面值轉(zhuǎn)換為一個(gè)臨時(shí)字符串對(duì)象，調(diào)用該方法，然后廢棄掉那個(gè)臨時(shí)的字符串對(duì)象。你也能用對(duì)字符串字面值使用類似String.length的屬性：

console.log("John"s cat".length) 
// 將打印字符串中的字符個(gè)數(shù)（包括空格） 
// 結(jié)果為：10

在ES2015中，還提供了一種模板字符串（template literals），模板字符串提供了一些語(yǔ)法糖來(lái)幫你構(gòu)造字符串。這與Perl、Python還有其他語(yǔ)言中的字符串插值（string interpolation）的特性非常相似。除此之外，你可以在通過(guò)模板字符串前添加一個(gè)tag來(lái)自定義模板字符串的解析過(guò)程，這可以用來(lái)防止注入攻擊，或者用來(lái)建立基于字符串的高級(jí)數(shù)據(jù)抽象。

// Basic literal string creation
`In JavaScript "
" is a line-feed.`

// Multiline strings
`In JavaScript this is
 not legal.`

// String interpolation
var name = "Bob", time = "today";
`Hello ${name}, how are you ${time}?`

// Construct an HTTP request prefix is used to interpret the replacements and construction
POST`http://foo.org/bar?a=${a}&b=$
     Content-Type: application/json
     X-Credentials: ${credentials}
     { "foo": ${foo},
       "bar": ${bar}}`(myOnReadyStateChangeHandler);

除非有特別需要使用字符串對(duì)象，否則,你應(yīng)當(dāng)始終使用字符串字面值。

條件判斷語(yǔ)句指的是根據(jù)指定的條件所返回的結(jié)果（真或假或其它預(yù)定義的），來(lái)執(zhí)行特定的語(yǔ)句。JavaScript 支持兩種條件判斷語(yǔ)句：if...else和switch。

let iceCream = "chocolate";
if (iceCream === "chocolate") {
  alert("我最喜歡巧克力冰激淋了。");    
} else {
  alert("但是巧克力才是我的最愛(ài)呀……");    
}

你可以用 throw 語(yǔ)句拋出一個(gè)異常并且用 try...catch 語(yǔ)句捕獲處理它。

throw 語(yǔ)句

try...catch 語(yǔ)句

從 ECMAScript 6 開(kāi)始，JavaScript 增加了對(duì) Promise 對(duì)象的支持，它允許你對(duì)延時(shí)和異步操作流進(jìn)行控制。

Promise 對(duì)象有以下幾種狀態(tài)：

pending：初始的狀態(tài)，即正在執(zhí)行，不處于 fulfilled 或 rejected 狀態(tài)。

fulfilled：成功的完成了操作。

rejected：失敗，沒(méi)有完成操作。

settled：Promise 處于 fulfilled 或 rejected 二者中的任意一個(gè)狀態(tài), 不會(huì)是 pending。

展現(xiàn)了 Promise 的工作流

function imgLoad(url) {
  return new Promise(function(resolve, reject) {
    var request = new XMLHttpRequest();
    request.open("GET", url);
    request.responseType = "blob";
    request.onload = function() {
      if (request.status === 200) {
        resolve(request.response);
      } else {
        reject(Error("Image didn"t load successfully; error code:" 
                     + request.statusText));
      }
    };
    request.onerror = function() {
      reject(Error("There was a network error."));
    };
    request.send();
  });
}

JavaScript中提供了這些循環(huán)語(yǔ)句：

for 語(yǔ)句

do...while 語(yǔ)句

while 語(yǔ)句

labeled 語(yǔ)句

break 語(yǔ)句

continue 語(yǔ)句

for...in 語(yǔ)句

for...of 語(yǔ)句

一個(gè)for循環(huán)會(huì)一直重復(fù)執(zhí)行，直到指定的循環(huán)條件為fasle。 JavaScript的for循環(huán)和Java與C的for循環(huán)是很相似的。

for ([initialExpression]; [condition]; [incrementExpression])
  statement

當(dāng)一個(gè)for循環(huán)執(zhí)行的時(shí)候，會(huì)發(fā)生以下事件：

如果有初始化表達(dá)式initialExpression，它將被執(zhí)行。這個(gè)表達(dá)式通常會(huì)初始化一個(gè)或多個(gè)循環(huán)計(jì)數(shù)器，但語(yǔ)法上是允許一個(gè)任意復(fù)雜度的表達(dá)式的。這個(gè)表達(dá)式也可以聲明變量。

計(jì)算condition表達(dá)式的值。如果condition的值是true，循環(huán)中的statement會(huì)被執(zhí)行。如果condition的值是false，for循環(huán)終止。如果condition表達(dá)式整個(gè)都被省略掉了，condition的值會(huì)被認(rèn)為是true。

循環(huán)中的 statement被執(zhí)行。如果需要執(zhí)行多條語(yǔ)句，可以使用塊 ({ ... })來(lái)包裹這些語(yǔ)句。

如果有更新表達(dá)式incrementExpression，執(zhí)行它.

然后流程回到步驟2。

  

    Choose some music types, then click the button below:
    
      R&B
      爵士
      布魯斯
      新紀(jì)元
      古典
      歌劇
    
  
  

do...while 語(yǔ)句一直重復(fù)直到指定的條件求值得到假（false）。 一個(gè) do...while 語(yǔ)句看起來(lái)像這樣：

do
  statement
while (condition);

statement 在檢查條件之前會(huì)執(zhí)行一次。要執(zhí)行多條語(yǔ)句（語(yǔ)句塊），要使用塊語(yǔ)句 ({ ... }) 包括起來(lái)。 如果 condition 為真（true），statement 將再次執(zhí)行。 在每個(gè)執(zhí)行的結(jié)尾會(huì)進(jìn)行條件的檢查。當(dāng) condition 為假（false），執(zhí)行會(huì)停止并且把控制權(quán)交回給 do...while 后面的語(yǔ)句。

在下面的例子中， 這個(gè) do 循環(huán)將至少重復(fù)一次并且一直重復(fù)直到 i 不再小于 5。

do {
  i += 1;
  console.log(i);
} while (i < 5);

一個(gè) while 語(yǔ)句只要指定的條件求值為真（true）就會(huì)一直執(zhí)行它的語(yǔ)句塊。一個(gè) while 語(yǔ)句看起來(lái)像這樣：

while (condition)
statement

如果這個(gè)條件變?yōu)榧?，循環(huán)里的 statement 將會(huì)停止執(zhí)行并把控制權(quán)交回給 while 語(yǔ)句后面的代碼。

條件檢測(cè)會(huì)在每次 statement 執(zhí)行之前發(fā)生。如果條件返回為真， statement 會(huì)被執(zhí)行并緊接著再次測(cè)試條件。如果條件返回為假，執(zhí)行將停止并把控制權(quán)交回給 while 后面的語(yǔ)句。

要執(zhí)行多條語(yǔ)句（語(yǔ)句塊），要使用塊語(yǔ)句 ({ ... }) 包括起來(lái)。

例子 1
下面的 while 循環(huán)只要 n 小于 3就會(huì)一直執(zhí)行：

var n = 0;
var x = 0;
while (n < 3) {
  n++;
  x += n;
}

在每次循環(huán)里， n 會(huì)增加1并被加到 x 上。所以， x 和 n 的變化是：

第一次完成后： n = 1 和 x = 1

第二次完成后： n = 2 和 x = 3

第三次完成后： n = 3 和 x = 6

在三次完成后， 條件 n < 3 結(jié)果不再為真，所以循環(huán)終止了。

例子 2
避免無(wú)窮循環(huán)（無(wú)限循環(huán)）。保證循環(huán)的條件結(jié)果最終會(huì)變成假；否則，循環(huán)永遠(yuǎn)不會(huì)停止。下面這個(gè) while 循環(huán)會(huì)永遠(yuǎn)執(zhí)行因?yàn)闂l件永遠(yuǎn)不會(huì)變成假：

while (true) {
  console.log("Hello, world");
}

函數(shù) 用來(lái)封裝可復(fù)用的功能。如果沒(méi)有函數(shù)，一段特定的操作過(guò)程用幾次就要重復(fù)寫(xiě)幾次，而使用函數(shù)則只需寫(xiě)下函數(shù)名和一些簡(jiǎn)短的信息

瀏覽器內(nèi)置函數(shù)和用戶定義的函數(shù)

一個(gè)函數(shù)定義（也稱為函數(shù)聲明，或函數(shù)語(yǔ)句）由一系列的function關(guān)鍵字組成，依次為：

函數(shù)的名稱。

函數(shù)參數(shù)列表，包圍在括號(hào)中并由逗號(hào)分隔。

定義函數(shù)的 JavaScript 語(yǔ)句，用大括號(hào){}括起來(lái)。

例如，以下的代碼定義了一個(gè)簡(jiǎn)單的square函數(shù)：

function square(number) {
  return number * number;
}

函數(shù)square使用了一個(gè)參數(shù)，叫作number。這個(gè)函數(shù)只有一個(gè)語(yǔ)句，它說(shuō)明該函數(shù)將函數(shù)的參數(shù)（即number）自乘后返回。函數(shù)的return語(yǔ)句確定了函數(shù)的返回值：

return number * number;

原始參數(shù)（比如一個(gè)具體的數(shù)字）被作為值傳遞給函數(shù)；值被傳遞給函數(shù)，如果被調(diào)用函數(shù)改變了這個(gè)參數(shù)的值，這樣的改變不會(huì)影響到全局或調(diào)用函數(shù)。

如果你傳遞一個(gè)對(duì)象（即一個(gè)非原始值，例如Array或用戶自定義的對(duì)象）作為參數(shù)，而函數(shù)改變了這個(gè)對(duì)象的屬性，這樣的改變對(duì)函數(shù)外部是可見(jiàn)的，如下面的例子所示：

function myFunc(theObject) {
  theObject.make = "Toyota";
}

var mycar = {make: "Honda", model: "Accord", year: 1998};
var x, y;

x = mycar.make;     // x獲取的值為 "Honda"

myFunc(mycar);
y = mycar.make;     // y獲取的值為 "Toyota"
                    // (make屬性被函數(shù)改變了)

雖然上面的函數(shù)聲明在語(yǔ)法上是一個(gè)語(yǔ)句，但函數(shù)也可以由函數(shù)表達(dá)式創(chuàng)建。這樣的函數(shù)可以是匿名的；它不必有一個(gè)名稱。例如，函數(shù)square也可這樣來(lái)定義：

var square = function(number) { return number * number; };
var x = square(4); // x gets the value 16

然而，函數(shù)表達(dá)式也可以提供函數(shù)名，并且可以用于在函數(shù)內(nèi)部代指其本身，或者在調(diào)試器堆棧跟蹤中識(shí)別該函數(shù)：

var factorial = function fac(n) {return n<2 ? 1 : n*fac(n-1)};

console.log(factorial(3));

當(dāng)將函數(shù)作為參數(shù)傳遞給另一個(gè)函數(shù)時(shí)，函數(shù)表達(dá)式很方便。下面的例子演示了一個(gè)叫map的函數(shù)如何被定義，而后使用一個(gè)表達(dá)式函數(shù)作為其第一個(gè)參數(shù)進(jìn)行調(diào)用：

function map(f,a) {
  var result = [],i; //創(chuàng)建一個(gè)新數(shù)組
  for (i = 0; i != a.length; i++)
    result[i] = f(a[i]);
  return result;
}

下面的代碼：

function map(f, a) {
  var result = []; // 創(chuàng)建一個(gè)數(shù)組
  var i; // 聲明一個(gè)值，用來(lái)循環(huán)
  for (i = 0; i != a.length; i++)
    result[i] = f(a[i]);
      return result;
}
var f = function(x) {
   return x * x * x; 
}
var numbers = [0,1, 2, 5,10];
var cube = map(f,numbers);
console.log(cube);

返回 [0, 1, 8, 125, 1000]。

在 JavaScript 中，可以根據(jù)條件來(lái)定義一個(gè)函數(shù)。比如下面的代碼，當(dāng)num 等于 0 的時(shí)候才會(huì)定義 myFunc ：

var myFunc;
if (num == 0){
  myFunc = function(theObject) {
    theObject.make = "Toyota"
  }
}

除了上述的定義函數(shù)方法外，你也可以在運(yùn)行時(shí)用 Function 構(gòu)造器由一個(gè)字符串來(lái)創(chuàng)建一個(gè)函數(shù) ，很像 eval() 函數(shù)。

當(dāng)一個(gè)函數(shù)是一個(gè)對(duì)象的屬性時(shí)，稱之為方法。了解更多關(guān)于對(duì)象和方法的知識(shí) 使用對(duì)象。

調(diào)用函數(shù)節(jié)
定義一個(gè)函數(shù)并不會(huì)自動(dòng)的執(zhí)行它。定義了函數(shù)僅僅是賦予函數(shù)以名稱并明確函數(shù)被調(diào)用時(shí)該做些什么。調(diào)用函數(shù)才會(huì)以給定的參數(shù)真正執(zhí)行這些動(dòng)作。例如，一旦你定義了函數(shù)square，你可以如下這樣調(diào)用它：

square(5);
上述語(yǔ)句通過(guò)提供參數(shù) 5 來(lái)調(diào)用函數(shù)。函數(shù)執(zhí)行完它的語(yǔ)句會(huì)返回值25。

函數(shù)一定要處于調(diào)用它們的域中，但是函數(shù)的聲明可以被提升(出現(xiàn)在調(diào)用語(yǔ)句之后)，如下例：

console.log(square(5));
/* ... */
function square(n) { return n*n }

函數(shù)域是指函數(shù)聲明時(shí)的所在的地方，或者函數(shù)在頂層被聲明時(shí)指整個(gè)程序。

提示：注意只有使用如上的語(yǔ)法形式（即 function funcName(){}）才可以。而下面的代碼是無(wú)效的。就是說(shuō)，函數(shù)提升僅適用于函數(shù)聲明，而不適用于函數(shù)表達(dá)式。

console.log(square); // square is hoisted with an initial value undefined.
console.log(square(5)); // TypeError: square is not a function
var square = function (n) { 
  return n * n; 
}

函數(shù)的參數(shù)并不局限于字符串或數(shù)字。你也可以將整個(gè)對(duì)象傳遞給函數(shù)。函數(shù) show_props（其定義參見(jiàn) 用對(duì)象編程）就是一個(gè)將對(duì)象作為參數(shù)的例子。

函數(shù)可以被遞歸，就是說(shuō)函數(shù)可以調(diào)用其本身。例如，下面這個(gè)函數(shù)就是用遞歸計(jì)算階乘：

function factorial(n){
  if ((n == 0) || (n == 1))
    return 1;
  else
    return (n * factorial(n - 1));
}

你可以計(jì)算1-5的階乘如下：

var a, b, c, d, e;

a = factorial(1); // 1賦值給a
b = factorial(2); // 2賦值給b
c = factorial(3); // 6賦值給c
d = factorial(4); // 24賦值給d
e = factorial(5); // 120賦值給e

還有其它的方式來(lái)調(diào)用函數(shù)。常見(jiàn)的一些情形是某些地方需要?jiǎng)討B(tài)調(diào)用函數(shù)，或者函數(shù)的實(shí)參數(shù)量是變化的，或者調(diào)用函數(shù)的上下文需要指定為在運(yùn)行時(shí)確定的特定對(duì)象。顯然，函數(shù)本身就是對(duì)象，因此這些對(duì)象也有方法（參考Function ）。作為此中情形之一，apply()方法可以實(shí)現(xiàn)這些目的。

在函數(shù)內(nèi)定義的變量不能在函數(shù)之外的任何地方訪問(wèn)，因?yàn)樽兞績(jī)H僅在該函數(shù)的域的內(nèi)部有定義。相對(duì)應(yīng)的，一個(gè)函數(shù)可以訪問(wèn)定義在其范圍內(nèi)的任何變量和函數(shù)。換言之，定義在全局域中的函數(shù)可以訪問(wèn)所有定義在全局域中的變量。在另一個(gè)函數(shù)中定義的函數(shù)也可以訪問(wèn)在其父函數(shù)中定義的所有變量和父函數(shù)有權(quán)訪問(wèn)的任何其他變量。

// 下面的變量定義在全局作用域(global scope)中
var num1 = 20,
    num2 = 3,
    name = "Chamahk";

// 本函數(shù)定義在全局作用域
function multiply() {
  return num1 * num2;
}

multiply(); // 返回 60

// 嵌套函數(shù)的例子
function getScore() {
  var num1 = 2,
      num2 = 3;
  
  function add() {
    return name + " scored " + (num1 + num2);
  }
  
  return add();
}

getScore(); // 返回 "Chamahk scored 5"

一個(gè)函數(shù)可以指向并調(diào)用自身。有三種方法可以達(dá)到這個(gè)目的：

函數(shù)名

arguments.callee

作用域下的一個(gè)指向該函數(shù)的變量名

例如，思考一下如下的函數(shù)定義：

var foo = function bar() {
   // statements go here
};

在這個(gè)函數(shù)體內(nèi)，以下的語(yǔ)句是等價(jià)的：

bar()

arguments.callee()

foo()

調(diào)用自身的函數(shù)我們稱之為遞歸函數(shù)。在某種意義上說(shuō)，遞歸近似于循環(huán)。兩者都重復(fù)執(zhí)行相同的代碼，并且兩者都需要一個(gè)終止條件（避免無(wú)限循環(huán)或者無(wú)限遞歸）。例如以下的循環(huán)：

var x = 0;
while (x < 10) { // "x < 10" 是循環(huán)條件
   // do stuff
   x++;
}

可以被轉(zhuǎn)化成一個(gè)遞歸函數(shù)和對(duì)其的調(diào)用：

function loop(x) {
  if (x >= 10) // "x >= 10" 是退出條件（等同于 "!(x < 10)"）
    return;
  // 做些什么
  loop(x + 1); // 遞歸調(diào)用
}
loop(0);

不過(guò)，有些算法并不能簡(jiǎn)單的用迭代來(lái)實(shí)現(xiàn)。例如，獲取樹(shù)結(jié)構(gòu)中所有的節(jié)點(diǎn)時(shí)，使用遞歸實(shí)現(xiàn)要容易得多：

function walkTree(node) {
  if (node == null) // 
    return;
  // do something with node
  for (var i = 0; i < node.childNodes.length; i++) {
    walkTree(node.childNodes[i]);
  }
}

跟loop函數(shù)相比，這里每個(gè)遞歸調(diào)用都產(chǎn)生了更多的遞歸。

將遞歸算法轉(zhuǎn)換為非遞歸算法是可能的，不過(guò)邏輯上通常會(huì)更加復(fù)雜，而且需要使用堆棧。事實(shí)上，遞歸函數(shù)就使用了堆棧：函數(shù)堆棧。

這種類似堆棧的行為可以在下例中看到：

function foo(i) {
  if (i < 0)
    return;
  console.log("begin:" + i);
  foo(i - 1);
  console.log("end:" + i);
}
foo(3);

// 輸出:

// begin:3
// begin:2
// begin:1
// begin:0
// end:0
// end:1
// end:2
// end:3

你可以在一個(gè)函數(shù)里面嵌套另外一個(gè)函數(shù)。嵌套（內(nèi)部）函數(shù)對(duì)其容器（外部）函數(shù)是私有的。它自身也形成了一個(gè)閉包。一個(gè)閉包是一個(gè)可以自己擁有獨(dú)立的環(huán)境與變量的的表達(dá)式（通常是函數(shù)）。

既然嵌套函數(shù)是一個(gè)閉包，就意味著一個(gè)嵌套函數(shù)可以”繼承“容器函數(shù)的參數(shù)和變量。換句話說(shuō)，內(nèi)部函數(shù)包含外部函數(shù)的作用域。

可以總結(jié)如下：

內(nèi)部函數(shù)只可以在外部函數(shù)中訪問(wèn)。

內(nèi)部函數(shù)形成了一個(gè)閉包：它可以訪問(wèn)外部函數(shù)的參數(shù)和變量，但是外部函數(shù)卻不能使用它的參數(shù)和變量。

下面的例子展示了嵌套函數(shù)：

function addSquares(a, b) {
  function square(x) {
    return x * x;
  }
  return square(a) + square(b);
}
a = addSquares(2, 3); // returns 13
b = addSquares(3, 4); // returns 25
c = addSquares(4, 5); // returns 41

由于內(nèi)部函數(shù)形成了閉包，因此你可以調(diào)用外部函數(shù)并為外部函數(shù)和內(nèi)部函數(shù)指定參數(shù)：

function outside(x) {
  function inside(y) {
    return x + y;
  }
  return inside;
}
fn_inside = outside(3); // Think of it like: give me a function that adds 3 to whatever you give it
result = fn_inside(5); // returns 8

result1 = outside(3)(5); // returns 8

函數(shù)可以被多層嵌套。例如，函數(shù)A可以包含函數(shù)B，函數(shù)B可以再包含函數(shù)C。B和C都形成了閉包，所以B可以訪問(wèn)A，C可以訪問(wèn)B和A。因此，閉包可以包含多個(gè)作用域；他們遞歸式的包含了所有包含它的函數(shù)作用域。這個(gè)稱之為作用域鏈。（稍后會(huì)詳細(xì)解釋）

思考一下下面的例子：

function A(x) {
  function B(y) {
    function C(z) {
      console.log(x + y + z);
    }
    C(3);
  }
  B(2);
}
A(1); // logs 6 (1 + 2 + 3)

在這個(gè)例子里面，C可以訪問(wèn)B的y和A的x。這是因?yàn)椋?/p>

B形成了一個(gè)包含A的閉包，B可以訪問(wèn)A的參數(shù)和變量
C形成了一個(gè)包含B的閉包
B包含A，所以C也包含A，C可以訪問(wèn)B和A的參數(shù)和變量。換言之，C用這個(gè)順序鏈接了B和A的作用域
反過(guò)來(lái)卻不是這樣。A不能訪問(wèn)C，因?yàn)锳看不到B中的參數(shù)和變量，C是B中的一個(gè)變量，所以C是B私有的。

當(dāng)同一個(gè)閉包作用域下兩個(gè)參數(shù)或者變量同名時(shí)，就會(huì)產(chǎn)生命名沖突。更近的作用域有更高的優(yōu)先權(quán)，所以最近的優(yōu)先級(jí)最高，最遠(yuǎn)的優(yōu)先級(jí)最低。這就是作用域鏈。鏈的第一個(gè)元素就是最里面的作用域，最后一個(gè)元素便是最外層的作用域。

看以下的例子：

function outside() {
  var x = 5;
  function inside(x) {
    return x * 2;
  }
  return inside;
}

outside()(10); // returns 20 instead of 10
命名沖突發(fā)生在return x上，inside的參數(shù)x和outside變量x發(fā)生了沖突。這里的作用鏈域是{inside, outside, 全局對(duì)象}。因此inside的x具有最高優(yōu)先權(quán)，返回了20（inside的x）而不是10（outside的x）。

閉包是 JavaScript 中最強(qiáng)大的特性之一。JavaScript 允許函數(shù)嵌套，并且內(nèi)部函數(shù)可以訪問(wèn)定義在外部函數(shù)中的所有變量和函數(shù)，以及外部函數(shù)能訪問(wèn)的所有變量和函數(shù)。但是，外部函數(shù)卻不能夠訪問(wèn)定義在內(nèi)部函數(shù)中的變量和函數(shù)。這給內(nèi)部函數(shù)的變量提供了一定的安全性。此外，由于內(nèi)部函數(shù)可以訪問(wèn)外部函數(shù)的作用域，因此當(dāng)內(nèi)部函數(shù)生存周期大于外部函數(shù)時(shí)，外部函數(shù)中定義的變量和函數(shù)將的生存周期比內(nèi)部函數(shù)執(zhí)行時(shí)間長(zhǎng)。當(dāng)內(nèi)部函數(shù)以某一種方式被任何一個(gè)外部函數(shù)作用域訪問(wèn)時(shí)，一個(gè)閉包就產(chǎn)生了。

var pet = function(name) {          //外部函數(shù)定義了一個(gè)變量"name"
  var getName = function() {            
    //內(nèi)部函數(shù)可以訪問(wèn) 外部函數(shù)定義的"name"
    return name; 
  }
  //返回這個(gè)內(nèi)部函數(shù)，從而將其暴露在外部函數(shù)作用域
  return getName;               
};
myPet = pet("Vivie");
    
myPet();                            // 返回結(jié)果 "Vivie"

實(shí)際上可能會(huì)比上面的代碼復(fù)雜的多。在下面這種情形中，返回了一個(gè)包含可以操作外部函數(shù)的內(nèi)部變量方法的對(duì)象。

var createPet = function(name) {
  var sex;
  
  return {
    setName: function(newName) {
      name = newName;
    },
    
    getName: function() {
      return name;
    },
    
    getSex: function() {
      return sex;
    },
    
    setSex: function(newSex) {
      if(typeof newSex == "string" 
        && (newSex.toLowerCase() == "male" || newSex.toLowerCase() == "female")) {
        sex = newSex;
      }
    }
  }
}

var pet = createPet("Vivie");
pet.getName();                  // Vivie

pet.setName("Oliver");
pet.setSex("male");
pet.getSex();                   // male
pet.getName();                  // Oliver

在上面的代碼中，外部函數(shù)的name變量對(duì)內(nèi)嵌函數(shù)來(lái)說(shuō)是可取得的，而除了通過(guò)內(nèi)嵌函數(shù)本身，沒(méi)有其它任何方法可以取得內(nèi)嵌的變量。內(nèi)嵌函數(shù)的內(nèi)嵌變量就像內(nèi)嵌函數(shù)的保險(xiǎn)柜。它們會(huì)為內(nèi)嵌函數(shù)保留“穩(wěn)定”——而又安全——的數(shù)據(jù)參與運(yùn)行。而這些內(nèi)嵌函數(shù)甚至不會(huì)被分配給一個(gè)變量，或者不必一定要有名字。

var getCode = (function(){
  var secureCode = "0]Eal(eh&2";    // A code we do not want outsiders to be able to modify...
  
  return function () {
    return secureCode;
  };
})();

getCode();    // Returns the secret code

盡管有上述優(yōu)點(diǎn)，使用閉包時(shí)仍然要小心避免一些陷阱。如果一個(gè)閉包的函數(shù)用外部函數(shù)的變量名定義了同樣的變量，那在外部函數(shù)域?qū)⒃僖矡o(wú)法指向該變量。

var createPet = function(name) {  // Outer function defines a variable called "name"
  return {
    setName: function(name) {    // Enclosed function also defines a variable called "name"
      name = name;               // ??? How do we access the "name" defined by the outer function ???
    }
  }
}

在箭頭函數(shù)出現(xiàn)之前，每一個(gè)新函數(shù)都重新定義了自己的 this 值（在嚴(yán)格模式下，一個(gè)新的對(duì)象在構(gòu)造函數(shù)里是未定義的，以“對(duì)象方法”的方式調(diào)用的函數(shù)是上下文對(duì)象等）。以面向?qū)ο蟮木幊田L(fēng)格，這樣著實(shí)有點(diǎn)惱人。

function Person() {
  // The Person() constructor defines `this` as itself.
  this.age = 0;

  setInterval(function growUp() {
    // In nonstrict mode, the growUp() function defines `this` 
    // as the global object, which is different from the `this`
    // defined by the Person() constructor.
    this.age++;
  }, 1000);
}

var p = new Person();

在ECMAScript 3/5里，通過(guò)把this的值賦值給一個(gè)變量可以修復(fù)這個(gè)問(wèn)題。

function Person() {
  var self = this; // Some choose `that` instead of `self`. 
                   // Choose one and be consistent.
  self.age = 0;

  setInterval(function growUp() {
    // The callback refers to the `self` variable of which
    // the value is the expected object.
    self.age++;
  }, 1000);
}

另外，創(chuàng)建一個(gè)約束函數(shù)可以使得 this值被正確傳遞給 growUp() 函數(shù)。

箭頭函數(shù)捕捉閉包上下文的this值，所以下面的代碼工作正常。

function Person(){
  this.age = 0;

  setInterval(() => {
    this.age++; // |this| properly refers to the person object
  }, 1000);
}

var p = new Person();

JavaScript語(yǔ)言有好些個(gè)頂級(jí)的內(nèi)建函數(shù)：

eval()

eval()方法會(huì)對(duì)一串字符串形式的JavaScript代碼字符求值。

uneval()

uneval()方法創(chuàng)建的一個(gè)Object的源代碼的字符串表示。

isFinite()

isFinite()函數(shù)判斷傳入的值是否是有限的數(shù)值。 如果需要的話，其參數(shù)首先被轉(zhuǎn)換為一個(gè)數(shù)值。

isNaN()

isNaN()函數(shù)判斷一個(gè)值是否是NaN。注意：isNaN函數(shù)內(nèi)部的強(qiáng)制轉(zhuǎn)換規(guī)則十分有趣； 另一個(gè)可供選擇的是ECMAScript 6 中定義Number.isNaN() , 或者使用 typeof來(lái)判斷數(shù)值類型。

parseFloat()

parseFloat() 函數(shù)解析字符串參數(shù)，并返回一個(gè)浮點(diǎn)數(shù)。

parseInt()

parseInt() 函數(shù)解析字符串參數(shù)，并返回指定的基數(shù)（基礎(chǔ)數(shù)學(xué)中的數(shù)制）的整數(shù)。

decodeURI()

decodeURI() 函數(shù)對(duì)先前經(jīng)過(guò)encodeURI函數(shù)或者其他類似方法編碼過(guò)的字符串進(jìn)行解碼。

decodeURIComponent()

decodeURIComponent()方法對(duì)先前經(jīng)過(guò)encodeURIComponent函數(shù)或者其他類似方法編碼過(guò)的字符串進(jìn)行解碼。

encodeURI()

encodeURI()方法通過(guò)用以一個(gè)，兩個(gè)，三個(gè)或四個(gè)轉(zhuǎn)義序列表示字符的UTF-8編碼替換統(tǒng)一資源標(biāo)識(shí)符（URI）的某些字符來(lái)進(jìn)行編碼（每個(gè)字符對(duì)應(yīng)四個(gè)轉(zhuǎn)義序列，這四個(gè)序列組了兩個(gè)”替代“字符）。

encodeURIComponent()

encodeURIComponent() 方法通過(guò)用以一個(gè)，兩個(gè)，三個(gè)或四個(gè)轉(zhuǎn)義序列表示字符的UTF-8編碼替換統(tǒng)一資源標(biāo)識(shí)符（URI）的每個(gè)字符來(lái)進(jìn)行編碼（每個(gè)字符對(duì)應(yīng)四個(gè)轉(zhuǎn)義序列，這四個(gè)序列組了兩個(gè)”替代“字符）