1. 程式人生 > >js Function 函式

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

只需要一行程式碼。