js Function 函數

函數

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']

只須要一行代碼。