JavaScript 基礎知識

1. 變數及其命名規范

在 JavaScript 中，使用等號 = 對變數進行賦值，可以把任意資料型別賦值給變數，同一個變數可以反復賦值，而且可以是不同型別的變數，但是要注意只能用 var 申明一次，

這種變數本身型別不固定的語言稱之為動態語言，與之對應的是靜態語言，靜態語言在定義變數時必須指定變數型別，如果賦值的時候型別不匹配，就會報錯，

變數的命名：

• 變數名只能由字母、數字、下劃線、$ 組成，且開頭不能是數字，
• 變數區分大小寫，
• 變數名要符合兩大法則之一：

1. 小駝峰法則：變數首字母小寫，之后每個單詞的首字母大寫（常用）；
2. 匈牙利命名法：變數所有字母都小寫，單詞之間用下劃線分割，

var helloWorld;  // 小駝峰命名法
var hello_world; // 匈牙利命名法

strict 模式

ECMA 在后續規范中推出了 strict 模式，在 strict 模式下運行的 JavaScript 代碼，強制通過 var 申明變數，未使用 var 申明變數就使用的，將導致運行錯誤，使用方法如下：

'use strict';  // 在 JavaScript 代碼的第一行寫上

2. 6種變數資料型別

2.1. Undefined：未定義

在 JavaScript 中，使用 var 宣告變數，但沒有進行初始化賦值時，結果為 Undefined，如果變數沒有宣告直接使用，則會報錯，不屬于 Undefined，

Undefined 僅僅在判斷函式引數是否傳遞的情況下有用，

<script type="text/javascript">
    var a;
    console.log(a); // 使用 var 宣告變數 a，但未賦值，a 為 Undefined
    console.log(b); // 沒有宣告直接使用的變數 b，會報錯
</script>

2.2. NULL：空參考

NULL 在 JavaScript 中是一種特殊的資料型別，表示一種空的參考，一個“空”的值，也就是這個變數中什么都沒有，它和 0 以及空字串 '' 不同，0 是一個數值，'' 表示長度為 0 的字串，而 NULL 表示“空”，同時，NULL 作為關鍵字不區分大小寫，形如 “NULL”、“Null”、“null” 均為合法資料型別，

2.3. Boolean：布爾型別

Boolean 值是一種非常常用的資料型別，表示真或者假，可選值只有兩個：true 或 false，

var a = true;
var b = 1>2;
console.log(a);  // true
console.log(b);  // false

2.4. Number：數值型別

在 JavaScript 中，沒有區分整數型別和小數型別，二十統一用數值型別代替，例如整數和小數型別都輸入 Number 型別，

Infinity 表示無限大，當數值超過了 JavaScript 的 Number 所能表示的最大值時，就表示為 Infinity，

var a = 11;
var b = 11.2;

2.5. String：字串型別

使用雙引號 "" 或單引號 '' 包裹的內容，被稱為字串，兩種字串沒有任何區別，且可以互相包含，

2.6. Object：物件型別

Object 是一種物件型別，在 JavaScript 中有一句話“萬物皆物件”，包括函式、陣列、自定義物件等都屬于物件型別，

3. JavaScript 中的變數函式

3.1. Number() 函式：將變數轉為數值型別

1. 字串型別轉數值

Number("111");     // 字串為純數值字串，會轉  為對應的數字，轉換之后結果為 111
Number("");        // 字串為空字串時，會轉為0
Number("111a");    // 字串中包換其他非數字字符時，不能轉換，轉換結果為 NaN

2. 布爾 Boolean 型別轉數值

Number(true); // true 轉換為1
Number(false);// false 轉換為0

3. Null 與 Undefined 轉數值

Number(null);      // Null 轉換為0，將空參考 null 轉換為 0
Number(undefined); // Undefined 轉換為 NaN，

4. Object 型別轉數值

先呼叫 ValueOf() 方法，確定函式是否有回傳值，再根據上述各種情況判斷，

3.2. isNaN()：檢測變數是否為 NaN

// 1. 純數字字串，檢測結果為 false
isNaN("111"); // 先用 Number() 轉換為數值型別的 111，所以 isNaN 檢測結果為 false
// 2.空字串，檢測結果為 false
isNaN("");    // 先用 Number() 轉換為數值型別的 0，所以 isNaN 檢測結果為 false
// 3.包含其他字符，檢測結果為 true
isNaN("la");  // 先用 Number() 轉為 NaN，所以 isNaN 檢測結果為 true
// 4.布爾型別，檢測結果為 false
isNaN(false); // 先用 Number() 轉為數值型別的 0，所以 isNaN 檢測結果為 false

3.3. parseInt()：將字串轉為整型

parseInt() 函式的作用是將字串型別轉為整數數值型別，即 parseInt() 函式可決議一個字串，并回傳一個整數，

// 1.純數字字串
document.write(parseInt("123"));        // 轉換為 123
document.write(parseInt("123.11"));     // 轉換為 123
// 2.包含其他字符的字串：截取第一個非數值字符前的數值部分進行輸出
document.write(parseInt("123.11a"));    // 轉化為小數時，會直接抹掉小數點，轉換為 123
document.write(parseInt("a123"));       // 轉換為 NaN

3.4. parseFloat()：將字串轉換為浮點型

parseFloat() 函式的作用是將字串轉換為小數數值型別，使用方式同 ParseInt() 類似，唯一不用的是，在轉化整數字串時，保留整數，但是當轉化包含小數點的字串時，保留小數點，

document.write(parseFloat("123"));    // 轉化為 123
document.write(parseFloat("123a11")); // 轉化為 123
document.write(parseFloat("a123"));   // 轉化為 NaN
document.write(parseFloat("a123.12"));// 轉化為 123.12
document.write(parseFloat("123.12a"));// 轉化為 NaN

Notice：parseInt() 和 parseFloat() 函式只能轉換 String 型別，對 Boolen、null、Undefined 進行轉換結果均為 NaN，

3.5. typeof()：變數型別檢測

typeof() 是 JavaScript 中非常常用的一個函式，它的主要作用是用來檢測一個變數的資料型別，傳入一個變數，回傳變數所屬的資料型別，一般分為以下幾種情況：

1. 未定義：資料型別為Undefined，
2. 數值：資料型別為 Number，
3. 字串：資料型別為 String，
4. True/False：資料型別為 Boolean，
5. Null/物件：資料型別為 Object，
6. 函式：資料型別為 function，

為了方便使用，JavaScript 在語法上為 typeof 函式提供了兩中常用寫法，分別是函式寫法和指令寫法：

var a;
// 1.函式寫法：需要保留 ()，變數通過()傳入，基本語法如下：
typeof(a);     // 函式呼叫法師需要將變數通過函式后面的()傳入
// 2.指令寫法：可以省略 (),直接將變數緊跟 typeof，基本語法如下：
typeof a;      // 指令呼叫方式可以省略()，直接將變數緊跟 typeof

4. 運算子

4.1. 相等比較運算子

1.== 和 === 的區別以及代碼展示

1. == 會自動轉換資料型別再比較，很多時候會得到意想不到的結果；
2. === 不會轉換資料型別，如果資料型別不一致，回傳 false，如果一致，再比較，

false == 0;    // true
false === 0;   // false

2.NaN 特殊的 Number 比較

NaN 這個特殊的 Number 與所有其他的值都不相等，包括他自己：

NaN === NaN;   // false

唯一能夠判斷 NaN 的方法是通過 isNaN() 函式：

isNaN(NaN);    // true

3.浮點數的相等比較

1/2 === (1-2/3);  // false

這是由于浮點數在運算程序中會產生誤差，因為計算機無法精確表示無限回圈小數，要比較兩個浮點數是否相等，只能計算它們之差的絕對值，看是否小于某個閾值：

Math.abs(1/3 - (1-2/3)) < 0.0000001;  // true

4.2. 逗號運算子

var a = 2;
var b = 0;
var c;
c = (++a, a *=2, b = a*5);
document.write(c); // c = 30，整個逗號運算式的值是最后一個運算式的值

5. 陣列

陣列是一組按順序排列的集合，結合中的每個值成為元素，JavaScript 的陣列可以包括任意資料型別：

// 陣列的元素可以通過索引來訪問
var arr = [1, 2, 3.14, 'Hello', null, true];
// 上述陣列包含六個元素，陣列用 `[]` 表示，元素之間用 `,` 隔開，

arr.length;  // 獲取陣列的長度，結果為 6
arr[0]; // 回傳索引為0的元素，即1
arr[5]; // 回傳索引為5的元素，即true
arr[6]; // 索引超出了范圍，回傳undefined

// 另一種創建陣列的方法是通過 `Array()` 函式實作：
var arr1 = new Array(1, 2, 3);  // 創建了陣列 [1, 2, 3]

如果直接給 Array 的 length 賦一個新的值會導致 Array 大小發生變化：

var arr = [1, 2, 3];
arr.length;        // 3
arr.length = 6;    // arr變為[1, 2, 3, undefined, undefined, undefined]
arr.length 2;      // arr變為[1, 2]

Array 可以通過索引把對應的元素修改為新的值，因此，對 Array 的索引進行賦值會直接修改這個 Array：

ar arr = ['A', 'B', 'C'];
arr[1] = 99;            // arr現在變為['A', 99, 'C']
// 如果通過索引賦值時，索引超過了范圍，同樣會引起 Array 大小的變化：
arr[5] = 'x';           // arr變為[1, 2, 3, undefined, undefined, 'x']

Notice： 大多數其他編程語言不允許直接改變陣列的大小，越界訪問索引會報錯，然而，JavaScript 的 Array 卻不會有任何錯誤，在撰寫代碼時，不建議直接修改 Array 的大小，訪問索引時要確保索引不會越界，

5.1. indexOf()

與 String 類似，Array 也可以通過 indexOf() 來搜索一個指定的元素的位置：

var arr = [10, 20, '30', 'xyz'];
arr.indexOf(10);                 // 元素10的索引為0
arr.indexOf(20);                 // 元素20的索引為1
arr.indexOf(30);                 // 元素30沒有找到，回傳-1
arr.indexOf('30');               // 元素'30'的索引為2

5.2. slice()

slice() 就是對應 String 的 substring() 版本，它截取 Array 的部分元素，然后回傳一個新的 Array：

var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
document.write(table.slice(0, 3)); // 從索引0開始，到索引3結束，但不包括索引3: ['A', 'B', 'C']
document.write(table.slice(3));    // 從索引3開始到結束: ['D', 'E', 'F', 'G']

注意到 slice() 的起止引數包括開始索引，不包括結束索引，
如果不給 slice() 傳遞任何引數，它就會從頭到尾截取所有元素，利用這一點，我們可以很容易地復制一個 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

5.3. push() 和 pop()

push() 向 Array 的末尾添加若干元素，pop() 則把Array 的最后一個元素洗掉掉：

var arr = [1, 2];
arr.push('A', 'B'); // 回傳Array新的長度: 4
arr; // [1, 2, 'A', 'B']
arr.pop(); // pop()回傳'B'
arr; // [1, 2, 'A']
arr.pop(); arr.pop(); arr.pop(); // 連續pop 3次
arr; // []
arr.pop(); // 空陣列繼續pop不會報錯，而是回傳undefined
arr; // []

5.4. unshift() 和 shift()

如果要往 Array 的頭部添加若干元素，使用 unshift() 方法，shift() 方法則把 Array 的第一個元素刪掉：

var arr = [1, 2];
arr.unshift('A', 'B'); // 回傳Array新的長度: 4
arr; // ['A', 'B', 1, 2]
arr.shift(); // 'A'
arr; // ['B', 1, 2]
arr.shift(); arr.shift(); arr.shift(); // 連續shift 3次
arr; // []
arr.shift(); // 空陣列繼續shift不會報錯，而是回傳undefined
arr; // []

5.5. sort()

sort() 可以對當前 Array 進行排序，它會直接修改當前 Array 的元素位置，直接呼叫時，按照默認順序排序：

var arr = ['B', 'C', 'A'];
arr.sort(); // arr = ['A', 'B', 'C']

5.6. reverse()

// 反轉陣列
var arr = ['one', 'two', 'three'];
arr.reverse(); // arr = ['three', 'two', 'one']

5.7. splice()

splice() 方法是修改 Array 的“萬能方法”，它可以從指定的索引開始洗掉若干元素，然后再從該位置添加若干元素：

var arr = ['Microsoft', 'Apple', 'Yahoo', 'AOL', 'Excite', 'Oracle'];
// 從索引2開始洗掉3個元素,然后再添加兩個元素:
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'); // 回傳[],因為沒有洗掉任何元素
arr; // ['Microsoft', 'Apple', 'Google', 'Facebook', 'Oracle']

5.8. concat()

concat() 方法把當前的 Array 和另一個 Array 連接起來，并回傳一個新的 Array：

var arr = ['A', 'B', 'C'];
var added = arr.concat([1, 2, 3]);
added; // ['A', 'B', 'C', 1, 2, 3]
arr; // ['A', 'B', 'C']

請注意，concat() 方法并沒有修改當前 Array ，而是回傳了一個新的 Array，

實際上，concat() 方法可以接收任意個元素和 Array，并且自動把 Array 拆開，然后全部添加到新的 Array 里：

var arr = ['A', 'B', 'C'];
arr.concat(1, 2, [3, 4]); // ['A', 'B', 'C', 1, 2, 3, 4]

5.9. join()

join() 方法是一個非常實用的方法，它把當前 Array 的每個元素都用指定的字串連接起來，然后回傳連接后的字串：

var arr = ['A', 'B', 'C', 1, 2, 3];
arr.join('-'); // 'A-B-C-1-2-3'
// 如果Array的元素不是字串，將自動轉換為字串后再連接，

5.10. 多維陣列

如果陣列的某個元素又是一個 Array，則可以形成多維陣列，例如：

var arr = [[1, 2, 3], [400, 500, 600], '-'];
// 上述Array包含3個元素，其中頭兩個元素本身也是Array，

6. 物件

JavaScript 的物件是一組由鍵-值組成的無序集合，例如：

var person = {
    name: 'Bob',
    age: 20,
    tags: ['js', 'web', 'mobile'],
    city: 'Beijing',
    hasCar: true,
    zipcode: null
};

JavaScript 物件的鍵都是字串型別，值可以是任意資料型別，上述 person 物件一共定義了 6 個鍵值對，其中每個鍵又稱為物件的屬性，例如，person 的 name 屬性為 'Bob' ，zipcode 屬性為 null，

訪問屬性是通過 . 運算子完成的，但這要求屬性名必須是一個有效的變數名，如果屬性名包含特殊字符，就必須用 '' 括起來：

var xiaohong = {
    name: '小紅',
    'middle-school': 'No.1 Middle School'
};
// xiaohong的屬性名middle-school不是一個有效的變數，就需要用''括起來，訪問這個屬性也無法使用.運算子，必須用['xxx']來訪問：
xiaohong['middle-school']; // 'No.1 Middle School'
xiaohong['name'];          // '小紅'
xiaohong.name;             // '小紅'

實際上 JavaScript 物件的所有屬性都是字串，不過屬性對應的值可以是任意資料型別，如果訪問一個不存在的屬性會回傳 undefined，

由于 JavaScript 的物件是動態型別，可以自由地給一個物件添加或洗掉屬性：

var xiaoming = {
    name: '小明'
};
xiaoming.age;              // undefined
xiaoming.age = 18;         // 新增一個age屬性
xiaoming.age;              // 18
delete xiaoming.age;       // 洗掉age屬性
xiaoming.age;              // undefined
delete xiaoming['name'];   // 洗掉name屬性
xiaoming.name;             // undefined
delete xiaoming.school;    // 洗掉一個不存在的school屬性也不會報錯

如果我們要檢測 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

不過要小心，如果 in 判斷一個屬性存在，這個屬性不一定是 xiaoming 的，它可能是 xiaoming 繼承得到的：

'toString' in xiaoming; // true

因為 toString 定義在 object 物件中，而所有物件最終都會在原型鏈上指向 object，所以 xiaoming 也擁有 toString 屬性，

要判斷一個屬性是否是 xiaoming 自身擁有的，而不是繼承得到的，可以用 hasOwnProperty() 方法：

var xiaoming = {
    name: '小明'
};
xiaoming.hasOwnProperty('name');     // true
xiaoming.hasOwnProperty('toString'); // false

7. 字串

JavaScript 的字串就是用 '' 或 "" 括起來的字符表示，如果 ' 本身也是一個字符，那就可以用 "" 括起來，比如 “I’m OK” 包含的字符是I，’，m，空格，O，K 這 6 個字符，如果字串內部既包含 ' 又包含 " 怎么辦？可以用轉義字符 \ 來標識：

'I\'m \"OK\"!';  // 表示的字串內容是：I'm "OK"!

轉義字符 \ 可以轉義很多字符，比如 \n 表示換行，\t 表示制表符，字符 \ 本身也要轉義，所以 \\ 表示的字符就是 \，

// ASCII 字符可以以 `\x##` 形式的十六進制表示，例如：
'\x41';          // 完全等同于 'A'

// 還可以用\u####表示一個Unicode字符：
'\u4e2d\u6587';  // 完全等同于 '中文'

多行字串

由于多行字串用 \n 寫起來比較費事，所以最新的ES6標準新增了一種多行字串的表示方法，用反引號 ... 表示：

`這是一個
多行
字串`;

模板字串

要把多個字串連接起來，可以用 + 號連接：

var name = '小明';
var age = 20;
var message = '你好, ' + name + ', 你今年' + age + '歲了!';
alert(message);

// 如果有很多變數需要連接，用 + 號就比較麻煩，ES6 新增了一種模板字串，
// 表示方法和上面的多行字串一樣，但是它會自動替換字串中的變數：
var name = '小明';
var age = 20;
var message = `你好, ${name}, 你今年${age}歲了!`;
alert(message);

操作字串

var s = 'Hello, world!';
s.length; // 13
// 要獲取字串某個指定位置的字符，使用類似Array的下標操作，
// 索引號從0開始：
s[0];     // 'H'
s[6];     // ' '
s[7];     // 'w'
s[12];    // '!'
s[13];    // undefined 超出范圍的索引不會報錯，但一律回傳undefined

**Notice：**字串是不可變的，如果對字串的某個索引賦值，不會有任何錯誤，但是，也沒有任何效果：

var s = 'Test';
s[0] = 'X';
alert(s); // s仍然為'Test'

8. Map 和 Set

JavaScript 的默認物件表示方式 {} 可以視為其他語言中的 Map 或 Dictionary 的資料結構，即一組鍵值對，但是 JavaScript 的物件有個小問題，就是鍵必須是字串，但實際上 Number 或者其他資料型別作為鍵也是非常合理的，為了解決這個問題，最新的 ES6 規范引入了新的資料型別 Map，

8.1. Map

Map 是一組鍵值對的結構，具有極快的查找速度，假設要根據同學的名字查找對應的成績，用 Map 實作，只需要一個“名字”-“成績”的對照表，直接根據名字查找成績，無論這個表有多大，查找速度都不會變慢：

var m = new Map([['Michael', 95], ['Bob', 75], ['Tracy', 85]]);
m.get('Michael'); // 95

初始化 Map 需要一個二維陣列，或者直接初始化一個空 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

由于一個 key 只能對應一個 value，所以，多次對一個 key 放入 value，后面的值會把前面的值沖掉：

var map = new Map();
map.set('Jason', 88);
map.set('Jason', 78);
map.get('Jason');     // 78

8.2. Set

Set 和 Map 類似，也是一組 key 的集合，但不存盤 value，由于 key 不能重復，所以，在 Set 中，沒有重復的 key，要創建一個 Set，需要提供一個 Array 作為輸入，或者直接創建一個空 Set：

var s1 = new Set();             // 空Set
var s2 = new Set([1, 2, 3]);    // 含1, 2, 3

// 重復元素在Set中自動被過濾：
var s = new Set([1, 2, 3, 3, '3']); // s = Set {1, 2, 3, "3"}

// 通過 add(key) 方法可以添加元素到 Set 中，可以重復添加，但不會有效果：
s.add(4); // s = Set {1, 2, 3, 4}
s.add(4); // 仍然是 s = Set {1, 2, 3, 4}

// 通過 delete(key) 方法可以洗掉元素：
var s = new Set([1, 2, 3]); // s = Set {1, 2, 3}
s.delete(3);                // s = Set {1, 2}

9. iterable

遍歷 Array 可以采用下標回圈，遍歷 Map 和 Set 就無法使用下標，為了統一集合型別，ES6 標準引入了新的 iterable 型別，Array、Map 和 Set 都屬于 iterable 型別，具有 iterable 型別的集合可以通過新的 for ... of 回圈來遍歷，

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]);
}

9.1. for...in 回圈

for 回圈的一個變體是 for ... in 回圈，它可以把一個物件的所有屬性依次回圈出來：

var o = {
    name: 'Jack',
    age: 20,
    city: 'Beijing'
};
for (var key in o) {
    console.log(key); // 'name', 'age', 'city'
}

// 要過濾掉物件繼承的屬性，用 hasOwnProperty() 來實作：
for (var key in o) {
    if (o.hasOwnProperty(key)) {
        console.log(key); // 'name', 'age', 'city'
    }
}

由于 Array 也是物件，而它的每個元素的索引被視為物件的屬性，因此，for ... in 回圈可以直接回圈出 Array 的索引：

var a = ['A', 'B', 'C'];
for (var i in a) {
    console.log(i);     // '0', '1', '2'
    console.log(a[i]);  // 'A', 'B', 'C'
}
// 注意，for ... in 對 Arra y的回圈得到的是 String 而不是 Number，

for ... in 回圈由于歷史遺留問題，它遍歷的實際上是物件的屬性名稱，一個 Array 陣列實際上也是一個物件，它的每個元素的索引被視為一個屬性，當我們手動給 Array 物件添加了額外的屬性后，for ... in 回圈將帶來意想不到的意外效果：

var a = ['A', 'B', 'C'];
a.name = 'Hello';
for (var x in a) {
    console.log(x); // '0', '1', '2', 'name'
}

9.2. for ... of 回圈

for ... in 回圈將把 name 包括在內，但 Array 的 length 屬性卻不包括在內，for ... of 回圈則完全修復了這些問題，它只回圈集合本身的元素：

var a = ['A', 'B', 'C'];
a.name = 'Hello';
for (var x of a) {
    console.log(x); // 'A', 'B', 'C'
}

然而，更好的方式是直接使用 iterable 內置的 forEach 方法，它接收一個函式，每次迭代就自動回呼該函式，以 Array 為例：

'use strict';
var a = ['A', 'B', 'C'];
a.forEach(function (element, index, array) {
    // element: 指向當前元素的值
    // index: 指向當前索引
    // array: 指向Array物件本身
    console.log(element + ', index = ' + index);
});

Set 與 Array 類似，但 Set 沒有索引，因此回呼函式的前兩個引數都是元素本身：

var s = new Set(['A', 'B', 'C']);
s.forEach(function (element, sameElement, set) {
    console.log(element);
});

Map 的回呼函式引數依次為 value、key 和 map 本身：

var m = new Map([[1, 'x'], [2, 'y'], [3, 'z']]);
m.forEach(function (value, key, map) {
    console.log(value);
});

// 如果對某些引數不感興趣，由于 JavaScript 的函式呼叫不要求引數必須一致，
// 因此可以忽略它們，例如，只需要獲得 Array 的 element：
var a = ['A', 'B', 'C'];
a.forEach(function (element) {
    console.log(element);
});

10. JavaScript 中的輸入與輸出

1. document.write() 檔案中列印輸出

var name = 'Jason';
document.write(name + '<br />'); // <br /> 表示輸出換行

2. alert() 瀏覽器彈窗輸出

alert('彈窗警告內容'); // 帶有一個“確定”按鈕

3. prompt() 瀏覽器彈窗輸入

// 彈窗默認接受的輸入的內容，為字串 String 格式
var name = prompt('請輸入您的姓名', 'Jason'); // 第二個欄位是可選欄位
document.write(name);  // 輸出在彈窗中輸入的名字，如果點取消，則輸出 null

4. confirm() 瀏覽器彈窗確認

var hello = confirm('你好嗎？');
if(hello) {
    alert('我很好！');
}else {
    alert('馬馬虎虎吧！');
}

5. console.log() 瀏覽器控制臺輸出