函數
var abs = function (x) {
if (x >= 0) {
return x;
} else {
return -x;
}
};
函數體內部的語句在執行時，一旦執行到return時，函數就執行完畢，並將結果返回。因此，函數內部通過條件判斷和循環可以實現非常復雜的邏輯。
在這種方式下，function (x) { ... }是一個匿名函數，它沒有函數名。但是，這個匿名函數賦值給了變量abs，所以，通過變量abs就可以調用該函數
如果沒有return語句，函數執行完畢后也會返回結果，只是結果為undefined。
要避免收到undefined，可以對參數進行檢查：
function abs(x) {
if (typeof x !== 'number') {
throw 'Not a number';
}
if (x >= 0) {
return x;
} else {
return -x;
}
}
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判斷，然后重新調整參數並賦值。
rest
由於JavaScript函數允許接收任意個參數，於是我們就不得不用arguments來獲取所有參數：
function foo(a, b) {
var i, rest = [];
if (arguments.length > 2) {
for (i = 2; i<arguments.length; i++) {
rest.push(arguments[i]);
}
}
console.log('a = ' + a);
console.log('b = ' + b);
console.log(rest);
}
為了獲取除了已定義參數a、b之外的參數，我們不得不用arguments，並且循環要從索引2開始以便排除前兩個參數，這種寫法很別扭，只是為了獲得額外的rest參數，有沒有更好的方法？
ES6標准引入了rest參數，上面的函數可以改寫為：
function foo(a, b, ...rest) {
console.log('a = ' + a);
console.log('b = ' + b);
console.log(rest);
}
foo(1, 2, 3, 4, 5);
// 結果:
// a = 1
// b = 2
// Array [ 3, 4, 5 ]
foo(1);
// 結果:
// a = 1
// b = undefined
// Array []
rest參數只能寫在最后，前面用...標識，從運行結果可知，傳入的參數先綁定a、b，多余的參數以數組形式交給變量rest，所以，不再需要arguments我們就獲取了全部參數。
如果傳入的參數連正常定義的參數都沒填滿，也不要緊，rest參數會接收一個空數組（注意不是undefined）。
小心你的return語句
前面我們講到了JavaScript引擎有一個在行末自動添加分號的機制，這可能讓你栽到return語句的一個大坑：
function foo() {
return { name: 'foo' };
}
foo(); // { name: 'foo' }
如果把return語句拆成兩行：
function foo() {
return
{ name: 'foo' };
}
foo(); // undefined
要小心了，由於JavaScript引擎在行末自動添加分號的機制，上面的代碼實際上變成了：
function foo() {
return; // 自動添加了分號，相當於return undefined;
{ name: 'foo' }; // 這行語句已經沒法執行到了
}
所以正確的多行寫法是：
function foo() {
return { // 這里不會自動加分號，因為{表示語句尚未結束
name: 'foo'
};
}
變量提升
JavaScript的函數定義有個特點，它會先掃描整個函數體的語句，把所有申明的變量“提升”到函數頂部：
'use strict';
function foo() {
var x = 'Hello, ' + y;
alert(x);
var y = 'Bob';
}
foo();
雖然是strict模式，但語句var x = 'Hello, ' + y;並不報錯，原因是變量y在稍后申明了。但是alert顯示Hello, undefined，說明變量y的值為undefined。這正是因為JavaScript引擎自動提升了變量y的聲明，但不會提升變量y的賦值。
對於上述foo()函數，JavaScript引擎看到的代碼相當於：
function foo() {
var y; // 提升變量y的申明
var x = 'Hello, ' + y;
alert(x);
y = 'Bob';
}
由於JavaScript的這一怪異的“特性”，我們在函數內部定義變量時，請嚴格遵守“在函數內部首先申明所有變量”這一規則。最常見的做法是用一個var申明函數內部用到的所有變量：
function foo() {
var
x = 1, // x初始化為1
y = x + 1, // y初始化為2
z, i; // z和i為undefined
// 其他語句:
for (i=0; i<100; i++) {
...
}
}
高階函數
高階函數英文叫Higher-order function。那么什么是高階函數？
JavaScript的函數其實都指向某個變量。既然變量可以指向函數，函數的參數能接收變量，那么一個函數就可以接收另一個函數作為參數，這種函數就稱之為高階函數。
一個最簡單的高階函數：
function add(x, y, f) {
return f(x) + f(y);
}
當我們調用add(-5, 6, Math.abs)時，參數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;
return 11;
用代碼驗證一下：
add(-5, 6, Math.abs); // 11
編寫高階函數，就是讓函數的參數能夠接收別的函數。
舉例說明，比如我們有一個函數f(x)=x2，要把這個函數作用在一個數組[1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map實現如下：
由於map()方法定義在JavaScript的Array中，我們調用Array的map()方法，傳入我們自己的函數，就得到了一個新的Array作為結果：
function pow(x) {
return x * x;
}
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
arr.map(pow); // [1, 4, 9, 16, 25, 36, 49, 64, 81]
map()傳入的參數是pow，即函數對象本身。
你可能會想，不需要map()，寫一個循環，也可以計算出結果：
var f = function (x) {
return x * x;
};
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var result = [];
for (var i=0; i<arr.length; i++) {
result.push(f(arr[i]));
}
的確可以，但是，從上面的循環代碼，我們無法一眼看明白“把f(x)作用在Array的每一個元素並把結果生成一個新的Array”。
所以，map()作為高階函數，事實上它把運算規則抽象了，因此，我們不但可以計算簡單的f(x)=x2，還可以計算任意復雜的函數，比如，把Array的所有數字轉為字符串：
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
arr.map(String); // ['1', '2', '3', '4', '5', '6', '7', '8', '9']
只需要一行代碼。