JavaScript簡易教程

這是我所知道的最完整最簡潔的JavaScript基礎(chǔ)教程。

這篇文章帶你盡快走進JavaScript的世界——前提是你有一些編程經(jīng)驗的話。本文試圖描述這門語言的最小子集。我給這個子集起名叫做“JavaScript簡易教程”，并推薦準備深入閱讀細節(jié)和高級技巧之前的新手閱讀。心急吃不了熱豆腐。文章的最后提出如何進一步學(xué)習(xí)。

警告：下面是我所描述的規(guī)則集和最佳實踐。我喜歡整潔清晰（例如，你可以隨時通過下面的目錄快速導(dǎo)航）。規(guī)則是無懈可擊的，但不可避免——每個人的理解不同。

目錄

1. 本文約定
2. 語言的性質(zhì)
3. 語法
4. 變量和賦值
5. 值
6. 布爾
7. 數(shù)字
8. 字符串
9. 語句
10. 函數(shù)
11. 異常處理
12. 嚴格模式
13. 變量作用域和閉包
14. 對象和繼承
15. 數(shù)組
16. 正則表達式
17. 數(shù)學(xué)
18. 標準庫的其他功能
19. 下一步學(xué)什么？

本文約定（Conventions used in this blog post）

命令行交互（Command line interaction）

每當我介紹一個新概念，我都會嘗試通過JavaScript命令行進行演示。像下面這樣：

> 3 + 4
  7

大于號后面的文本是用戶輸入內(nèi)容。其他的都是JavaScript引擎的輸出內(nèi)容。此外，也可以使用console.log()來向控制臺打印數(shù)據(jù)（這方法可以在大部分JavaScript引擎中工作，包括Node.js）.

查找文檔（Finding documentation）

有時你看到一些函數(shù)或方法有超鏈接，你應(yīng)該清楚他們的工作原理。如果沒有，可以在Mozilla Developer Network (MDN)上查看細節(jié)，你也可以使用Google在MDN上查找文檔。例如，下面是通過Google搜索數(shù)組的push()方法的例子：

mdn array push

語言的性質(zhì)（The nature of the language）

本節(jié)對JavaScript的性質(zhì)簡要介紹，以幫助你理解一些疑問。

JavaScript 和 ECMAScript（JavaScript versus ECMAScript）

編程語言稱為JavaScript，語言標準稱為ECMAScript。他們有不同名字的原因是因為“Java”已經(jīng)被注冊為商標（屬于Oracle）。目前，只有Mozilla被正式允許使用“JavaScript”名稱，因為很久以前他們等到一份許可。因此，開放的語言標準擁有不同的名字。當前的JavaScript版本是ECMAScript 5，ECMAScript 6當前是開發(fā)版。

影響（Influences）

JavaScript之父，Brendan Eich 別無選擇必須迅速創(chuàng)建一門語言。（或者，更糟糕，Netscape將使用其他技術(shù)）。他借鑒了幾門其他語言：

• JavaScript借鑒了Java的語法和如何區(qū)分原始值和對象。 JavaScript的函數(shù)設(shè)計受Scheme和AWK的啟發(fā)——他們（函數(shù)）都是第一類（first-class）對象，并且在語言中廣泛使用。閉包使他們變成強大的工具。
• Self影響了JavaScript獨一無二的面向?qū)ο缶幊?OOP)風(fēng)格。它的核心思想（在這里我們沒有提到）非常優(yōu)雅，基于此創(chuàng)建的語言非常少。但一個簡單的模式（見后面）照顧大部分用例。JavaScript面向?qū)ο缶幊痰臍⑹旨壧匦允悄憧梢灾苯觿?chuàng)建對象。不需要先創(chuàng)建類或其他類似的東西。
• Perl和Python影響了JavaScript字符串，數(shù)組和正則表達式的操作。

JavaScript直到ECMAScript 3才加入異常處理，這解釋了為什么這門語言經(jīng)常自動轉(zhuǎn)換類型和經(jīng)常靜默失敗：它最初不能拋出異常。

一方面，JavaScript有很多怪癖，并且確實很多功能（塊級變量作用域（block-sciped variables），模塊（modules）支持子類型（subtyping）等）。另一方面，它有幾個非常強大的特性，允許你彌補上面的問題。在其他語言中，你要學(xué)習(xí)語言特性。在JavaScript中，你需要經(jīng)常學(xué)習(xí)模式代替。

深入閱讀（Further reading）

• JavaScript: how it all began
• JavaScript: the glass is half full [什么讓JavaScript如此吸引人？]
• ECMAScript: ES.next versus ES 6 versus ES Harmony [包括ECMAScript版本的一個簡史]
• Perl and Python influences in JavaScript
• Javascript:10天設(shè)計一門語言

語法（Syntax）

這節(jié)介紹一些JavaScript的基本語法規(guī)則。

語句和表達式（Statements versus expressions）

了解JavaScript的語法，這有助于了解（簡而言之），它有兩個主要的語法類型：語句和表達式。

• 語句通常“做某些事情”。程序是一組語句序列。舉個例子，下面聲明（創(chuàng)建）一個 變量 foo： var foo;
• 表達式產(chǎn)生值。他們通常位于賦值操作的郵編，函數(shù)參數(shù)，等。舉個例子： 3 * 7

語句和表達式之間的區(qū)別最好通過實例說明，JavaScript（像Java）有兩種不同的方式實現(xiàn)if-then-else。一種是用語句：

var x;
if (y >= 0) {
    x = y;
} else {
    x = -y;
}

另一種是表達式：

var x = y >= 0 ? y : -y;

你可以將后者作為函數(shù)參數(shù)（但前者不行）：

myFunction(y >= 0 ? y : -y)

最后，每當JavaScript期待一個語句，你也可以用一個表達式代替。例如：

foo(bar(7, 1));

foo(...)；是一個語句（也叫做表達式語句），bar(7, 1)是一個表達式。他們都實現(xiàn)函數(shù)調(diào)用。

流程控制語句和語句塊（Control flow statements and blocks）

流程控制語句，其語句體可以是單條語句。舉兩個例子：

if (obj !== null) obj.foo();
    while (x > 0) x--;

然而，任何語句總能被語句塊代替，花括號包含零或多條語句。因此，你也可以這樣寫：

if (obj !== null) {
    obj.foo();
}

while (x > 0) {
    x--;
}

在本文中，我們只是用后一種方式。

分號（Semicolons）

分號在JavaScript中是可選的。但省略他們可能帶來意想不到的結(jié)果，所以我建議你不要那樣做。

正如上面所看到的，分號作為語句的結(jié)尾，但語句塊不需要。僅有一種情況下你將見到塊后面有分號：函數(shù)表達式后面的函數(shù)體塊。表達式作為語句的結(jié)尾，后面是分號：

var x = 3 * 7;
var f = function () { };

注釋（Comments）

JavaScript有兩種注釋方式：單行注釋和多行注釋。單行注釋以//開頭，以換行符結(jié)尾：

x++; // 單行（single-line）注釋

多行注釋用/**/包裹

/* 
 這是多行注釋
 多行哦
 */

深入閱讀

• Expressions versus statements in JavaScript
• Automatic semicolon insertion in JavaScript

變量和賦值（Variables and assignment）

JavaScript中的變量在使用之前必須先聲明：

var foo;  // 聲明變量“foo”

賦值（Assignment）

你可以在生命變量的同時給它賦值：

var foo = 6;

你也可以給已經(jīng)存在的變量重新賦值：

foo = 4;  // 更改變量的值

復(fù)合賦值操作符（Compount assignment operators）

有很多符合賦值操作符，例如+=。下面的兩個賦值操作等價：

x += 1;
x = x + 1;

標識符和變量名（Identifiers and variable names）

標識符就是事物的名字，在JavaScript中他們扮演不同的語法角色。例如，變量的名稱是一個標識符。

大體上，標識符的第一個字符可以是任何Unicode字符，美元標志符（$）或下劃線（_）。后面的字符可以是任意字符和數(shù)字。因此，下面全是合法的標識符：

arg0
_tmp
$elem
π

一些標識符是“保留關(guān)鍵字”——他們是語法的一部分，不能用作變量名：

arguments break case catch class const continue debugger default delete do else enum eval export extends false finally for function if implements import in instanceof interface let new null package private protected public return static super switch this throw true try typeof var void while with yield

從技術(shù)上講，下面三個標識符不是保留字，但也不應(yīng)該作為變量名：

Infinity NaN undefined

深入閱讀

• Valid JavaScript variable names [by Mathias Bynens]

值（Values）

JavaScript有所有我們期待的編程語言值類型：布爾，數(shù)字，字符串，數(shù)組等。JavaScript中的所有值都有屬性。每個屬性有一個鍵（或名字）和一個值?？紤]記錄的域（fields of record）。你可以使用點（.）操作符讀取屬性：

value.propKey

舉個例子：字符串“abc”有屬性lenght（長度）。

 > var str = 'abc';
 > str.length
   3

上面的代碼也可以寫成下面這樣：

> 'abc'.length
  3

點操作符也可以用來給屬性賦值：

 > var obj = {};  // 空對象
 > obj.foo = 123; // 創(chuàng)建屬性“foo”，設(shè)置它為123
   123
 > obj.foo
   123

你也可以通過它（.）調(diào)用方法：

> 'hello'.toUpperCase()
  'HELLO'

上面，我們在值“hello”上面調(diào)用方法 toUpperCase()。

原始類型值和對象（Primitive values versus objects）

JavaScript定義了不同值之間的區(qū)別：

• 原始值包括：boolean，number，string，null和undefined，
• 所有其他的值都是對象。實際上對象被定義為——所有不為原始類型的值。

兩者之間的主要區(qū)別在于他們是如何被比較的：每一個對象有一個獨一無二的標志，并且僅和自己相等：

> var obj1 = {};  // 一個空對象
> var obj2 = {};  // 另一個空對象
> obj1 === obj2
  false
> obj1 === obj1
  true

相反，所有原始值只要編碼值相同就被認為是相同的：

> var prim1 = 123;
> var prim2 = 123;
> prim1 === prim2
  true

接下來的兩節(jié)介紹原始值和對象的更多細節(jié)。

原始類型值（Primitive values）

下面的全是原始類型值（簡稱：原始值）：

• 布爾類型：true，false
• 數(shù)字類型：1736，1.351
• 字符串類型: ‘a(chǎn)bc’，”abc”
• 兩個“無值（non-values）”：undefined，null

原始值的特征：

• 值做比較時：“內(nèi)容”做比較。

    > 3 === 3
      true
    > 'abc' === 'abc'
      true
  

• 無法更改：值的屬性無法更改，無法添加和移除屬性。

    > var str = 'abc';
    > str.foo = 3; // try to create property `foo` ? no effect
    > str.foo  // unknown property
      undefined 
  

  (獲取未知屬性總返回undefined)

• 原始值的集合是固定的（fixed set of values）：你不能自定義原始值。

對象（Objects）

所有非原始值（non-primitive）的值都是對象。最常見的幾種對象類型是：

• 簡單對象（類型是Object）能通過對象字面量創(chuàng)建：

  { firstName: ‘Jane’, lastName: ‘Doe’ }

  上面的對象有兩個屬性：firstName屬性的值是“Jane”，lastName屬性的值是“Doe”。

• 數(shù)組（類型是 Array）能通過數(shù)組字面量創(chuàng)建：

  [ ‘a(chǎn)pple’, ‘banana’, ‘cherry’ ]

  上面的數(shù)組有三個元素，可以通過數(shù)字索引訪問。例如“apple”的索引是0.

• 正則表達式對象（類型是 RegExp）能通過正則表達式字面量創(chuàng)建。

  /^a+b+$/

對象的特征：

• 比較的是引用：比較的是標識符，每個值有自己的標識符。

    > {} === {}  // 兩個不同的空對象
      false
  	
    > var obj1 = {};
    > var obj2 = obj1;
    > obj1 === obj2
      true
  

• 默認可以更改。

     > var obj = {};
     > obj.foo = 123;
     > obj.foo
       123
  

-** 用戶可擴展（user-extensible）：**你可以通過構(gòu)造函數(shù)定義新的對象類型。

數(shù)組所有的數(shù)據(jù)結(jié)構(gòu)（如）都是對象，但并不是所有的對象都是數(shù)據(jù)結(jié)構(gòu)。例如：正則表達式是對象，但不是一個數(shù)據(jù)結(jié)構(gòu)。

undefined 和 null（undefined and null）

多少有些不必要，JavaScript有兩個“無值（non-values）”：undefined 和 null。

• undefined的意思是“沒有值（no value）”。為初始化的變量是undefined：

    > var foo;
    > foo
    undefined
  

  如果你讀取不存在的屬性，將返回undefined：

    > var obj = {}; // 空對象
    > obj.foo
      undefined
  

  未傳遞的參數(shù)也是undefined：

    > function f(x) { return x }
    > f()
      undefined
  

• null的意思是“沒有對象（no object）”。它被用來表示對象的無值（參數(shù)，鏈上的對象等）。

通常情況下你應(yīng)該把undefined和null看成是等價的，如果他們代表相同意義的無值的話。檢查他們的一種方式是通過嚴格比較：

if (x === undefined || x === null) {
    ...
}

另一種在實際中使用的方法是認為undefined 和 null 都是false：

if (!x) {
    ...
}

警告：false，0，NaN 和 “” 都被當作false。

包裝類型（Wrapper types）

對象類型的實例Foo（包括內(nèi)建類型，例如Array和其他自定義類型）從對象Foo.prototype上獲取方法。你可以通過讀這個方法但不調(diào)用它的方式驗證這點：

> [].push === Array.prototype.push
  true

相反，原始類型是沒有類型的，所以每個原始類型有一個關(guān)聯(lián)類型，稱之為包裝類型：

• 布爾值的包裝類型是 Boolean。布爾值從Boolean.prototype上獲取方法：

    > true.toString === Boolean.prototype.toString
  	true
  

  注意包裝類型的名字首個字母是大寫的B。如果在JavaScript中布爾值的類型可以訪問，那么它可能會被成為布爾對象。

• 數(shù)字值的包裝類型是Number。
• 字符串值的包裝類型是String。

包裝類型也有實例（他們的實例是對象），但不常用。相反，包裝類型有其他用處：如果你將他們作為函數(shù)調(diào)用，他們可以將值轉(zhuǎn)換為原始類型。

> Number('123')
  123
> String(true)
  'true'

通過typeof 和 instanceof 將值分類（Categorizing values via typeof and instanceof）

有兩個操作符可以用來將值分類：typeof 主要用來操作原始值，instanceof 主要用來造作對象。

typeof 使用方法如下：

typeof ?value?

它返回描述 value “類型”的一個字符串。例如：

> typeof true
  'boolean'
> typeof 'abc'
  'string'
> typeof {} // 空對象字面量
  'object'
> typeof [] // 空數(shù)組字面量
  'object'

下標列出了所有typeof的結(jié)果：

有兩個東西和我們所說的原始值和對象是矛盾的：

• 函數(shù)的類型是“function”而不是“object”。鑒于函數(shù)（類型為“function”）是對象（類型是對象）的子類型，這不是一個錯誤。
• null的類型是“object”。這是一個bug，但從沒被修復(fù)，因為修復(fù)后會破壞現(xiàn)有的代碼。

instanceof使用方法如下：

?value? instanceof ?Constr?

如果 value 是一個對象，并且value 是由構(gòu)造函數(shù)Constr創(chuàng)建的（考慮：類）。例如：

> var b = new Bar();  // 通過構(gòu)造函數(shù)Bar創(chuàng)建對象
> b instanceof Bar
  true
> {} instanceof Object
  true
> [] instanceof Array
  true
> [] instanceof Object  // 數(shù)字是對象的子類型
  true

深入閱讀

• Categorizing values in JavaScript
• Improving the JavaScript typeof operator
• 探索javascript中null和undefined的深淵

布爾（Booleans）

布爾類型原始值包括true和false。下面的操作符產(chǎn)生布爾值：

• 二元邏輯運算符：&&（與），

  （或）

• 前綴邏輯運算符：!（非）
• 等值運算符：=== !== == !=
• 比較運算符（字符串或數(shù)字）：> >= < <=

真值和假值（Truthy and falsy）

每當JavaScript希望一個布爾值時（例如：if語句的條件），可以使用任何值。它將被理解（轉(zhuǎn)換）為true或false。下面的值被理解為false：

• undefined, null
• 布爾: false
• 數(shù)字: -0, NaN
• 字符串: ‘’

所有其他值被認為true。被理解為false的值成為假值（falsy），被理解為true的值成為真值（truthy）?？梢允褂肂oolean作為函數(shù)測試值被理解為什么。

> Boolean(undefined)
  false
> Boolean(0)
  false
> Boolean(3)
  true

二元邏輯運算符（Binary logical operators）

JavaScript中的二元邏輯運算符是短路運算——如果第一個操作數(shù)可以確定結(jié)果，第二個操作數(shù)將不被驗證。例如，在下面的代碼中，函數(shù)foo()不會被調(diào)用。

false && foo()
true  || foo()

此外，二元邏輯運算符返回操作數(shù)中的一個——可能是一個布爾值，也可能不是。一張真值表用來決定返回哪個值：

• 與：如果第一個操作數(shù)是假值，返回第一個。否則返回第二個操作數(shù)。

    > NaN && 'abc'
      NaN
    > 123 && 'abc'
      'abc'
  

• 或：如果第一個操作數(shù)是真值，返回第一個。否則，返回第二個操作數(shù)。

    > 'abc' || 123
      'abc'
    > '' || 123
      123
  

等值運算符（Equality operators）

在JavaScript中檢測相等，你可以使用嚴格相等（===）和嚴格不等（!==）。或者你也可以使用非嚴格相等（==）和非嚴格不等（!=）。經(jīng)驗規(guī)則：總是用嚴格運算符，假裝非嚴格運算符不存在。嚴格相等更安全。

深入閱讀

• Equality in JavaScript: === versus ==
• 在JavaScript中什么時候使用==是正確的？

數(shù)字（Numbers）

JavaScript中的所有數(shù)字都是浮點型（雖然大部分的JavaScript引擎內(nèi)部也使用整數(shù)）。至于為什么這樣設(shè)計，查看這里（每一個JavaScript開發(fā)者應(yīng)該了解的浮點知識）。

> 1 === 1.0
  true

特殊數(shù)字：

• NaN (“不是一個數(shù)字 not a number”): 錯誤值。

    > Number('xyz')  // 'xyz' 不能被轉(zhuǎn)換為數(shù)字
      NaN
  

• Infinity：也是最大錯誤值（溢出）.

    > 3 / 0
      Infinity
    > Math.pow(2, 1024)  // 數(shù)字太大了
      Infinity
  

  Infinity 有時很有用，因為它比任何其他數(shù)字都大。同樣，-Infinity 比其他任何數(shù)字都小。

• JavaScript有兩個零，+0 和 -0。它通常不讓你看到，并簡單將兩個零都顯示為0：

    > +0
      0
    > -0
      0
  

  因此最好假裝只有一個零（正如我們看到假值時所做的那樣：-0 和 +0 都是假值）。

運算符（Operators）

JavaScript中有下列算數(shù)運算符：

• 加: number1 + number2
• 減: number1 - number2
• 乘: number1 * number2
• 除: number1 / number2
• 求模: number1 % number2
• 自增: ++variable, variable++
• 自減: –variable, variable–
• 負值: -value
• 轉(zhuǎn)換為數(shù)字: +value

全局對象Math通過函數(shù)提供更多算數(shù)運算操作。

JavaScript中也有位運算符（例如：位與 &）。

深入閱讀

在2ality有一系列博文介紹這些內(nèi)容，例如：

• How numbers are encoded in JavaScript
• JavaScript’s two zeros
• Integers and shift operators in JavaScript
• NaN and Infinity in JavaScript
• Working with large integers in JavaScript

字符串（Strings）

字符串可以直接通過字符串字面量創(chuàng)建。這些字面量被單引號或雙引號包裹。反斜線（\）轉(zhuǎn)義字符并且產(chǎn)生一些控制字符。例如：

'abc'
"abc"

'Did she say "Hello"?'
"Did she say \"Hello\"?"

'That\'s nice!'
"That's nice!"

'Line 1\nLine 2'  // 換行
'Backlash: \\'

可以通過方括號訪問單個字符：

> var str = 'abc';
> str[1]
  'b'

length屬性是字符串的字符數(shù)量。

> 'abc'.length
  3

提醒：字符串是不可變的，如果你想改變現(xiàn)有字符串，你需要創(chuàng)建一個行的字符串。

字符串運算符（String operators）

字符串可以通過加號操作符（+）拼接，如果其中一個操作數(shù)為字符串，會將另一個操作數(shù)也轉(zhuǎn)換為字符串。

> var messageCount = 3;
> 'You have '+messageCount+' messages'
  'You have 3 messages'

連續(xù)執(zhí)行拼接操作可以使用 += 操作符：

> var str = '';
> str += 'Multiple ';
> str += 'pieces ';
> str += 'are concatenated.';
> str
  'Multiple pieces are concatenated.'

字符串方法（String methods）

字符串有許多有用的方法。例如：

> 'abc'.slice(1)  // 復(fù)制子字符串
  'bc'
> 'abc'.slice(1, 2)
  'b'

> '\t xyz  '.trim()  // 移除空白字符
  'xyz'

> 'mj?lnir'.toUpperCase()
  'MJ?LNIR'

> 'abc'.indexOf('b')  // 查找字符串
  1
> 'abc'.indexOf('x')
  -1

深入閱讀

• String concatenation in JavaScript
• JavaScript: single quotes or double quotes?

語句（Statements）

條件（Conditionals）

if語句通過布爾條件決定執(zhí)行那個分支：

if (myvar === 0) {
    // then
}

if (myvar === 0) {
    // then
} else {
    // else
}

if (myvar === 0) {
    // then
} else if (myvar === 1) {
    // else-if
} else if (myvar === 2) {
    // else-if
} else {
    // else
}

下面的switch語句，furit的值決定那個分支被執(zhí)行。

switch (fruit) {
    case 'banana':
        // ...
        break;
    case 'apple':
        // ...
        break;
    default:  // 所有其他情況
        // ...
}

循環(huán)（Loops）

for 循環(huán)的格式如下：

for(初始化; 當條件成立時循環(huán); 下一步操作)

例子：

for (var i=0; i < arr.length; i++) {
    console.log(arr[i]);
}

當條件成立時while循環(huán)繼續(xù)循環(huán)它的循環(huán)體。

// 和上面的for循環(huán)相等
var i = 0;
while (i < arr.length) {
    console.log(arr[i]);
    i++;
}

當條件成立時，do-while循環(huán)繼續(xù)循環(huán)。由于條件位于循環(huán)體之后，所以循環(huán)體總是被至少至少執(zhí)行一次。

do {
    // ...
} while(條件);

在所有的循環(huán)中：

• break中斷循環(huán)
• continue開始一個新的循環(huán)迭代

函數(shù)（Functions）

定義函數(shù)的一種方法是通過函數(shù)聲明：

function add(param1, param2) {
    return param1 + param2;
}

上面的代碼定義一個名稱叫做add的函數(shù)，有兩個參數(shù)param1和param2，并且返回參數(shù)的和。下面是你如何調(diào)用這個函數(shù)：

> add(6, 1)
  7
> add('a', 'b')
  'ab'

另一種定義add()函數(shù)的方法是通過函數(shù)表達式：

var add = function (param1, param2) {
    return param1 + param2;
};

函數(shù)表達式產(chǎn)生一個值，因此可以直接將函數(shù)作為參數(shù)傳遞給其他函數(shù)：

someOtherFunction(function (p1, p2) { ... });

函數(shù)聲明提升（Function declarations are hoisted）

函數(shù)聲明會被提升，他們?nèi)灰苿拥疆斍白饔糜蜷_始之處。這允許你在函數(shù)聲明之前調(diào)用它們：

function foo() {
    bar();  // 沒問題，bar被提升
    function bar() {
        ...
    }
}

注意：雖然變量聲明也會被提升，但賦值的過程不會被提升：

function foo() {
    bar();  // 有問題，bar是undefined
    var bar = function () {
        // ...
    };
}

特殊變量arguments（The special variable arguments）

在JavaScript中你可以調(diào)用任意函數(shù)并傳遞任意數(shù)量的參數(shù)——語言絕不會抱怨。那可以工作，然而，使所有參數(shù)可訪問需要通過特殊變量 arguments。arguments 看起來像數(shù)組，但它沒有數(shù)組的方法。

> function f() { return arguments }
> var args = f('a', 'b', 'c');
> args.length
3
> args[0]  // 獲取索引為0的元素
'a'

太多或太少參數(shù)（Too many or too few arguments）

讓我們通過下面的函數(shù)探索JavaScript中傳遞太多或太少參數(shù)時如何處理（函數(shù) toArray在后面提到）

function f(x, y) {
    console.log(x, y);
    console.log(toArray(arguments));
}

多出的參數(shù)將被忽略（可以通過arguments訪問）：

> f('a', 'b', 'c')
a b
[ 'a', 'b', 'c' ]

缺少的參數(shù)將是undefined：

> f('a')
a undefined
[ 'a' ]
> f()
undefined undefined
[]

可選參數(shù)（Optional parameters）

下面是一個常見模式，給參數(shù)設(shè)置默認值：

function pair(x, y) {
    x = x || 0;  // (*)
    y = y || 0;
    return [ x, y ];
}

> pair()
[ 0, 0 ]
> pair(3)
[ 3, 0 ]
> pair(3, 5)
[ 3, 5 ] 

強制數(shù)量（Enforcing an arity）

如果你想強制參數(shù)的數(shù)量，你可以檢測arguments.length：

function pair(x, y) {
    if (arguments.length !== 2) {
        throw new Error('Need exactly 2 arguments');
    }
    ...
}

將arguments 轉(zhuǎn)換為數(shù)組（Converting arguments to an array）

arguments 不是一個數(shù)組，它僅僅是類數(shù)組（array-like）：它有一個length屬性，并且你可以通過方括號索引方式訪問它的元素。然而，你不能移除元素，或在它上面調(diào)用任何數(shù)組方法。因此，有時你需要將其轉(zhuǎn)換為數(shù)組。這就是下面函數(shù)的作用。

function toArray(arrayLikeObject) {
    return [].slice.call(arrayLikeObject);
}

深入閱讀

• JavaScript quirk 5: parameter handling

異常處理（Exception handling）

異常處理最常見的方式像下面這樣：

function throwException() {
    throw new Error('Problem!');
}

try {
    throwException();
} catch (e) {
    console.log(e);  // 錯誤：信息
    console.log(e.stack);  // 非標準，但大部分瀏覽器支持
}

try分支包裹易出錯的代碼，如果try分支內(nèi)部拋出異常，catch分支將會執(zhí)行。

深入閱讀

• Subtyping JavaScript builtins in ECMAScript 5 [especially relevant for errors]

嚴格模式（Strict mode）

嚴格模式開啟檢測和一些其他措施，是JavaScript變成更整潔的語言。推薦使用嚴格模式。為了開啟嚴格模式，只需在JavaScript文件或script標簽第一行添加如下語句：

'use strict';

你也可以在每個函數(shù)上選擇性開啟嚴格模式，只需將上面的代碼放在函數(shù)的開頭：

function functionInStrictMode() {
    'use strict';
}

下面的兩小節(jié)看下嚴格模式的三大好處。

明確錯誤（Explicit errors）

讓我們看一個例子，嚴格模式給我們明確的錯誤，否則JavaScript總是靜默失?。合旅娴暮瘮?shù) f() 執(zhí)行一些非法操作，它試圖更改所有字符串都有的只讀屬性——length：

function f() {
    'abc'.length = 5;
}

當你調(diào)用上面的函數(shù)，它靜默失敗，賦值操作被簡單忽略。讓我們將 f() 在嚴格模式下運行：

function f_strict() {
    'use strict';
    'abc'.length = 5;
}

現(xiàn)在瀏覽器報給我們一些錯誤：

> f_strict()
TypeError: Cannot assign to read only property 'length' of abc

不是方法的函數(shù)中的this（this in non-method functions）

在嚴格模式下，不作為方法的函數(shù)中的this值是undefined：

function f_strict() {
    'use strict';
    return this;
}
console.log(f_strict() === undefined);  // true

在非嚴格模式下，this的值是被稱作全局對象（global object）（在瀏覽器里是window）：

function f() {
    return this;
}
console.log(f() === window);  // true

不再自動創(chuàng)建全局變量（No auto-created global variables）

在非嚴格模式下，如果你給不存在的變量賦值，JavaScript會自動創(chuàng)建一個全局變量：

> function f() { foo = 5 }
> f()  // 不會報錯
> foo
5

在嚴格模式下，這會產(chǎn)生一個錯誤：

> function f_strict() { 'use strict'; foo2 = 4; }
> f_strict()
ReferenceError: foo2 is not defined

深入閱讀

• JavaScript’s strict mode: a summary
• 揭秘javascript中謎一樣的this
• JavaScript中的this關(guān)鍵字

變量作用域和閉包（Variable scoping and closures）

在JavaScript中，你必須通過var聲明變量，在你使用它們之前：

> var x;
> x = 3;
> y = 4;
ReferenceError: y is not defined

你可以用一條var語句聲明和初始化多個變量：

var x = 1, y = 2, z = 3;

但我建議每個變量使用一條語句。因此，我將上面的語句重寫為：

var x = 1;
var y = 2;
var z = 3;

由于提升（見下文），最好在函數(shù)頂部聲明變量。

變量和函數(shù)作用域（Variables are function-scoped）

變量的作用域總是整個函數(shù)（沒有塊級作用域）。例如：

function foo() {
    var x = -3;
    if (x < 0) {  // (*)
        var tmp = -x;
        ...
    }
    console.log(tmp);  // 3
}

我們可以看到tmp變量不僅在（*）所在行的語句塊，它在整個函數(shù)內(nèi)都存在。

變量提升（Variables are hoisted）

變量聲明會被提升：聲明會被移到函數(shù)的頂部，但賦值過程不會。舉個例子，在下面的函數(shù)中（*）行位置聲明了一個變量。

function foo() {
    console.log(tmp); // undefined
    if (false) {
        var tmp = 3;  // (*)
    }
}

在內(nèi)部，上面的函數(shù)被執(zhí)行像下面這樣：

function foo() {
    var tmp;  // declaration is hoisted
    console.log(tmp);
    if (false) {
        tmp = 3;  // assignment stays put
    }
}

閉包（Closures）

每個函數(shù)保持和函數(shù)體內(nèi)部變量的連接，甚至離開創(chuàng)建它的作用域之后。例如：

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

在（*）行開始的函數(shù)在它創(chuàng)建時保留上下文，并在內(nèi)部保存一個start活動值：

> var inc = createIncrementor(5);
> inc()
5
> inc()
6
> inc()
7

閉包是一個函數(shù)加上和其作用域鏈的鏈接。因此，createIncrementor() 返回的是一個閉包。

IIFE：模擬塊級作用域（IIFE: Simulating block scoping）

有時你想模擬一個塊，例如你想將變量從全局作用域隔離。完成這個工作的模式叫做 IIFE(立即執(zhí)行函數(shù)表達式(Immediately Invoked Function Expression))：

(function () {  // 塊開始
    var tmp = ...;  // 非全局變量
}());  // 塊結(jié)束

上面你會看到函數(shù)表達式被立即執(zhí)行。外面的括號用來阻止它被解析成函數(shù)聲明；只有函數(shù)表達式能被立即調(diào)用。函數(shù)體產(chǎn)生一個新的作用域并使 tmp 變?yōu)榫植孔兞俊?/p>

閉包實現(xiàn)變量共享（Inadvertent sharing via closures）

下面是個經(jīng)典問題，如果你不知道它那它會讓你費盡思量。因此，先瀏覽下，先對問題有個大概的了解。

閉包保持和外部變量的連接，有時可能和你想像的行為不一致：

var result = [];
for (var i=0; i < 5; i++) {
    result.push(function () { return i });  // (*)
}
console.log(result[1]()); // 5 (不是 1)
console.log(result[3]()); // 5 (不是 3)

(*)行的返回值總是當前的i值，而不是當函數(shù)被創(chuàng)建時的i值。當循環(huán)結(jié)束后，i的值是5，這是為什么數(shù)組中的所有函數(shù)的返回值總是一樣的。如果你想捕獲當前變量的快照，你可以使用 IIFE：

for (var i=0; i < 5; i++) {
    (function (i2) {
        result.push(function () { return i2 });
    }(i));  // 復(fù)制當前的i
}

深入閱讀

• Variable declarations: three rules you can break
• JavaScript quirk 6: the scope of variables
• JavaScript quirk 7: inadvertent sharing of variables via closures
• 認識javascript中的作用域和上下文
• JavaScript的作用域和提升機制
• 了解JavaScript的執(zhí)行上下文

對象和繼承（Objects and inheritance）

和所有的值類型一樣，對象有屬性。事實上，你可以將對象當作一組屬性的集合，每個屬性是一對（鍵和值）。鍵是字符串，值可以是任意JavaScript值。到目前為止，我們僅僅見過鍵是標識符的屬性，因為點操作符處理的鍵必須為標識符。在這節(jié)，你講見到另一種方法屬性的方法，能將任意字符串作為鍵。

單個對象（Single objects）

在JavaScript中，你可以直接創(chuàng)建對象，通過對象字面量：

var jane = {
    name: 'Jane',

    describe: function () {
        'use strict';
        return 'Person named '+this.name;
    }
};

上面的對象有兩個屬性：name 和 describe。你能讀（“get”）和 寫（“set”）屬性：

> jane.name  // get
'Jane'
> jane.name = 'John';  // set
> jane.newProperty = 'abc';  // 自動創(chuàng)建

屬性是函數(shù)如 describe 可以被當作方法調(diào)用。當調(diào)用他們時可以在它們內(nèi)部通過this引用對象。

> jane.describe()  // 調(diào)用方法
'Person named John'
> jane.name = 'Jane';
> jane.describe()
'Person named Jane'

in 操作符用來檢測一個屬性是否存在：

> 'newProperty' in jane
true
> 'foo' in jane
false

你若你讀取一個不存在的屬性，你將得到undefined值。因此上面的兩個檢查也可以像下面這樣：

> jane.newProperty !== undefined
true
> jane.foo !== undefined
false

delete操作符用來刪除一個屬性：

> delete jane.newProperty
true
> 'newProperty' in jane
false

任意鍵屬性（Arbitrary property keys）

屬性的鍵可以是任意字符串。到目前為止，我們看到的對象字面量中的和點操作符后的屬性關(guān)鍵字。按這種方法你只能使用標識符。如果你想用其他任意字符串作為鍵名，你必須在對象字面量里加上引號，并使用方括號獲取和設(shè)置屬性。

> var obj = { 'not an identifier': 123 };
> obj['not an identifier']
123
> obj['not an identifier'] = 456;

方括號允許你動態(tài)計算屬性關(guān)鍵字：

> var x = 'name';
> jane[x]
'Jane'
> jane['na'+'me']
'Jane'

引用方法（Extracting methods）

如果你引用一個方法，它將失去和對象的連接。就其本身而言，函數(shù)不是方法，其中的this值為undefined（嚴格模式下）。

> var func = jane.describe;
> func()
TypeError: Cannot read property 'name' of undefined

解決辦法是使用函數(shù)內(nèi)置的bind()方法。它創(chuàng)建一個新函數(shù)，其this值固定為給定的值。

> var func2 = jane.describe.bind(jane);
> func2()
'Person named Jane'

方法內(nèi)部的函數(shù)（Functions inside a method）

每個函數(shù)都有一個特殊變量this。如果你在方法內(nèi)部嵌入函數(shù)是很不方便的，因為你不能從函數(shù)中訪問方法的this。下面是一個例子，我們調(diào)用forEach循環(huán)一個數(shù)組：

var jane = {
    name: 'Jane',
    friends: [ 'Tarzan', 'Cheeta' ],
    logHiToFriends: function () {
        'use strict';
        this.friends.forEach(function (friend) {
            // 這里的“this”是undefined
            console.log(this.name+' says hi to '+friend);
        });
    }
}

調(diào)用 logHiToFriends 會產(chǎn)生錯誤：

> jane.logHiToFriends()
TypeError: Cannot read property 'name' of undefined

有兩種方法修復(fù)這問題。

#1：將this存儲在不同的變量。

logHiToFriends: function () {
    'use strict';
    var that = this;
    this.friends.forEach(function (friend) {
        console.log(that.name+' says hi to '+friend);
    });
}

#2：forEach的第二個參數(shù)允許提供this值。

logHiToFriends: function () {
    'use strict';
    this.friends.forEach(function (friend) {
        console.log(this.name+' says hi to '+friend);
    }, this);
}

在JavaScript中函數(shù)表達式經(jīng)常被用作函數(shù)參數(shù)。時刻小心函數(shù)表達式中的this。

構(gòu)造函數(shù)：對象工廠（Constructors: factories for objects）

目前為止，你可能認為JavaScript的對象僅是鍵值的映射，通過JavaScript對象字面量可以得出這個觀點，看起來很像其他語言中的地圖/字典（map/dictionary）。然而，JavaScript對象也支持真正意義上的面向?qū)ο筇匦裕豪^承（inheritance）。本節(jié)會完全講解JavaScript中繼承的工作原理，但會給你以此為開始的簡單模式。如果你想得到更多知識，請查閱這篇文章“JavaScript inheritance by example”。

除了作為“真正”的函數(shù)和方法，函數(shù)還在JavaScript中扮演第三種角色：如果通過new操作符調(diào)用，他們會變?yōu)闃?gòu)造函數(shù)，對象的工廠。構(gòu)造函數(shù)是對其他語言中的類的粗略模擬。約定俗稱，構(gòu)造函數(shù)的第一個字母大寫。例如：

// 設(shè)置實例數(shù)據(jù)
function Point(x, y) {
    this.x = x;
    this.y = y;
}
// 方法
Point.prototype.dist = function () {
    return Math.sqrt(this.x*this.x + this.y*this.y);
};

我們看到構(gòu)造函數(shù)分為兩部分：首先，Point函數(shù)設(shè)置實例數(shù)據(jù)。其次，Point.prototype屬性包含對象的方法。前者的數(shù)據(jù)是每個實例私有的，后面的數(shù)據(jù)是所有實例共享的。

我們通過new操作符調(diào)用Point：

> var p = new Point(3, 5);
> p.x
3
> p.dist()
5.830951894845301

p是Point的一個實例：

> p instanceof Point
true
> typeof p
'object'

深入閱讀

• The pitfalls of using objects as maps in JavaScript [important, read soon]
• JavaScript inheritance by example
• Object properties in JavaScript [advanced: each property has attributes that determine whether it is writable, etc.]
• Private data for objects in JavaScript
• Javascript繼承 原型的陷阱
• Javascript 封裝問題

數(shù)組（Arrays）

數(shù)組是數(shù)組元素的序列，能通過整數(shù)索引方法數(shù)組元素，數(shù)組索引從0開始。

數(shù)組字面量（Array literals）

數(shù)組字面量創(chuàng)建數(shù)組很方便：

> var arr = [ 'a', 'b', 'c' ];

上面的數(shù)組有三個元素：分別是字符串“a”，“b”， “c”。你可以通過整數(shù)索引訪問它們：

> arr[0]
'a'
> arr[0] = 'x';
> arr
[ 'x', 'b', 'c' ]

length屬性總表示一個數(shù)組有多少項元素。

> arr.length
3

除此之外它也可以用來從數(shù)組上移除尾部元素：

> arr.length = 2;
> arr
[ 'x', 'b' ]

in操作符也可以在數(shù)組上工作。

> 1 in arr // arr在索引為1處是否有元素？
true
> 5 in arr // arr在索引為5處是否有元素？
false

值得注意的是數(shù)組是對象，因此可以有對象屬性：

> arr.foo = 123;
> arr.foo
123

數(shù)組方法（Array methods）

數(shù)組有許多方法。舉些例子：

> var arr = [ 'a', 'b', 'c' ];

> arr.slice(1, 2)  // 復(fù)制元素
[ 'b' ]
> arr.slice(1)
[ 'b', 'c' ]

> arr.push('x')  // 在末尾添加一個元素
4
> arr
[ 'a', 'b', 'c', 'x' ]

> arr.pop()  // 移除最后一個元素
'x'
> arr
[ 'a', 'b', 'c' ]

> arr.shift()  // 移除第一個元素
'a'
> arr
[ 'b', 'c' ]

> arr.unshift('x')  // 在前面添加一個元素
3
> arr
[ 'x', 'b', 'c' ]

> arr.indexOf('b')  // 查找給定項在數(shù)組中的索引，若不存在返回-1
1
> arr.indexOf('y') 
-1

> arr.join('-')  // 將元素拼接為一個字符串
'x-b-c'
> arr.join('')
'xbc'
> arr.join()
'x,b,c'

遍歷數(shù)組（Iterating over arrays）

有幾種方法可以遍歷數(shù)組元素。其中兩個最重要的是 forEach 和 map。

forEach遍歷整個數(shù)組，并將當前元素和它的索引傳遞給一個函數(shù)：

[ 'a', 'b', 'c' ].forEach(
    function (elem, index) {  // (*)
        console.log(index + '. ' + elem);
    });

上面代碼的輸出

0. a
1. b
2. c

注意（*）行的函數(shù)參數(shù)是可省略的。例如：它可以只有一個參數(shù) elem。

map創(chuàng)建一個新數(shù)組，通過給每個存在數(shù)組元素應(yīng)用一個函數(shù)：

> [1,2,3].map(function (x) { return x*x })
[ 1, 4, 9 ]

深入閱讀

• Arrays in JavaScript
• JavaScript quirk 8: array-like objects
• 有趣的javascript原生數(shù)組函數(shù)

正則表達式（Regular expressions）

JavaScript內(nèi)建支持正則表達式。他們被雙斜線分隔：

/^abc$/
/[A-Za-z0-9]+/

方法 test()：測試是否匹配（Method test(): is there a match?）

> /^a+b+$/.test('aaab')
true
> /^a+b+$/.test('aaa')
false

方法 exec()：匹配和捕獲組（Method exec(): match and capture groups）

> /a(b+)a/.exec('_abbba_aba_')
[ 'abbba', 'bbb' ]

返回的數(shù)組第一項（索引為0）是完整匹配，捕獲的第一個分組在第二項（索引為1），等。有一種方法可以反復(fù)調(diào)用獲取所有匹配。

方法 replace()：搜索并替換（Method replace(): search and replace）

> '<a> <bbb>'.replace(/<(.*?)>/g, '[$1]')
'[a] [bbb]'

replace的第一個參數(shù)必須是正則表達式，并且開啟全局搜索（/g 標記），否則僅第一個匹配項會被替換。有一種方法使用一個函數(shù)來計算替換項。

深入閱讀

• JavaScript: an overview of the regular expression API
• JavaScript Regular Expression Enlightenment [by Cody Lindley]

數(shù)學(xué)（Math）

Math是一個有算數(shù)功能的對象。例如：

> Math.abs(-2)
2

> Math.pow(3, 2)  // 3^2
9

> Math.max(2, -1, 5)
5

> Math.round(1.9)
2

> Math.cos(Math.PI)  // 預(yù)定義常量π
-1

標準庫的其他功能（Other functionality of the standard library）

JavaScript標準庫相對簡單，但有很多其他東西你可以使用：

• Date：日期構(gòu)造函數(shù)，主要功能有轉(zhuǎn)換和創(chuàng)建日期字符串，訪問日期組成部分（年，小時等）。
• JSON：一個對象，功能是轉(zhuǎn)換和生成JSON數(shù)據(jù)。
• console.* 方法：瀏覽器的具體方法，不是語言成分的部分，但他們也可以在Node.js中工作。

下一步學(xué)什么？

在你學(xué)會了這篇文章的基礎(chǔ)教程后，你可以轉(zhuǎn)到大部分章節(jié)末尾提到的高級教程。此外，我建議你看下面的資源：

• Style guides: I have written a guide to style guides.
• Underscore.js: 一個彌補JavaScript標準庫缺少的功能的庫
• JSbooks – free JavaScript books
• Frontend rescue: how to keep up to date on frontend technologies
• http://yanhaijing.com 當然還有我的博客也非常不錯哦
• http://yanhaijing.com/es5 如果你想成為高手，我建議閱讀ecmascript 規(guī)范
• 給javascript初學(xué)者的24條最佳實踐
• 我希望我知道的七個JavaScript技巧

歡迎反饋

我嘗試找到JavaScript的一個最理想子集。我成功了嗎？需要增刪一些東西嗎？如果你是一個JavaScript新手，我特別想聽聽你的意見：當讀這篇文章的時候是非常容易理解嗎？或是你在某些地方卡住？

注

原文：http://www.2ality.com/2013/06/basic-javascript.html