JavaScript代碼可以直接嵌在網(wǎng)頁(yè)的任何地方，不過(guò)通常我們都把JavaScript代碼放到<head>中：
<html>
<head>
<script>
alert('Hello, world');
</script>
</head>
<body>
...
</body>
</html>
由<script>...</script>包含的代碼就是JavaScript代碼，它將直接被瀏覽器執(zhí)行。
第二種方法是把JavaScript代碼放到一個(gè)單獨(dú)的.js文件，然后在HTML中通過(guò)<script src="..."></script>引入這個(gè)文件：
<html>
<head>
<script src="/static/js/abc.js"></script>
</head>
<body>
...
</body>
</html>
這樣，/static/js/abc.js就會(huì)被瀏覽器執(zhí)行。
把JavaScript代碼放入一個(gè)單獨(dú)的.js文件中更利于維護(hù)代碼，并且多個(gè)頁(yè)面可以各自引用同一份.js文件。
可以在同一個(gè)頁(yè)面中引入多個(gè).js文件，還可以在頁(yè)面中多次編寫<script> js代碼... </script>，瀏覽器按照順序依次執(zhí)行。
有些時(shí)候你會(huì)看到<script>標(biāo)簽還設(shè)置了一個(gè)type屬性：
<script type="text/javascript">
...
</script>
但這是沒(méi)有必要的，因?yàn)槟J(rèn)的type就是JavaScript，所以不必顯式地把type指定為JavaScript。
如何編寫JavaScript
首先在愛(ài)情守望者下載WebStorm，然后在破解網(wǎng)站獲取注冊(cè)碼，在注冊(cè)時(shí)選code注冊(cè)并把注冊(cè)碼復(fù)制進(jìn)去即可，更詳細(xì)可參考這個(gè)簡(jiǎn)書。
1.基本語(yǔ)法
每句代碼的結(jié)尾都要加上;，即使有的情況下可以不用加，但我們最好不用省略。
語(yǔ)句塊是一組語(yǔ)句的集合，例如，下面的代碼先做了一個(gè)判斷，如果判斷成立，將執(zhí)行{...}中的所有語(yǔ)句：
if (2 > 1) {
x = 1;
y = 2;
z = 3;
}
注釋：
1.// 注釋內(nèi)容
2./* 注釋內(nèi)容 */
2.數(shù)據(jù)類型和變量
Number
JavaScript不區(qū)分整數(shù)和浮點(diǎn)數(shù)，統(tǒng)一用Number表示，以下都是合法的Number類型：
123; // 整數(shù)123
0.456; // 浮點(diǎn)數(shù)0.456
1.2345e3; // 科學(xué)計(jì)數(shù)法表示1.2345x1000，等同于1234.5
-99; // 負(fù)數(shù)
NaN; // NaN表示Not a Number，當(dāng)無(wú)法計(jì)算結(jié)果時(shí)用NaN表示
Infinity; // Infinity表示無(wú)限大，當(dāng)數(shù)值超過(guò)了JavaScript的Number所能表示的最大值時(shí)，就表示為Infinity
Number可以直接做四則運(yùn)算，規(guī)則和數(shù)學(xué)一致：
1 + 2; // 3
(1 + 2) * 5 / 2; // 7.5
2 / 0; // Infinity
0 / 0; // NaN
10 % 3; // 1
10.5 % 3; // 1.5
字符串
字符串是以單引號(hào)'或雙引號(hào)"括起來(lái)的任意文本，比如'abc'，"xyz"等等。請(qǐng)注意，''或""本身只是一種表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c這3個(gè)字符。
布爾值
布爾值和布爾代數(shù)的表示完全一致，一個(gè)布爾值只有true、false兩種值，要么是true，要么是false，可以直接用true、false表示布爾值，也可以通過(guò)布爾運(yùn)算計(jì)算出來(lái)：
true; // 這是一個(gè)true值
false; // 這是一個(gè)false值
2 > 1; // 這是一個(gè)true值
2 >= 3; // 這是一個(gè)false值
&&運(yùn)算是與運(yùn)算，只有所有都為true，&&運(yùn)算結(jié)果才是true;||運(yùn)算是或運(yùn)算，只要其中有一個(gè)為true，||運(yùn)算結(jié)果就是true;!運(yùn)算是非運(yùn)算，它是一個(gè)單目運(yùn)算符，把true變成false，false變成true:
true && true; // 這個(gè)&&語(yǔ)句計(jì)算結(jié)果為true
true && false; // 這個(gè)&&語(yǔ)句計(jì)算結(jié)果為false
false && true && false; // 這個(gè)&&語(yǔ)句計(jì)算結(jié)果為false
false || false; // 這個(gè)||語(yǔ)句計(jì)算結(jié)果為false
true || false; // 這個(gè)||語(yǔ)句計(jì)算結(jié)果為true
false || true || false; // 這個(gè)||語(yǔ)句計(jì)算結(jié)果為true
! true; // 結(jié)果為false
! false; // 結(jié)果為true
! (2 > 5); // 結(jié)果為true
布爾值經(jīng)常用在條件判斷中，比如：
var age = 15;
if (age >= 18) {
alert('adult');
} else {
alert('teenager');
}
比較運(yùn)算符
JavaScript允許對(duì)任意數(shù)據(jù)類型做比較：
false == 0; // true
false === 0; // false
要特別注意相等運(yùn)算符==。JavaScript在設(shè)計(jì)時(shí)，有兩種比較運(yùn)算符：
第一種是==比較，它會(huì)自動(dòng)轉(zhuǎn)換數(shù)據(jù)類型再比較，很多時(shí)候，會(huì)得到非常詭異的結(jié)果；
第二種是===比較，它不會(huì)自動(dòng)轉(zhuǎn)換數(shù)據(jù)類型，如果數(shù)據(jù)類型不一致，返回false，如果一致，再比較。
由于JavaScript這個(gè)設(shè)計(jì)缺陷，不要使用==比較，始終堅(jiān)持使用===比較。
另一個(gè)例外是NaN這個(gè)特殊的Number與所有其他值都不相等，包括它自己：
NaN === NaN; // false
唯一能判斷NaN的方法是通過(guò)isNaN()函數(shù)：
isNaN(NaN); // true
最后要注意浮點(diǎn)數(shù)的相等比較：
1 / 3 === (1 - 2 / 3); // false
這不是JavaScript的設(shè)計(jì)缺陷。浮點(diǎn)數(shù)在運(yùn)算過(guò)程中會(huì)產(chǎn)生誤差，因?yàn)橛?jì)算機(jī)無(wú)法精確表示無(wú)限循環(huán)小數(shù)。要比較兩個(gè)浮點(diǎn)數(shù)是否相等，只能計(jì)算它們之差的絕對(duì)值，看是否小于某個(gè)閾值：
Math.abs(1 / 3 - (1 - 2 / 3)) < 0.0000001; // true
null和undefined
null表示一個(gè)“空”的值，它和0以及空字符串''不同，0是一個(gè)數(shù)值，''表示長(zhǎng)度為0的字符串，而null表示“空”。
JavaScript的設(shè)計(jì)者希望用null表示一個(gè)空的值，而undefined表示值未定義。事實(shí)證明，這并沒(méi)有什么卵用，區(qū)分兩者的意義不大。大多數(shù)情況下，我們都應(yīng)該用null。undefined僅僅在判斷函數(shù)參數(shù)是否傳遞的情況下有用。
數(shù)組
數(shù)組是一組按順序排列的集合，集合的每個(gè)值稱為元素。JavaScript的數(shù)組可以包括任意數(shù)據(jù)類型。例如：
[1, 2, 3.14, 'Hello', null, true];
另一種創(chuàng)建數(shù)組的方法是通過(guò)Array()函數(shù)實(shí)現(xiàn)：
new Array(1, 2, 3); // 創(chuàng)建了數(shù)組[1, 2, 3]
數(shù)組的元素可以通過(guò)索引來(lái)訪問(wèn)。請(qǐng)注意，索引的起始值為0：
var arr = [1, 2, 3.14, 'Hello', null, true];
arr[0]; // 返回索引為0的元素，即1
arr[5]; // 返回索引為5的元素，即true
arr[6]; // 索引超出了范圍，返回undefined
對(duì)象
JavaScript的對(duì)象是一組由鍵-值組成的無(wú)序集合，例如：
var person = {
name: 'Bob',
age: 20,
tags: ['js', 'web', 'mobile'],
city: 'Beijing',
hasCar: true,
zipcode: null
};
JavaScript對(duì)象的鍵都是字符串類型，值可以是任意數(shù)據(jù)類型。上述`person`對(duì)象一共定義了6個(gè)鍵值對(duì)，其中每個(gè)鍵又稱為對(duì)象的屬性，例如，`person`的`name`屬性為`'Bob'`，`zipcode`屬性為`null`。
要獲取一個(gè)對(duì)象的屬性，我們用對(duì)象變量.屬性名的方式：
person.name; // 'Bob'
person.zipcode; // null
變量
變量在JavaScript中就是用一個(gè)變量名表示，變量名是大小寫英文、數(shù)字、$和_的組合，且不能用數(shù)字開(kāi)頭。變量名也不能是JavaScript的關(guān)鍵字，如if、while等。申明一個(gè)變量用var語(yǔ)句，比如：
var a; // 申明了變量a，此時(shí)a的值為undefined
var $b = 1; // 申明了變量$b，同時(shí)給$b賦值，此時(shí)$b的值為1
var s_007 = '007'; // s_007是一個(gè)字符串
var Answer = true; // Answer是一個(gè)布爾值true
var t = null; // t的值是null
在JavaScript中，使用等號(hào)=對(duì)變量進(jìn)行賦值。可以把任意數(shù)據(jù)類型賦值給變量，同一個(gè)變量可以反復(fù)賦值，而且可以是不同類型的變量，但是要注意只能用var申明一次，例如：
var a = 123; // a的值是整數(shù)123
a = 'ABC'; // a變?yōu)樽址?這種變量本身類型不固定的語(yǔ)言稱之為動(dòng)態(tài)語(yǔ)言，與之對(duì)應(yīng)的是靜態(tài)語(yǔ)言。靜態(tài)語(yǔ)言在定義變量時(shí)必須指定變量類型，如果賦值的時(shí)候類型不匹配，就會(huì)報(bào)錯(cuò)。例如Java是靜態(tài)語(yǔ)言，賦值語(yǔ)句如下：
int a = 123; // a是整數(shù)類型變量，類型用int申明
a = "ABC"; // 錯(cuò)誤：不能把字符串賦給整型變量
strict模式
JavaScript在設(shè)計(jì)之初，為了方便初學(xué)者學(xué)習(xí)，并不強(qiáng)制要求用var申明變量。這個(gè)設(shè)計(jì)錯(cuò)誤帶來(lái)了嚴(yán)重的后果：如果一個(gè)變量沒(méi)有通過(guò)var申明就被使用，那么該變量就自動(dòng)被申明為全局變量：
i = 10; // i現(xiàn)在是全局變量
在同一個(gè)頁(yè)面的不同的JavaScript文件中，如果都不用var申明，恰好都使用了變量i，將造成變量i互相影響，產(chǎn)生難以調(diào)試的錯(cuò)誤結(jié)果。
使用var申明的變量則不是全局變量，它的范圍被限制在該變量被申明的函數(shù)體內(nèi)（函數(shù)的概念將稍后講解），同名變量在不同的函數(shù)體內(nèi)互不沖突。
為了修補(bǔ)JavaScript這一嚴(yán)重設(shè)計(jì)缺陷，ECMA在后續(xù)規(guī)范中推出了strict模式，在strict模式下運(yùn)行的JavaScript代碼，強(qiáng)制通過(guò)var申明變量，未使用var申明變量就使用的，將導(dǎo)致運(yùn)行錯(cuò)誤。
啟用strict模式的方法是在JavaScript代碼的第一行寫上：
'use strict';
這是一個(gè)字符串，不支持strict模式的瀏覽器會(huì)把它當(dāng)做一個(gè)字符串語(yǔ)句執(zhí)行，支持strict模式的瀏覽器將開(kāi)啟strict模式運(yùn)行JavaScript。
3.字符串
JavaScript的字符串就是用''或""括起來(lái)的字符表示。
如果'本身也是一個(gè)字符，那就可以用""括起來(lái)，比如"I'm OK"包含的字符是I，'，m，空格，O，K這6個(gè)字符。
如果字符串內(nèi)部既包含'又包含"怎么辦？可以用轉(zhuǎn)義字符\來(lái)標(biāo)識(shí)，比如：
I\'m \"OK\"!';
表示的字符串內(nèi)容是：I'm "OK"!
轉(zhuǎn)義字符\可以轉(zhuǎn)義很多字符，比如\n表示換行，\t表示制表符，字符\本身也要轉(zhuǎn)義，所以\\表示的字符就是\。
多行字符串
由于多行字符串用\n寫起來(lái)比較費(fèi)事，所以最新的ES6標(biāo)準(zhǔn)新增了一種多行字符串的表示方法，用反引號(hào)` ... ` 表示：
模板字符串
要把多個(gè)字符串連接起來(lái)，可以用+號(hào)連接：
var name = '小明';
var age = 20;
var message = '你好, ' + name + ', 你今年' + age + '歲了!';
如果有很多變量需要連接，用+號(hào)就比較麻煩。ES6新增了一種模板字符串，表示方法和上面的多行字符串一樣，但是它會(huì)自動(dòng)替換字符串中的變量：
var name = '小明';
var age = 20;
var message = `你好, ${name}, 你今年${age}歲了!`;
操作字符串
字符串常見(jiàn)的操作如下：
var s = 'Hello, world!';
s.length; // 13
要獲取字符串某個(gè)指定位置的字符，使用類似Array的下標(biāo)操作，索引號(hào)從0開(kāi)始：
var s = 'Hello, world!';
s[0]; // 'H'
s[6]; // ' '
s[7]; // 'w'
s[12]; // '!'
s[13]; // undefined 超出范圍的索引不會(huì)報(bào)錯(cuò)，但一律返回undefined
需要特別注意的是，字符串是不可變的，如果對(duì)字符串的某個(gè)索引賦值，不會(huì)有任何錯(cuò)誤，但是，也沒(méi)有任何效果：
var s = 'Test';
s[0] = 'X';
alert(s); // s仍然為'Test'
toUpperCase
toUpperCase()把一個(gè)字符串全部變?yōu)榇髮懀?/p>
var s = 'Hello';
s.toUpperCase(); // 返回'HELLO'
toLowerCase
toLowerCase()把一個(gè)字符串全部變?yōu)樾懀?/p>
var s = 'Hello';
var lower = s.toLowerCase(); // 返回'hello'并賦值給變量lower
lower; // 'hello'
indexOf
indexOf()會(huì)搜索指定字符串出現(xiàn)的位置：
var s = 'hello, world';
s.indexOf('world'); // 返回7
s.indexOf('World'); // 沒(méi)有找到指定的子串，返回-1
substring
substring()返回指定索引區(qū)間的子串：
var s = 'hello, world'
s.substring(0, 5); // 從索引0開(kāi)始到5（不包括5），返回'hello'
s.substring(7); // 從索引7開(kāi)始到結(jié)束，返回'world'
4.數(shù)組
JavaScript的Array可以包含任意數(shù)據(jù)類型，并通過(guò)索引來(lái)訪問(wèn)每個(gè)元素。
要取得Array的長(zhǎng)度，直接訪問(wèn)length屬性：
var arr = [1, 2, 3.14, 'Hello', null, true];
arr.length; // 6
請(qǐng)注意，直接給Array的length賦一個(gè)新的值會(huì)導(dǎo)致Array大小的變化：
var arr = [1, 2, 3];
arr.length; // 3
arr.length = 6;
arr; // arr變?yōu)閇1, 2, 3, undefined, undefined, undefined]
arr.length = 2;
arr; // arr變?yōu)閇1, 2]
Array可以通過(guò)索引把對(duì)應(yīng)的元素修改為新的值，因此，對(duì)Array的索引進(jìn)行賦值會(huì)直接修改這個(gè)Array：
var arr = ['A', 'B', 'C'];
arr[1] = 99;
arr; // arr現(xiàn)在變?yōu)閇'A', 99, 'C']
請(qǐng)注意，如果通過(guò)索引賦值時(shí)，索引超過(guò)了范圍，同樣會(huì)引起Array大小的變化：
var arr = [1, 2, 3];
arr[5] = 'x';
arr; // arr變?yōu)閇1, 2, 3, undefined, undefined, 'x']
大多數(shù)其他編程語(yǔ)言不允許直接改變數(shù)組的大小，越界訪問(wèn)索引會(huì)報(bào)錯(cuò)。然而，JavaScript的Array卻不會(huì)有任何錯(cuò)誤。在編寫代碼時(shí)，不建議直接修改Array的大小，訪問(wèn)索引時(shí)要確保索引不會(huì)越界。
indexOf
與String類似，Array也可以通過(guò)indexOf()來(lái)搜索一個(gè)指定的元素的位置：
var arr = [10, 20, '30', 'xyz'];
arr.indexOf(10); // 元素10的索引為0
arr.indexOf(20); // 元素20的索引為1
arr.indexOf(30); // 元素30沒(méi)有找到，返回-1
arr.indexOf('30'); // 元素'30'的索引為2
注意了，數(shù)字30和字符串'30'是不同的元素。
slice
slice()就是對(duì)應(yīng)String的substring()版本，它截取Array的部分元素，然后返回一個(gè)新的Array：
var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
arr.slice(0, 3); // 從索引0開(kāi)始，到索引3結(jié)束，但不包括索引3: ['A', 'B', 'C']
arr.slice(3); // 從索引3開(kāi)始到結(jié)束: ['D', 'E', 'F', 'G']
注意到slice()的起止參數(shù)包括開(kāi)始索引，不包括結(jié)束索引。
如果不給slice()傳遞任何參數(shù)，它就會(huì)從頭到尾截取所有元素。利用這一點(diǎn)，我們可以很容易地復(fù)制一個(gè)Array：
var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
var aCopy = arr.slice();
aCopy; // ['A', 'B', 'C', 'D', 'E', 'F', 'G']
aCopy === arr; // false
push和pop
push()向Array的末尾添加若干元素，pop()則把Array的最后一個(gè)元素刪除掉：
var arr = [1, 2];
arr.push('A', 'B'); // 返回Array新的長(zhǎng)度: 4
arr; // [1, 2, 'A', 'B']
arr.pop(); // pop()返回'B'
arr; // [1, 2, 'A']
arr.pop(); arr.pop(); arr.pop(); // 連續(xù)pop 3次
arr; // []
arr.pop(); // 空數(shù)組繼續(xù)pop不會(huì)報(bào)錯(cuò)，而是返回undefined
arr; // []
unshift和shift
如果要往Array的頭部添加若干元素，使用unshift()方法，shift()方法則把Array的第一個(gè)元素刪掉：
var arr = [1, 2];
arr.unshift('A', 'B'); // 返回Array新的長(zhǎng)度: 4
arr; // ['A', 'B', 1, 2]
arr.shift(); // 'A'
arr; // ['B', 1, 2]
arr.shift(); arr.shift(); arr.shift(); // 連續(xù)shift 3次
arr; // []
arr.shift(); // 空數(shù)組繼續(xù)shift不會(huì)報(bào)錯(cuò)，而是返回undefined
arr; // []
sort
sort()可以對(duì)當(dāng)前Array進(jìn)行排序，它會(huì)直接修改當(dāng)前Array的元素位置，直接調(diào)用時(shí)，按照默認(rèn)順序排序：
var arr = ['B', 'C', 'A'];
arr.sort();
arr; // ['A', 'B', 'C']
reverse
reverse()把整個(gè)Array的元素給掉個(gè)個(gè)，也就是反轉(zhuǎn)：
var arr = ['one', 'two', 'three'];
arr.reverse();
arr; // ['three', 'two', 'one']
splice
splice()方法是修改Array的“萬(wàn)能方法”，它可以從指定的索引開(kāi)始刪除若干元素，然后再?gòu)脑撐恢锰砑尤舾稍兀?/p>
var arr = ['Microsoft', 'Apple', 'Yahoo', 'AOL', 'Excite', 'Oracle'];
// 從索引2開(kāi)始刪除3個(gè)元素,然后再添加兩個(gè)元素:
arr.splice(2, 3, 'Google', 'Facebook'); // 返回刪除的元素 ['Yahoo', 'AOL', 'Excite']
arr; // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']
// 只刪除,不添加:
arr.splice(2, 2); // ['Google', 'Facebook']
arr; // ['Microsoft', 'Apple', 'Oracle']
// 只添加,不刪除:
arr.splice(2, 0, 'Google', 'Facebook'); // 返回[],因?yàn)闆](méi)有刪除任何元素
arr; // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']
concat
concat()方法把當(dāng)前的Array和另一個(gè)Array連接起來(lái)，并返回一個(gè)新的Array：
var arr = ['A', 'B', 'C'];
var added = arr.concat([1, 2, 3]);
added; // ['A', 'B', 'C', 1, 2, 3]
arr; // ['A', 'B', 'C']
請(qǐng)注意，concat()方法并沒(méi)有修改當(dāng)前Array，而是返回了一個(gè)新的Array。
實(shí)際上，concat()方法可以接收任意個(gè)元素和Array，并且自動(dòng)把Array拆開(kāi)，然后全部添加到新的Array里：
var arr = ['A', 'B', 'C'];
arr.concat(1, 2, [3, 4]); // ['A', 'B', 'C', 1, 2, 3, 4]
join
join()方法是一個(gè)非常實(shí)用的方法，它把當(dāng)前Array的每個(gè)元素都用指定的字符串連接起來(lái)，然后返回連接后的字符串：
var arr = ['A', 'B', 'C', 1, 2, 3];
arr.join('-'); // 'A-B-C-1-2-3'
如果Array的元素不是字符串，將自動(dòng)轉(zhuǎn)換為字符串后再連接。
多維數(shù)組
如果數(shù)組的某個(gè)元素又是一個(gè)Array，則可以形成多維數(shù)組，例如：
var arr = [[1, 2, 3], [400, 500, 600], '-'];
5.對(duì)象
JavaScript的對(duì)象是一種無(wú)序的集合數(shù)據(jù)類型，它由若干鍵值對(duì)組成。
JavaScript的對(duì)象用于描述現(xiàn)實(shí)世界中的某個(gè)對(duì)象。例如，為了描述“小明”這個(gè)淘氣的小朋友，我們可以用若干鍵值對(duì)來(lái)描述他：
var xiaoming = {
name: '小明',
birth: 1990,
school: 'No.1 Middle School',
height: 1.70,
weight: 65,
score: null
};
JavaScript用一個(gè){...}表示一個(gè)對(duì)象，鍵值對(duì)以xxx: xxx形式申明，用,隔開(kāi)。注意，最后一個(gè)鍵值對(duì)不需要在末尾加,。
上述對(duì)象申明了一個(gè)name屬性，值是'小明'，birth屬性，值是1990，以及其他一些屬性。最后，把這個(gè)對(duì)象賦值給變量xiaoming后，就可以通過(guò)變量xiaoming來(lái)獲取小明的屬性了：
xiaoming.name; // '小明'
xiaoming.birth; // 1990
訪問(wèn)屬性是通過(guò).操作符完成的，但這要求屬性名必須是一個(gè)有效的變量名。如果屬性名包含特殊字符，就必須用''括起來(lái)：
var xiaohong = {
name: '小紅',
'middle-school': 'No.1 Middle School'
};
xiaohong的屬性名middle-school不是一個(gè)有效的變量，就需要用''括起來(lái)。訪問(wèn)這個(gè)屬性也無(wú)法使用.操作符，必須用['xxx']來(lái)訪問(wèn)：
xiaohong['middle-school']; // 'No.1 Middle School'
xiaohong['name']; // '小紅'
xiaohong.name; // '小紅'
也可以用xiaohong['name']來(lái)訪問(wèn)xiaohong的name屬性，不過(guò)xiaohong.name的寫法更簡(jiǎn)潔。我們?cè)诰帉慗avaScript代碼的時(shí)候，屬性名盡量使用標(biāo)準(zhǔn)的變量名，這樣就可以直接通過(guò)object.prop的形式訪問(wèn)一個(gè)屬性了。
實(shí)際上JavaScript對(duì)象的所有屬性都是字符串，不過(guò)屬性對(duì)應(yīng)的值可以是任意數(shù)據(jù)類型。
如果訪問(wèn)一個(gè)不存在的屬性會(huì)返回什么呢？JavaScript規(guī)定，訪問(wèn)不存在的屬性不報(bào)錯(cuò)，而是返回undefined：
'use strict';
var xiaoming = {
name: '小明'
};
console.log(xiaoming.name);
console.log(xiaoming.age); // undefined
由于JavaScript的對(duì)象是動(dòng)態(tài)類型，你可以自由地給一個(gè)對(duì)象添加或刪除屬性：
var xiaoming = {
name: '小明'
};
xiaoming.age; // undefined
xiaoming.age = 18; // 新增一個(gè)age屬性
xiaoming.age; // 18
delete xiaoming.age; // 刪除age屬性
xiaoming.age; // undefined
delete xiaoming['name']; // 刪除name屬性
xiaoming.name; // undefined
delete xiaoming.school; // 刪除一個(gè)不存在的school屬性也不會(huì)報(bào)錯(cuò)
如果我們要檢測(cè)xiaoming是否擁有某一屬性，可以用in操作符：
var xiaoming = {
name: '小明',
birth: 1990,
school: 'No.1 Middle School',
height: 1.70,
weight: 65,
score: null
};
'name' in xiaoming; // true
'grade' in xiaoming; // false
不過(guò)要小心，如果in判斷一個(gè)屬性存在，這個(gè)屬性不一定是xiaoming的，它可能是xiaoming繼承得到的：
'toString' in xiaoming; // true
因?yàn)?code>toString定義在object對(duì)象中，而所有對(duì)象最終都會(huì)在原型鏈上指向object，所以xiaoming也擁有toString屬性。
要判斷一個(gè)屬性是否是xiaoming自身?yè)碛械模皇抢^承得到的，可以用hasOwnProperty()方法：
var xiaoming = {
name: '小明'
};
xiaoming.hasOwnProperty('name'); // true
xiaoming.hasOwnProperty('toString'); // false
6.條件判斷
JavaScript使用if () { ... } else { ... }來(lái)進(jìn)行條件判斷。例如，根據(jù)年齡顯示不同內(nèi)容，可以用if語(yǔ)句實(shí)現(xiàn)如下：
var age = 20;
if (age >= 18) { // 如果age >= 18為true，則執(zhí)行if語(yǔ)句塊
alert('adult');
} else { // 否則執(zhí)行else語(yǔ)句塊
alert('teenager');
}
多行條件判斷
如果還要更細(xì)致地判斷條件，可以使用多個(gè)if...else...的組合：
var age = 3;
if (age >= 18) {
alert('adult');
} else if (age >= 6) {
alert('teenager');
} else {
alert('kid');
}
上述多個(gè)if...else...的組合實(shí)際上相當(dāng)于兩層if...else...：
var age = 3;
if (age >= 18) {
alert('adult');
} else {
if (age >= 6) {
alert('teenager');
} else {
alert('kid');
}
}
但是我們通常把else if連寫在一起，來(lái)增加可讀性。這里的else略掉了{}是沒(méi)有問(wèn)題的，因?yàn)樗话粋€(gè)if語(yǔ)句。注意最后一個(gè)單獨(dú)的else不要略掉{}。
請(qǐng)注意，if...else...語(yǔ)句的執(zhí)行特點(diǎn)是二選一，在多個(gè)if...else...語(yǔ)句中，如果某個(gè)條件成立，則后續(xù)就不再繼續(xù)判斷了。
JavaScript把null、undefined、0、NaN和空字符串''視為false，其他值一概視為true
7.循環(huán)
JavaScript的循環(huán)有兩種，一種是for循環(huán)，通過(guò)初始條件、結(jié)束條件和遞增條件來(lái)循環(huán)執(zhí)行語(yǔ)句塊：
var x = 0;
var i;
for (i=1; i<=10000; i++) {
x = x + i;
}
x; // 50005000
讓我們來(lái)分析一下for循環(huán)的控制條件：
- i=1 這是初始條件，將變量i置為1；
- i<=10000 這是判斷條件，滿足時(shí)就繼續(xù)循環(huán)，不滿足就退出循環(huán)；
- i++ 這是每次循環(huán)后的遞增條件，由于每次循環(huán)后變量i都會(huì)加1，因此它終將在若干次循環(huán)后不滿足判斷條件
i<=10000而退出循環(huán)。
for循環(huán)最常用的地方是利用索引來(lái)遍歷數(shù)組：
var arr = ['Apple', 'Google', 'Microsoft'];
var i, x;
for (i=0; i<arr.length; i++) {
x = arr[i];
console.log(x);
}
for循環(huán)的3個(gè)條件都是可以省略的，如果沒(méi)有退出循環(huán)的判斷條件，就必須使用break語(yǔ)句退出循環(huán)，否則就是死循環(huán)：
var x = 0;
for (;;) { // 將無(wú)限循環(huán)下去
if (x > 100) {
break; // 通過(guò)if判斷來(lái)退出循環(huán)
}
x ++;
}
for ... in
for循環(huán)的一個(gè)變體是for ... in循環(huán)，它可以把一個(gè)對(duì)象的所有屬性依次循環(huán)出來(lái)：
var o = {
name: 'Jack',
age: 20,
city: 'Beijing'
};
for (var key in o) {
console.log(key); // 'name', 'age', 'city'
}
要過(guò)濾掉對(duì)象繼承的屬性，用hasOwnProperty()來(lái)實(shí)現(xiàn)：
var o = {
name: 'Jack',
age: 20,
city: 'Beijing'
};
for (var key in o) {
if (o.hasOwnProperty(key)) {
console.log(key); // 'name', 'age', 'city'
}
}
由于Array也是對(duì)象，而它的每個(gè)元素的索引被視為對(duì)象的屬性，因此，for ... in循環(huán)可以直接循環(huán)出Array的索引：
var a = ['A', 'B', 'C'];
for (var i in a) {
console.log(i); // '0', '1', '2'
console.log(a[i]); // 'A', 'B', 'C'
}
請(qǐng)注意，for ... in對(duì)Array的循環(huán)得到的是String而不是Number。
do ... while
最后一種循環(huán)是do { ... } while()循環(huán)，它和while循環(huán)的唯一區(qū)別在于，不是在每次循環(huán)開(kāi)始的時(shí)候判斷條件，而是在每次循環(huán)完成的時(shí)候判斷條件：
var n = 0;
do {
n = n + 1;
} while (n < 100);
n; // 100
用do { ... } while()循環(huán)要小心，循環(huán)體會(huì)至少執(zhí)行1次，而for和while循環(huán)則可能一次都不執(zhí)行。
8.Map和Set
Map
Map是一組鍵值對(duì)的結(jié)構(gòu)，具有極快的查找速度。
舉個(gè)例子，假設(shè)要根據(jù)同學(xué)的名字查找對(duì)應(yīng)的成績(jī)，如果用Array實(shí)現(xiàn)，需要兩個(gè)Array：
var names = ['Michael', 'Bob', 'Tracy'];
var scores = [95, 75, 85];
給定一個(gè)名字，要查找對(duì)應(yīng)的成績(jī)，就先要在names中找到對(duì)應(yīng)的位置，再?gòu)膕cores取出對(duì)應(yīng)的成績(jī)，Array越長(zhǎng)，耗時(shí)越長(zhǎng)。
如果用Map實(shí)現(xiàn)，只需要一個(gè)“名字”-“成績(jī)”的對(duì)照表，直接根據(jù)名字查找成績(jī)，無(wú)論這個(gè)表有多大，查找速度都不會(huì)變慢。用JavaScript寫一個(gè)Map如下：
var m = new Map([['Michael', 95], ['Bob', 75], ['Tracy', 85]]);
m.get('Michael'); // 95
初始化Map需要一個(gè)二維數(shù)組，或者直接初始化一個(gè)空Map。Map具有以下方法：
var m = new Map(); // 空Map
m.set('Adam', 67); // 添加新的key-value
m.set('Bob', 59);
m.has('Adam'); // 是否存在key 'Adam': true
m.get('Adam'); // 67
m.delete('Adam'); // 刪除key 'Adam'
m.get('Adam'); // undefined
由于一個(gè)key只能對(duì)應(yīng)一個(gè)value，所以，多次對(duì)一個(gè)key放入value，后面的值會(huì)把前面的值沖掉：
var m = new Map();
m.set('Adam', 67);
m.set('Adam', 88);
m.get('Adam'); // 88
Set
Set和Map類似，也是一組key的集合，但不存儲(chǔ)value。由于key不能重復(fù)，所以，在Set中，沒(méi)有重復(fù)的key。
要?jiǎng)?chuàng)建一個(gè)Set，需要提供一個(gè)Array作為輸入，或者直接創(chuàng)建一個(gè)空Set：
var s1 = new Set(); // 空Set
var s2 = new Set([1, 2, 3]); // 含1, 2, 3
重復(fù)元素在Set中自動(dòng)被過(guò)濾：
var s = new Set([1, 2, 3, 3, '3']);
s; // Set {1, 2, 3, "3"}
注意數(shù)字3和字符串'3'是不同的元素。
通過(guò)add(key)方法可以添加元素到Set中，可以重復(fù)添加，但不會(huì)有效果：
s.add(4);
s; // Set {1, 2, 3, 4}
s.add(4);
s; // 仍然是 Set {1, 2, 3, 4}
通過(guò)delete(key)方法可以刪除元素：
var s = new Set([1, 2, 3]);
s; // Set {1, 2, 3}
s.delete(3);
s; // Set {1, 2}
9.iterable
遍歷Array可以采用下標(biāo)循環(huán)，遍歷Map和Set就無(wú)法使用下標(biāo)。為了統(tǒng)一集合類型，ES6標(biāo)準(zhǔn)引入了新的iterable類型，Array、Map和Set都屬于iterable類型。
具有iterable類型的集合可以通過(guò)新的for ... of循環(huán)來(lái)遍歷。
用for ... of循環(huán)遍歷集合，用法如下：
var a = ['A', 'B', 'C'];
var s = new Set(['A', 'B', 'C']);
var m = new Map([[1, 'x'], [2, 'y'], [3, 'z']]);
for (var x of a) { // 遍歷Array
console.log(x);
}
for (var x of s) { // 遍歷Set
console.log(x);
}
for (var x of m) { // 遍歷Map
console.log(x[0] + '=' + x[1]);
}
你可能會(huì)有疑問(wèn)，for ... of循環(huán)和for ... in循環(huán)有何區(qū)別？
for ... in循環(huán)由于歷史遺留問(wèn)題，它遍歷的實(shí)際上是對(duì)象的屬性名稱。一個(gè)Array數(shù)組實(shí)際上也是一個(gè)對(duì)象，它的每個(gè)元素的索引被視為一個(gè)屬性。
當(dāng)我們手動(dòng)給Array對(duì)象添加了額外的屬性后，for ... in循環(huán)將帶來(lái)意想不到的意外效果：
var a = ['A', 'B', 'C'];
a.name = 'Hello';
for (var x in a) {
console.log(x); // '0', '1', '2', 'name'
}
for ... in循環(huán)將把name包括在內(nèi)，但Array的length屬性卻不包括在內(nèi)。
for ... of循環(huán)則完全修復(fù)了這些問(wèn)題，它只循環(huán)集合本身的元素：
var a = ['A', 'B', 'C'];
a.name = 'Hello';
for (var x of a) {
console.log(x); // 'A', 'B', 'C'
}
這就是為什么要引入新的for ... of循環(huán)。
然而，更好的方式是直接使用iterable內(nèi)置的forEach方法，它接收一個(gè)函數(shù)，每次迭代就自動(dòng)回調(diào)該函數(shù)。以Array為例：
'use strict';
var a = ['A', 'B', 'C'];
a.forEach(function (element, index, array) {
// element: 指向當(dāng)前元素的值
// index: 指向當(dāng)前索引
// array: 指向Array對(duì)象本身
console.log(element + ', index = ' + index);
});//A, index = 0 B, index = 1 C, index = 2
Set與Array類似，但Set沒(méi)有索引，因此回調(diào)函數(shù)的前兩個(gè)參數(shù)都是元素本身：
var s = new Set(['A', 'B', 'C']);
s.forEach(function (element, sameElement, set) {
console.log(element);
});
Map的回調(diào)函數(shù)參數(shù)依次為value、key和map本身：
var m = new Map([[1, 'x'], [2, 'y'], [3, 'z']]);
m.forEach(function (value, key, map) {
console.log(value);
});
如果對(duì)某些參數(shù)不感興趣，由于JavaScript的函數(shù)調(diào)用不要求參數(shù)必須一致，因此可以忽略它們。例如，只需要獲得Array的element：
var a = ['A', 'B', 'C'];
a.forEach(function (element) {
console.log(element);
});
