一.函數
抽象
抽象是數學中非常常見的概念。舉個例子：
計算數列的和，比如：1 + 2 + 3 + ... + 100，寫起來十分不方便，于是數學家發明了求和符號∑，可以把1 + 2 + 3 + ... + 100記作：
100
∑n
n=1
這種抽象記法非常強大，因為我們看到 ∑ 就可以理解成求和，而不是還原成低級的加法運算。
而且，這種抽象記法是可擴展的，比如：
100
∑(n2+1)
n=1
還原成加法運算就變成了：
(1 x 1 + 1) + (2 x 2 + 1) + (3 x 3 + 1) + ... + (100 x 100 + 1)
可見，借助抽象，我們才能不關心底層的具體計算過程，而直接在更高的層次上思考問題。
寫計算機程序也是一樣，函數就是最基本的一種代碼抽象的方式。
二.函數的定義和調用
1.定義函數
在JavaScript中，定義函數的方式如下：
function abs(x){
if(x>=0){
return x;
}else{
return -x;
}
}
上述abs()函數的定義如下：
- function 指出這是一個函數定義
- abs 是函數的名稱
- (x)括號內列出函數的參數，多個參數以 , 分隔;
- {....}之間的代碼是函數體，可以包括若干語句，甚至可以沒有任何語句
請注意，函數體內部的語句在執行時，一旦執行到return時，函數就執行完畢，并將結果返回。因此，函數內部通過條件判斷和循環可以實現非常復雜的邏輯。
如果沒有return語句，函數執行完畢后也會返回結果，只是結果為undefined。
2.調用函數
調用函數時，按順序傳入參數即可：
abs(10); // 返回10
abs(-9); // 返回9
由于JavaScript允許傳入任意個參數而不影響調用，因此傳入的參數比定義的參數多也沒有問題，雖然函數內部并不需要這些參數：
abs(10, 'blablabla'); // 返回10
abs(-9, 'haha', 'hehe', null); // 返回9
傳入的參數比定義的少也沒有問題：
abs(); // 返回NaN
// 此時abs(x)函數的參數x將收到undefined，計算結果為NaN。
要避免收到undefined，可以對參數進行檢查：
function abs(x) {
if (typeof x !== 'number') {
throw 'Not a number';
}
if (x >= 0) {
return x;
} else {
return -x;
}
}
3.arguments
JavaScript還有一個免費贈送的關鍵字arguments，它只在函數內部起作用，并且永遠指向當前函數的調用者傳入的所有參數。arguments類似Array但它不是一個Array：
function foo(x) {
alert(x); // 10
for (var i=0; i<arguments.length; i++) {
alert(arguments[i]); // 10, 20, 30
}
}
foo(10, 20, 30);
利用arguments，你可以獲得調用者傳入的所有參數。也就是說，即使函數不定義任何參數，還是可以拿到參數的值：
function abs() {
if (arguments.length === 0) {
return 0;
}
var x = arguments[0];
return x >= 0 ? x : -x;
}
abs(); // 0
abs(10); // 10
abs(-9); // 9
實際上arguments最常用于判斷傳入參數的個數。你可能會看到這樣的寫法：
// foo(a[, b], c)
// 接收2~3個參數，b是可選參數，如果只傳2個參數，b默認為null：
function foo(a, b, c) {
if (arguments.length === 2) {
// 實際拿到的參數是a和b，c為undefined
c = b; // 把b賦給c
b = null; // b變為默認值
}
// ...
}
要把中間的參數b變為“可選”參數，就只能通過arguments判斷，然后重新調整參數并賦值。
三.變量作用域
在JavaScript中，用var申明的變量實際上是有作用域的。
如果一個變量在函數體內部申明，則該變量的作用域為整個函數體，在函數體外不可引用該變量：
'use strict';
function foo() {
var x = 1;
x = x + 1;
}
x = x + 2; // ReferenceError! 無法在函數體外引用變量x
如果兩個不同的函數各自申明了同一個變量，那么該變量只在各自的函數體內起作用。換句話說，不同函數內部的同名變量互相獨立，互不影響：
'use strict';
function foo() {
var x = 1;
x = x + 1;
}
function bar() {
var x = 'A';
x = x + 'B';
}
由于JavaScript的函數可以嵌套，此時，內部函數可以訪問外部函數定義的變量，反過來則不行：
'use strict';
function foo() {
var x = 1;
function bar() {
var y = x + 1; // bar可以訪問foo的變量x!
}
var z = y + 1; // ReferenceError! foo不可以訪問bar的變量y!
}
如果內部函數和外部函數的變量名重名怎么辦？
'use strict';
function foo() {
var x = 1;
function bar() {
var x = 'A';
alert('x in bar() = ' + x); // 'A'
}
alert('x in foo() = ' + x); // 1
bar();
}
這說明JavaScript的函數在查找變量時從自身函數定義開始，從“內”向“外”查找。如果內部函數定義了與外部函數重名的變量，則內部函數的變量將“屏蔽”外部函數的變量。
四.方法
在一個對象中綁定函數，稱為這個對象的方法。
在JavaScript中，對象的定義是這樣的：
var xiaoming = {
name: 'xiaoming',
birth: 1990
};
但是，我們給xiaoming綁定一個函數，就可以做更多事情，例如，寫個age()方法，返回xiaoming的年齡：
var xiaoming = {
name: 'xiaoming',
birth: 1990,
age: function(){
var y = new Date().getFullYear();
return y - this.birth;
}
} ;
xiaoming.age; //function xiaoming.age()
xiaoming.age(); //今年調用是27，明年調用就變成26了
在一個方法內部，this是一個特殊變量，它始終指向當前對象，也就是xiaoming這個變量。所以，this.birth可以拿到xiaoming的birth屬性。
function getAge(){
var y = new Date().getFullYear();
return y -this.birth;
}
var xiaoming = {
name: 'xiaoming',
birth: 1990,
age: getAge
};
xiaoming.age(); //27,正常結果
getAge(); //NaN
單獨調用函數getAge()怎么返回了NaN？請注意，我們已經進入到了JavaScript的一個大坑里。
JavaScript的函數內部如果調用了this，那么這個this到底指向誰？
答案是，視情況而定！
如果以對象的方法形式調用，比如xiaoming.age()，該函數的this指向被調用的對象，也就是xiaoming，這是符合我們預期的。
如果單獨調用函數，比如getAge()，此時，該函數的this指向全局對象，也就是window。
坑爹啊！
更坑爹的是，如果這么寫：
var fn = xiaoming.age; // 先拿到xiaoming的age函數
fn(); // NaN
也是不行的！要保證this指向正確，必須用obj.xxx()的形式調用！
由于這是一個巨大的設計錯誤，要想糾正可沒那么簡單。ECMA決定，在strict模式下讓函數的this指向undefined，因此，在strict模式下，你會得到一個錯誤：
'use strict';
var xiaoming = {
name: '小明',
birth: 1990,
age: function () {
var y = new Date().getFullYear();
return y - this.birth;
}
};
var fn = xiaoming.age;
fn(); // Uncaught TypeError: Cannot read property 'birth' of undefined
這個決定只是讓錯誤及時暴露出來，并沒有解決this應該指向的正確位置。
有些時候，喜歡重構的你把方法重構了一下：
'use strict';
var xiaoming = {
name: '小明',
birth: 1990,
age: function () {
function getAgeFromBirth() {
var y = new Date().getFullYear();
return y - this.birth;
}
return getAgeFromBirth();
}
};
xiaoming.age(); // Uncaught TypeError: Cannot read property 'birth' of undefined
結果又報錯了！原因是this指針只在age方法的函數內指向xiaoming，在函數內部定義的函數，this又指向undefined了！（在非strict模式下，它重新指向全局對象window！）
修復的辦法也不是沒有，我們用一個that變量首先捕獲this：
'use strict';
var xiaoming = {
name: '小明',
birth: 1990,
age: function () {
var that = this; // 在方法內部一開始就捕獲this
function getAgeFromBirth() {
var y = new Date().getFullYear();
return y - that.birth; // 用that而不是this
}
return getAgeFromBirth();
}
};
xiaoming.age(); // 25
用var that = this;，你就可以放心地在方法內部定義其他函數，而不是把所有語句都堆到一個方法中。
五.高階函數
JavaScript的函數其實都指向某個變量。既然變量可以指向函數，函數的參數能接收變量，那么一個函數就可以接收另一個函數作為參數，這種函數就可以接收另一個函數作為參數，這種函數稱為高階函數。
一個最簡單的高階函數
function add(x,y,f){
return f(x) + f(y);
}
當我們調用add(-5,6,Math.ads)時，參數x,y和f分別接收-5，6和函數Math.abs，根據函數定義，我們可以推導計算過程為：
x = -5;
y = 6;
f = Math.abs;
f(x) + f(y) ==> Math.abs(-5) + Math.abs(6) ==> 11'
編寫高階函數，就是讓函數的參數能夠接收別的函數
六.閉包（擇日再看）
七.標準對象
在JavaScript的世界里，一切都是對象。
但是某些對象還是和其他對象不太一樣。為了區分對象的類型，我們用typeof操作符獲取對象類型，它總是返回一個字符串：
typeof 123; // 'number'
typeof NaN; // 'number'
typeof 'str'; // 'string'
typeof true; // 'boolean'
typeof undefined; // 'undefined'
typeof Math.abs; // 'function'
typeof null; // 'object'
typeof []; // 'object'
typeof {}; // 'object'
可見，number、string、boolean、function和undefined有別于其他類型。特別注意null的類型是object，Array的類型也是object，如果我們用typeof將無法區分出null、Array和通常意義上的object——{}。
八.Date
在JavaScript中，Date對象用來表示日期和時間
要獲取系統當前時間，用：
var now = new Date();
now; // Wed Jun 24 2015 19:49:22 GMT+0800 (CST)
now.getFullYear(); // 2015, 年份
now.getMonth(); // 5, 月份，注意月份范圍是0~11，5表示六月
now.getDate(); // 24, 表示24號
now.getDay(); // 3, 表示星期三
now.getHours(); // 19, 24小時制
now.getMinutes(); // 49, 分鐘
now.getSeconds(); // 22, 秒
now.getMilliseconds(); // 875, 毫秒數
now.getTime(); // 1435146562875, 以number形式表示的時間戳
注意，當前時間是瀏覽器從本機操作系統獲取的時間，所以不一定準確，因為用戶可以把當前時間設定為任何值。
如果要創建一個指定日期和時間的Date對象，可以用：
var d = new Date(2015, 5, 19, 20, 15, 30, 123);
d; // Fri Jun 19 2015 20:15:30 GMT+0800 (CST)
你可能觀察到了一個非常非常坑爹的地方，就是JavaScript的月份范圍用整數表示是0~11，0表示一月，1表示二月……，所以要表示6月，我們傳入的是5！這絕對是JavaScript的設計者當時腦抽了一下，但是現在要修復已經不可能了。
第二種創建一個指定日期和時間的方法是解析一個符合ISO 8601格式的字符串：
var d = Date.parse('2015-06-24T19:49:22.875+08:00');
d; // 1435146562875
但它返回的不是Date對象，而是一個時間戳。不過有時間戳就可以很容易地把它轉換為一個Date：
var d = new Date(1435146562875);
d; // Wed Jun 24 2015 19:49:22 GMT+0800 (CST)
九.RegExp
所以我們判斷一個字符串是否是合法的Email的方法是：
創建一個匹配Email的正則表達式；
用該正則表達式去匹配用戶的輸入來判斷是否合法。
因為正則表達式也是用字符串表示的，所以，我們要首先了解如何用字符來描述字符。
在正則表達式中，如果直接給出字符，就是精確匹配。用\d可以匹配一個數字，\w可以匹配一個字母或數字，所以：
- '00\d' 可以匹配 '007',但無法匹配'00A';
- '\d\d\d' 可以匹配 '010';
- '\w\w' 可以匹配 'js';
- . 可以匹配任何字符， 'js.'可以匹配 'jsp' 、'jss' 、 'js!'
要匹配變長的字符，在正則表達式中，用*表示任意個字符(包括0個)，用+表示至少一個字符，用？表示0個或1個字符，用{n}表示n個字符，用{n,m}表示n~m個字符：
來看個復雜的例子： \d{3}\s+\d{3,8} 從左到右解讀一下：
1.\d{3} 表示匹配3個數字，例如'010';
- \s 可以匹配一個空格(也包括Tab等空白符)，所以\s+ 表示有至少一個空格
- \d{3,8} 表示3-8個數字，例如 '1234567'
綜合起來，上面的正則表達式可以匹配以任意個空格隔開的帶區號的電話號碼。
進階
要做到更精確地匹配，可以用[]表示范圍，比如：
- [0-9a-zA-Z_] 可以匹配一個數字、字母或者下劃線；
- [0-9a-ZA-Z-]+可以匹配至少由一個數字、字母或者下劃線組成的字符串，比如'a100','0_z','js2015'等等；
- [a-zA-Z_$][0-9a-zA-Z_$]*可以匹配由字母或下劃線、$開頭，后接任意個由一個數字、字母或者下劃線、$組成的字符串，也就是JavaScript允許的變量名；
- [a-zA-Z_$][0-9a-zA-Z_$]{0, 19}更精確地限制了變量的長度是1-20個字符（前面1個字符+后面最多19個字符）。
十.Json
JSON的字符集必須是UTF-8，表示多語言就沒有問題了。為了統一解析，JSON的字符串規定必須用雙引號""，Object的鍵也必須用雙引號""。
var xiaoming = {
name: '小明',
age: 14,
gender: true,
heightL 1.65,
grade: null,
'middle-school' : 'one middle school',
skills: ['JavaScript','Java','Python','Liap']
};
JSON.stringify(xiaoming);
// '{"name":"小明","age":14,"gender":true,"height":1.65,"grade":null,"middle-school":"\"W3C\" Middle School","skills":["JavaScript","Java","Python","Lisp"]}'
要輸出得好看一些，可以加上參數，按縮進輸出：
JSON.stringify(xiaoming, null, ' ');
結果：
{
"name": "小明",
"age": 14,
"gender": true,
"height": 1.65,
"grade": null,
"middle-school": "\"W3C\" Middle School",
"skills": [
"JavaScript",
"Java",
"Python",
"Lisp"
]
}
第二個參數用于控制如何篩選對象的鍵值，如果我們只想輸出指定的屬性，可以傳入Array：
JSON.stringify(xiaoming, ['name', 'skills'], ' ');
結果
{
"name": "小明",
"skills": [
"JavaScript",
"Java",
"Python",
"Lisp"
]
}
還可以傳入一個函數，這樣對象的每個鍵值對都會被函數先處理：
function convert(key, value) {
if (typeof value === 'string') {
return value.toUpperCase();
}
return value;
}
JSON.stringify(xiaoming, convert, ' ');
上面的代碼把所有屬性值都變成大寫：
{
"name": "小明",
"age": 14,
"gender": true,
"height": 1.65,
"grade": null,
"middle-school": "\"W3C\" MIDDLE SCHOOL",
"skills": [
"JAVASCRIPT",
"JAVA",
"PYTHON",
"LISP"
]
}
如果我們還想要精確控制如何序列化小明，可以給xiaoming定義一個toJSON()的方法，直接返回JSON應該序列化的數據：
var xiaoming = {
name: '小明',
age: 14,
gender: true,
height: 1.65,
grade: null,
'middle-school': '\"W3C\" Middle School',
skills: ['JavaScript', 'Java', 'Python', 'Lisp'],
toJSON: function () {
return { // 只輸出name和age，并且改變了key：
'Name': this.name,
'Age': this.age
};
}
};
JSON.stringify(xiaoming); // '{"Name":"小明","Age":14}'
反序列化
拿到一個JSON格式的字符串，我們直接用JSON.parse()把它變成一個JavaScript對象：
JSON.parse('[1,2,3,true]'); // [1, 2, 3, true]
JSON.parse('{"name":"小明","age":14}'); // Object {name: '小明', age: 14}
JSON.parse('true'); // true
JSON.parse('123.45'); // 123.45
JSON.parse()還可以接收一個函數，用來轉換解析出的屬性：
JSON.parse('{"name":"小明","age":14}', function (key, value) {
// 把number * 2:
if (key === 'name') {
return value + '同學';
}
return value;
}); // Object {name: '小明同學', age: 14}
