注：如果這篇筆記妨礙大家眼睛，亦或影響大家心情，亦或沒(méi)有用處，請您告知我，我會(huì )把它毫不留情的刪掉。
var a = [];
a.push(1,2,3);
a.reverse(); //將數組元素的次序反轉a.sort(); //排序
prompt() 方法用于顯示可提示用戶(hù)進(jìn)行輸入的對話(huà)框。
confirm()
parseInt
parseFloat
isNaN
isFinite
eval
String.toUpperCase()
String.toLowerCase()
HTML不區分大小寫(xiě)，onclick,onClick
JavaScript區分大小寫(xiě)，onclick
對象
Array
Function
Date
RegExp
Error
Math
Number
String
Infinity 無(wú)窮大，
正無(wú)窮大，Number.POSITIVE_INFINITY, Number.MAX_VALUE, 1/0, Infinity
負無(wú)窮大，Number.NEGATIVE_INFINITY, -Number.MAX_VALUE, -1/0, -Infinity
NaN非數字值, Number.NaN, 0/0
負零, -Number.MIN_VALUE/2, -1/Infinity, -0
0 = Number.MIN_VALUE/2 //發(fā)生下溢，計算結果為0
Javascript解釋器有自己的內存管理機制
負號是一元求反運算符
0x或0X十六進(jìn)制直接量
\u開(kāi)頭的為Unicode字符
使用0開(kāi)頭的八進(jìn)制直接量
JavaScript中的浮點(diǎn)數具有足夠的精度，并可以及其近似于0.1。但是事實(shí)，浮點(diǎn)數字不能精確表述的確帶來(lái)了一些問(wèn)題，如下代碼
var x = .3 - .2; // 0.3減去0.2
var y = .2 - .1; // 0.2減去0.1
x==y // => false：兩值不相等！
x == .1 // => false：.3-.2 不等于 .1
y == .1 // => true：.2-.1 等于 .1
在JavaScript中字符串是固定不變的，類(lèi)似replace()和toUpperCase()的方法都返回新字符串，原字符串本身并沒(méi)有發(fā)生改變。
訪(fǎng)問(wèn)字符串中的單個(gè)字符（16位值）：chartAt(), s[0], s[s.length-1]
JaveScript采用Perl中的正則表達式語(yǔ)法
正則表達式
/\bjavascript\b/ig // 匹配單詞"javascript"，"i"忽略大小寫(xiě)，"g"全文搜索，全文匹配
var text = "testing: 1, 2, 3"; // 文本示范
var pattern = /\d+/g; // 匹配所有包含一個(gè)或多個(gè)數字的實(shí)例
pattern.test(text); // => true: 匹配成功
text.search(pattern); // => 9: 首次匹配成功的位置
text.match(pattern); // => ["1", "2", "3"]: 所有匹配組成的數組
text.replace(pattern, "#"); // => "testing: #, #, #"
text.split(/\D+/); // => ["", "1", "2", "3"]: 用非數字字符街區字符串
對null執行typeof運算，結果返回字符串，也就是說(shuō)，可以將null認為是一個(gè)特殊的對象值，含義是非對象
undefined: 意思為“未定義”
var global = this; // 定義一個(gè)引用全局對象的全局變量
global === window; // => true
global返回全局對象，在客戶(hù)端JavaScript中，在其表示的瀏覽器窗口中的所有JavaScript代碼中，Window對象充當了全局對象，這個(gè)全局Window對象有一個(gè)屬性window引用其自身，它可以代替this來(lái)引用全局對象。Window對象定義了核心全局屬性，但它也針對Web瀏覽器和客戶(hù)端JavaScript定義了一少部分其他全局屬性。
JavaScript對象是一種復合值：它是屬性或已命名值的集合。通過(guò)“.”符號來(lái)引用屬性值。
var s = 'test'; // 創(chuàng )建一個(gè)字符串
s.len = 4; // 給它設置一個(gè)屬性
var t = s.len; // => t等于undefined 查詢(xún)一個(gè)屬性
這段代碼說(shuō)明了在讀取字符串、數字和布爾值的屬性值（或方法）的時(shí)候，表現的像對象一樣，但如果你試圖給其屬性賦值，則會(huì )忽略這個(gè)操作：修改只是發(fā)生在臨時(shí)對象身上，而這個(gè)臨時(shí)對象并未繼續保留下來(lái)，字符串、數字和布爾值的屬性都是只讀的，并且不能給它們定義新屬性。
JavaScript中的原始值（undefined、null、布爾值、數字和字符串）與對象（包括數組和函數）有著(zhù)根本區別。原始值是不可更改的：任何方式都無(wú)法更改一個(gè)原始值。
對象的比較并非值的比較：即使兩個(gè)對象包含同樣的屬性及相同的值，它們也是不相等的。各個(gè)索引元素完全相等的兩個(gè)數組也不相等。我們通常將對象稱(chēng)為引用類(lèi)型，以此來(lái)和JavaScript的基本類(lèi)型區分開(kāi)來(lái)。依照術(shù)語(yǔ)的叫法，對象值都是引用，對象的比較均是引用的比較，當且僅當引用同一個(gè)基對象時(shí)，它們才相等。
包裝對象：存取字符串、數字或布爾值的屬性時(shí)創(chuàng )建的臨時(shí)對象
JavaScript運算符合語(yǔ)句期望使用多樣化的數據類(lèi)型，并可以相互轉換。if語(yǔ)句將undefined轉換成false，但“==”運算符從不試圖將其操作數轉換為布爾值。
在代碼中會(huì )經(jīng)常見(jiàn)到的類(lèi)型轉換慣用法：
x + "" // 等價(jià)于 String(x)
+x // 等價(jià)于 Number(x) 也可以寫(xiě)成 x-0
!!x // 等價(jià)于 Boolean(x) 注意是雙嘆號
Number → String
Number類(lèi)定義的toString()方法可以接收表示轉換基數的可選參數，如果不指定此參數，轉換規則將是基于十進(jìn)制。同樣，亦可以將數字轉換為其他進(jìn)制數（范圍在2~36）之間，例如：
var n = 17;
binary_string = n.toString(2); // 轉換為 "10001"
octal_string = "0" + n.toString(8); // 轉換為 "021"
hex_string = "0x" + n.toString(16); // 轉換為 "0x11"
parseInt()方法的第二個(gè)可選參數類(lèi)似
var n = 123456.789;
下面的方法都轉為字符串
n.toFixed(0); // "123457"
n.toFixed(2); // "123456.79"
n.toFixed(5); // "123456.78900"
n.toExponential(1); // "1.2e+5"
n.toExponential(3); // "1.235e+5"
n.toPrecision(4); // "1.235e+5"
n.toPrecision(7); // "123456.8"
n.toPrecision(10); // "123456.7890"
parseInt("3 blind mice") // => 3
parseFloat(" 3.14 meters") // => 3.14
parseInt("-12.34") // => 12
parseInt("0xFF") // => 255
parseInt("0xff") // => 255
parseInt("-0XFF") // => -255
parseFloat(".1") // => 0.1
parseInt("0.1") // => 0
parseInt(".1") // => NaN: 整數不能以"."開(kāi)始
parseFloat("$72.47"); // => NaN: 數字不能以"$"開(kāi)始
parseInt()可以接收第二個(gè)可選參數，這個(gè)參數指定數字轉換的基數，合法的取值范圍是2~36，例如：
parseInt("11", 2); // => 3 (1*2 + 1)
parseInt("ff", 16); // => 255 (15*16 + 15)
parseInt("zz", 36); // => 1295 (35*36 + 35)
parseInt("077", 8); // => 63 (7*8 + 7)
parseInt("077", 10); // => 77 (7*10 + 7)
對象到布爾值的轉換非常簡(jiǎn)單：所有的對象（包括數組和函數）都轉換為true。對于包裝對象亦是如此：new Boolean(false)是一個(gè)對象而不是原始值，它將轉換為true。
很多類(lèi)定義了更多特定版本的toString()方法。例如：
[1,2,3].toString() // => "1,2,3"
(function(x) { f(x); }).toString() // => "function(x) {\n f(x);\n}"
/\d+/g.toString() // => "/\\d+/g"
new Date(2010, 0, 1).toString() // => "Fri Jan 01 2010 00:00:00 GMT-0800 (PST)"
日期類(lèi)定義的valueOf()方法會(huì )返回它的一個(gè)內部表示：1970年1月1日以來(lái)的毫秒數。
var d = new Date(2010, 0, 1); // 2010年1月1日（太平洋時(shí)間）
d.valueOf() // => 1262332800000
對象到字符串的轉換步驟：
1、如果對象具有toString()方法，則調用這個(gè)方法。如果它返回一個(gè)原始值，JavaScript將這個(gè)值轉換為字符串（如果本身不是字符串的話(huà)），并返回這個(gè)字符串結果。
2、如果對象沒(méi)有toString()方法，或者這個(gè)方法并不返回一個(gè)原始值，那么JavaScript會(huì )調用valueOf。如果存在這個(gè)方法，則JavaScript調用它。如果返回值是原始值，JavaScript將這個(gè)值轉換為字符串（如果本身不是字符串的話(huà)）。
3、否則，JavaScript無(wú)法從toString()或valueOf()獲得一個(gè)原始值，因此這是它將拋出一個(gè)類(lèi)型錯誤異常。
對象到數字的轉換步驟
1、如果對象具有valueOf()方法，后者返回一個(gè)原始值，則JavaScript將這個(gè)原始值轉換為數字（如果需要的話(huà)）并返回這個(gè)數字。
2、否則，如果對象具有toString()方法，后者返回一個(gè)原始值，則JavaScript將其轉換并返回。
3、否則，JavaScript拋出一個(gè)類(lèi)型錯誤異常。
直接量：在程序中直接顯示的出來(lái)的數值，javascript中的直接量包括字符串直接量，數字直接量，布爾直接量，數組直接量，函數直接量，對象直接量和特殊直接量7種。
JavaScript的函數作用域是指函數內聲明的所有變量在函數體內始終是可見(jiàn)的。有意思的是，這意味著(zhù)變量在聲明之前甚至已經(jīng)可用。JavaScript的這個(gè)特性被非正式地稱(chēng)為聲明提前，即JavaScript函數里聲明的所有變量（但不涉及賦值）都被“提前”至函數體的頂部。
函數定義可以嵌套。
var scope = "global";
function f() {
console.log(scope); // 輸出"undefined"，而不是"global
var scope = "local"; // 變量這這里賦初始值，但變量本身在函數體內任何地方均是有定義的
console.log(scope); // 輸出"local“
}
解釋?zhuān)耗憧赡苷`以為函數中的第一行輸出”global“，因為代碼還沒(méi)有執行var語(yǔ)句聲明局部變量的地方。其實(shí)不然，由于函數作用域的特性，局部變量在整個(gè)函數體始終是有定義的，也就是說(shuō)，在函數體內局部變量遮蓋了同名全局變量。盡管如此，只有在程序執行var語(yǔ)句的時(shí)候，局部變量才會(huì )被真正賦值。因此，上述過(guò)程等價(jià)于：將函數內的變量聲明”提前“至函數體頂部，同時(shí)變量初始化留在原來(lái)的位置：
function f() {
var scope; // 在函數頂部聲明了局部變量
console.log(scope); // 變量存在，但其值是 "undefined"
scope = "local"; // 這里將其初始化并賦值
console.log(scope); // 這里它具有了我們所期望的值
}
在具有塊級作用域的編程語(yǔ)言中，在狹小的作用域里讓變量聲明和使用變量的代碼盡可能靠近彼此，通常來(lái)講，這是一個(gè)非常不錯的編程習慣。由于JavaScript沒(méi)有塊級作用域，因此一些程序猿特意將變量聲明放在函數體頂部，而不是將聲明靠近放在使用變量之處。這種做法使得他們的源代碼非常清晰地反映了真實(shí)的變量作用域。
當聲明一個(gè)JavaScript全局變量時(shí)，實(shí)際上是定義了全局對象的一個(gè)屬性（見(jiàn)3.5節）。當使用var聲明一個(gè)變量時(shí)，創(chuàng )建的這個(gè)屬性是不可配置的（見(jiàn)6.7節），也就是說(shuō)這個(gè)變量無(wú)法通過(guò)delete運算符刪除?？赡苣阋呀?jīng)注意到了，如果你沒(méi)有使用嚴格模式并給一個(gè)未聲明的變量賦值的話(huà)，JavaScript會(huì )自動(dòng)創(chuàng )建一個(gè)全局變量。以這種方式創(chuàng )建的變量時(shí)全局對象的正常的可配值屬性，并可以刪除它們。
JavaScript全局變量是全局對象的屬性，這是在ECMAScript規范中強制規定的。
最簡(jiǎn)單的表達式是“原始表達式”。原始表達式是表達式的最小單位——它們不再包含其他表達式。JavaScript中的原始表達式包含常量或直接量，關(guān)鍵字和變量。
直接量是直接在程序中出現的常數值。
1.23 // 數字直接量
"hello" // 字符串直接量
/pattern/ // 正則表達式直接量
一些保留字構成直接表達式
true、false、null、this
在方法體內，this返回調用這個(gè)方法的對象，this相關(guān)可參考4.5節、第8章（8.2.2節）和第九章
第三種原始表達式是變量：
i,a,b,undefined（undefined是全局變量，和null不同，它不是關(guān)鍵字）
屬性訪(fǎng)問(wèn)表達式
expression . identifier
expression [ expression ]
第一種寫(xiě)法是一個(gè)表達式后跟隨一個(gè)句點(diǎn)和標識符。用于訪(fǎng)問(wèn)對象屬性
第二種寫(xiě)法是使用方括號，方括號內是另外一個(gè)表達式，用于訪(fǎng)問(wèn)對象或數組的屬性或元素
在JavaScript中，所有的數字都是浮點(diǎn)型的，除法運算的結果也是浮點(diǎn)型，比如，5/2的結果是2.5，而不是2。除數為0的運算結果為正無(wú)窮大或負無(wú)窮大，而0/0的結果是NaN。
求余運算符的操作數通常都是整數，但也適用于浮點(diǎn)數，比如，6.5%2.1結果是0.2。
“+” 運算符
1 + {} // => "1[object Object]"：對象轉換為字符串后進(jìn)行字符串連接
true + false // => 2：布爾值轉換為數字后做加法
2 + null // => 2：null轉換為0后做加法
2 + undefined // => NaN：undefined轉換為NaN后做加法
嚴格相等運算符(恒等運算符)“===”首先計算其操作數的值，然后比較這兩個(gè)值，比較過(guò)程沒(méi)有任何類(lèi)型轉換：
- 如果兩個(gè)值類(lèi)型不相同，則它們不相等。
- 如果兩個(gè)值都是null或者都是undefined，則它們相等，null與undefined不嚴格相等
- 如果兩個(gè)值都是布爾值true或都是布爾值false，則它們相等。
- 如果其中一個(gè)值是NaN，或者兩個(gè)值都是NaN，則它們不相等。NaN和其他任何值都是不相等的，包括它本身！通過(guò)x!==x來(lái)判斷x是否為NaN，只有在x為NaN的時(shí)候，這個(gè)表達式的值才為true。
- 如果兩個(gè)值為數字且數值相等，則它們相等。如果一個(gè)值為0，另一個(gè)值為-0，則它們同樣相等。
- 如果兩個(gè)值為字符串，且所含的對應位上的16位數（參照3.2節）完全相等，則它們相等。如果它們的長(cháng)度或內容不同，則它們不等。兩個(gè)字符串可能含義完全一樣且所顯示出的字符串也一樣，但具有不同編碼的16位值。JavaScript并不對Unicode進(jìn)行標準化的轉換，因此像這樣的字符串通過(guò)“===”和“==”運算符的比較結果也不相等。
- 如果兩個(gè)引用值指向同一個(gè)對象、數組或函數，則它們是相等的。如果指向不同的對象，則它們是不等的，盡管兩個(gè)對象具有完全一樣的屬性。
相等運算符“==”和恒等運算符相似，但相等運算符的比較并不嚴格。如果兩個(gè)操作數不是同一類(lèi)型，那么相等運算符會(huì )嘗試進(jìn)行一些類(lèi)型轉換，然后進(jìn)行比較：
- 如果兩個(gè)操作數的類(lèi)型相同，則和上文所述的嚴格相等的比比較規則一樣。
- 如果兩個(gè)操作數類(lèi)型不同，“==”相等操作符也可能會(huì )認為它們相等。檢測相等將會(huì )遵守如下規則和類(lèi)型轉換：
如果一個(gè)值為null，另一個(gè)是undefined，則它們相等。
如果一個(gè)值是數字，另一個(gè)是字符串，先將字符串轉換為數字，然后使用轉換后的值進(jìn)行比較。
如果其中一個(gè)值是true，則將其自身轉換為1再進(jìn)行比較。如果其中一個(gè)值是false，則將其自身轉換為0再進(jìn)行比較。
如果一個(gè)值是對象，另一個(gè)值是數字或字符串，則使用3.8.3節所提到的轉換規則將對象轉換為原始值，然后再進(jìn)行比較。對象通過(guò)toString()方法或者valueOf()方法轉換為原始值。JavaScript語(yǔ)言核心的內置類(lèi)首先嘗試使用valueOf()，再?lài)L試使用toString()，除了日期類(lèi)，日期類(lèi)只使用toString()轉換。那些不是JavaScript語(yǔ)言核心中的對象則通過(guò)各自實(shí)現中定義的方法轉換為原始值
其他不同類(lèi)型之間的比較均不相等。
比較操作符的操作數可能是任意類(lèi)型。然而，只有數字和字符串才能真正執行比較操作，因此那些不是數字和字符串的操作數將進(jìn)行類(lèi)型轉換，類(lèi)型轉換規則如下：
如果操作數為對象，那么這個(gè)對象將依照3.8.3節結尾處所描述的轉換規則轉換為原始值：如果valueOf()返回一個(gè)原始值，那么直接使用這個(gè)原始值。否則，使用toString()的轉換結果進(jìn)行比較操作。
在對象轉換為原始值之后，如果兩個(gè)操作數都是字符串，那么將依照字母表的順序對兩個(gè)字符串進(jìn)行比較，這里提到的“字母表順序”是指組成這個(gè)字符串的16位Unicode字符的索引順序。
在對象轉換為原始值之后，如果至少有一個(gè)操作數不是字符串，那么兩個(gè)操作數都將轉換為數字進(jìn)行數值比較。0和-0相等的。Infinity比其他任何數字都大（除了Infinity本身），-Infinity比其他任何數字都?。ǔ怂陨恚?。如果其中一個(gè)操作數是（或轉換后是）NaN，那么比較操作符總是返回false
對于數字和字符串操作符來(lái)說(shuō)，加號運算符和比較運算符的行為都有所不同，前者更偏愛(ài)字符串，如果它的其中一個(gè)操作數是字符串的話(huà)，則進(jìn)行字符串連接操作。而比較運算符更偏愛(ài)數字，只有在兩個(gè)操作數都是字符串的時(shí)候，才會(huì )進(jìn)行字符串的比較。
最后，需要注意的是，“<=”（小于等于）和“>=”（大于等于）運算符在判斷相等的時(shí)候，并不依賴(lài)與相等運算符和嚴格運算符的比較規則，相反，小于等于運算符只是簡(jiǎn)單的“不大于”，大于等于運算符也只是“不小于”，只有一個(gè)例外，那就是當其一個(gè)操作數是（或則轉換后是）NaN的時(shí)候，所有4個(gè)比較運算符均返回false。
in運算符
in運算符希望它的左操作數是一個(gè)字符串或可以轉換為字符串，希望它的右操作數是一個(gè)對象。如果右側的對象擁有一個(gè)名為左操作數值的屬性名，那么表達式返回true，例如：
var point = { x:1, y:1} // 定義一個(gè)對象
"x" in point // => true : 對象有一個(gè)名為“x”的屬性
"z" in point // => false : 對象中不存在名為”z“ 的屬性
"toString" in point // => true : 對象繼承了toString()方法
var data = [7,8,9]; // 擁有三個(gè)元素的數組
"0" in data // => true : 數組包含元素“0”
1 in data // => true : 數字轉換為字符串
3 in data // => false : 沒(méi)有索引為3的元素
instanceof運算符
instanceof運算符希望左操作數是一個(gè)對象，右操作數標識對象的類(lèi)，如果左側的對象是右側類(lèi)的實(shí)例，則表達式返回true；否則返回false。第9章將會(huì )講到，JavaScript中對象的類(lèi)是通過(guò)初始化它們的構造函數來(lái)定義的。這樣的話(huà)，instanceof的右操作數應當是一個(gè)函數。
var a = [1, 2, 3]; // 通過(guò)數組直接量的寫(xiě)法創(chuàng )建一個(gè)數組
a instanceof Array; // 計算結果為true，a是一個(gè)數組
a instanceof Object; // 計算結果為true，所有的數組都是對象
a instanceof RegExp; // 計算結果為false，數組不是正則表達式
var o = { x : 1 };
var p = null;
o && o.x // => 1，o是真值，因此返回值為o.x
p && p.x // => null，p是假值，因此將其返回，而并不去計算p.x
eval()只有一個(gè)參數，如果傳入的參數不是字符串，它直接返回這個(gè)參數，如果參數是字符串，它會(huì )把字符串當成JavaScript代碼進(jìn)行編譯。
eval使用了調用它的變量作用域環(huán)境，別名eval使用了全局作用域環(huán)境。
變量在聲明它們的腳本或函數中都是有定義的，變量聲明語(yǔ)句會(huì )被“提前”至腳本或者函數的頂部，但是初始化的操作則還在原來(lái)var語(yǔ)句的位置執行，在聲明語(yǔ)句之前變量的值是undefined
函數聲明語(yǔ)句通常出現在JavaScript代碼的最頂層，也可以嵌套在其他函數體內。但在嵌套時(shí)，函數聲明只能出現在所嵌套函數的頂部。也就是說(shuō)，函數定義不能出現在if語(yǔ)句、while循環(huán)或者其他任何語(yǔ)句中，正是由于函數聲明位置的這種限制，ECMAScript標準規范并沒(méi)有將函數聲明歸類(lèi)為真正的語(yǔ)句。有一些JavaScript實(shí)現的確允許在出現語(yǔ)句的地方都可以進(jìn)行函數聲明，但是不同的實(shí)現在細節處理方式上有很大差別，因此將函數聲明放在其他的語(yǔ)句內的做法并不具備可移植性。
盡管函數聲明語(yǔ)句和函數定義表達式包含相同的函數名，但二者仍然不同。兩種方式都創(chuàng )建了新的函數對象，但函數聲明語(yǔ)句中的函數名是一個(gè)變量名，變量指向函數對象。和通過(guò)var聲明變量一樣，函數定義語(yǔ)句中的函數被顯示地“提前”到了腳本或函數的頂部。因此它們在整個(gè)腳本和函數內都是可見(jiàn)的。使用var的話(huà)，只有變量聲明提前了——變量的初始化代碼仍然在原來(lái)的位置。然而使用函數聲明語(yǔ)句的話(huà)，函數名稱(chēng)和函數體均提前：腳本中所有函數和函數中所有嵌套的函數都會(huì )在當前上下文中其他代碼之前聲明。也就是說(shuō)，可以在聲明一個(gè)JavaScript函數之前調用它。
switch(n) {
case 1: { // 如果 n === 1，從這里開(kāi)始執行
// 執行代碼塊 1
break;} // 停止執行switch語(yǔ)句
case 2: // 如果 n === 2，從這里執行
// 執行代碼塊 2
break; // 在這里停止執行switch語(yǔ)句
case 3: // 如果 n === 3，從這里執行
// 執行代碼塊 3
break; // 在這里停止執行switch語(yǔ)句
default: // 如果所有的條件都不匹配
// 執行代碼塊 4
break; // 在這里停止執行switch語(yǔ)句
}
break語(yǔ)句可以使解釋器跳出switch語(yǔ)句或循環(huán)語(yǔ)句。在switch語(yǔ)句中，case只是指明了要執行的代碼起點(diǎn)，但并沒(méi)有指明終點(diǎn)。如果沒(méi)有break語(yǔ)句，那么switch語(yǔ)句中的每一個(gè)case還包括default中的代碼塊都會(huì )執行，直到整個(gè)switch代碼塊的結尾。 ECMAScript標準允許每個(gè)case關(guān)鍵字跟隨任意的表達式。
由于JavaScript中的case表達式的值是在運行時(shí)（run-time）計算的，這一點(diǎn)使得JavaScript的switch語(yǔ)句和C、C++、和Java中的switch語(yǔ)句有很大區別（并且效率也很低）。
For/in語(yǔ)句，語(yǔ)法如下：
for (variable in object)
statement
只要 for/in 循環(huán)中 variable 的值可以當做賦值表達式的左值，它可以是任意表達式。每次循環(huán)都會(huì )計算這個(gè)表達式，也就是說(shuō)每次循環(huán)它計算的值有可能不同。例如，可以用下面這段代碼將所有對象屬性復制至一個(gè)數組中：
var o = {x:1, y:2, z:3};
var a = [], i =0;
for(a[i++] in o) /* empty */;
for/in循環(huán)并不會(huì )遍歷對象的所有屬性，只有 ”可枚舉“ （enumerable）的屬性才會(huì )遍歷到。（參照第6章）
標簽語(yǔ)句
語(yǔ)句是可以添加標簽的，標簽是由語(yǔ)句前的標識符和冒號組成：
identifier : statement
break 和 continue 是 JavaScript 中唯一可以使用語(yǔ)句標簽的語(yǔ)句。
語(yǔ)句標簽只有在它所起作用的語(yǔ)句（當然也可以在它的子句中）內是有定義的。
break 可以 “跳出” 任何閉合的語(yǔ)句塊。這里的語(yǔ)句可以是由花括號括起來(lái)的一組語(yǔ)句。
不管 break 語(yǔ)句帶不帶標簽，它的控制權都無(wú)法越過(guò)函數的邊界。
不管continue語(yǔ)句帶不帶標簽，它只能在循環(huán)體內使用。在其他地方使用將會(huì )報語(yǔ)法錯誤。
在不同類(lèi)型的循環(huán)中，continue的行為也有所區別
- 在 while 循環(huán)中，在循環(huán)開(kāi)始處指定的expression會(huì )重復檢測，如果檢測結果為true，循環(huán)體會(huì )頭開(kāi)始執行
- 在 do/while 循環(huán)中，程序的執行直接跳到循環(huán)結尾處，這時(shí)會(huì )重新判斷循環(huán)條件，再執行
- 在 for 循環(huán)中，首先計算自增表達式，然后再次檢測 test 表達式，用以判斷是否執行循環(huán)體
- 在 for/in 循環(huán)中，循環(huán)開(kāi)始遍歷下一個(gè)屬性名，這個(gè)屬性名賦給了指定的變量。
return 語(yǔ)句語(yǔ)法
return expression;
return 語(yǔ)句只能在函數體內出現，如果不是的話(huà)會(huì )報語(yǔ)法錯誤。當調用的函數時(shí)，該函數不存在return語(yǔ)句或return語(yǔ)句不帶expression，則該函數的返回值為undefined。
待續......
