第四章 函数(JavaScript:语言精粹)

函数包含一组语句，用来指定对象的行为，其代码可以用来重复使用。

 

一般来说，编程就是将一组需求分解成一组函数和数据结构的技能。

 

概览：函数对象 | 函数字面量 | 调用 | 方法调用模式 | 函数调用模式 | 构造函数调用模式 | Apply 调用模式 | 参数 | 返回 | 异常 | 给基本类型扩展功能 | 递归 | 作用域 | 闭包

 

---

 

4.1. 函数对象

 

JavaScript 中的函数就是对象。

 

对象字面量产生的对象连接到 Object.prototype，函数对象连接到 Function.prototype(该原型对象本身连接到 Object.prototype)。

 

函数的与众不同之处在于它们能被调用。

 

---

 

4.2. 函数字面量

 

函数对象通过函数字面量来创建。

 

// 4.2 code 1
var add = function (a, b) {
    return a + b;
};

 

函数字面量分为 4 个部分：第 1 部分，是保留字 function；第 2 部分，是函数名，它可以省略，省略函数名的函数称为匿名函数；第 3 部分是包含在圆括号中的一组参数；第 4 部分是包围在花括号中的一组语句，是函数的主体，在函数被调用时执行。

 

函数也可以被定义在其他函数中。一个内部函数除了可以访问自己的参数和变量，同时也能自由访问把它嵌套在其中的父函数的参数和变量。这被称为闭包。

 

4.3. 调用

 

除了函数声明时定义的形式参数，每个函数还接收两个附加的参数：this 和 arguments。this 的值取决于调用的模式。

 

在 JavaScript 中一共有四种调用模式：方法调用模式、函数调用模式、构造器调用模式、apply 调用模式。

 

---

 

4.4. 方法调用模式

 

当一个函数被保存为对象的一个属性时，我们称它为一个方法。当一个方法被调用时，this 被绑定到该对象。

 

// 4.4 code 2
var myObj = {
    value: 0,
    increment: function (inc) {
        this.value += typeof inc === 'number' ? inc : 1;
    }
};

myObj.increment();
myObj.value        //
myObj.increment(2);
myObj.value        //

 

通过 this 可取得它们所属对象的上下文的方法称为公共方法，代码里 increment 方法就是公共方法。

 

---

 

4.5. 函数调用模式

 

当一个函数并非一个对象的属性时，那么它就被当作一个函数来调用的。

 

// 4.5 code 3
var sum = add(3, 4); //

 

以此模式调用函数时，this 被绑定到全局变量，也就是 window 对象。

 

// 4.5 code 4
myObj.double = function () {

    var helper = function () {
        this  // Oops, window Object!
    }
}

 

↑这是一个语言设计上的错误，内部函数 helper 的 this 指 window，根本不是外部函数 double 指的 myObj 对象。可以这样解决：

 

// 4.5 code 5
myObj.double = function () {
    var that = this;

    var helper = function () {
        that.value = add(that.value, that.value);
    }

    helper();   // Function Invocation
}

myObj.double(); // Method Invocation
myObj.value     //

 

将外部函数的 this(也就是 myObj 对象)，赋值给变量 that，那么在内部函数里就可以使用 myObj 对象了。

 

---

 

4.6. 构造器调用模式

 

JavaScript 是一门基于原型继承的语言，这意味着对象可以直接从其他对象继承属性，通过 prototype 属性。这偏离了当前编程的主流风格（基于类的编程），并没有被广泛理解。

 

一个函数，如果创建的目的就是希望给 new 前缀来调用，那么它就被称为构造器函数。

 

// 4.6 code 6
var Quo = function (str) {
    this.status = str;
}

Quo.prototype.get_status = function () {
    return this.status;
}

var quo1 = new Quo('online');
quo1.get_status() // "online"

 

你可能会看到，当一个函数当成构造器函数使用时，函数名遵循大写约定（比如是 Quo，而不是 quo）。

 

我不推荐使用这种形式的构造器函数。下一章会有更好的替代方式。

 

---

 

4.7. Apply 调用模式

 

JavaScript 的函数可以拥有方法。

 

Apply 调用模式要用到 Function.prototype.apply(thisArg, argArray)方法，第一个参数是绑定给 this 的值，第二个参数是一个参数数组。

 

// 4.7 code 7
var arr = [3, 4];
var sum = add.apply(null, arr);
sum    //

var statusObj = {
    status: 'offline'
};
var status = Quo.prototype.get_status.apply(statusObj);
status // "offline"

 

结合上面的代码，我们对 apply 方法的两个参数，再做些说明，以便加深我们的印象：

1. add.apply(null, array)：null 表示函数 add 里的 this 值为 null，array 数组里提供了调用 add 函数时可以传递给它的两个参数，这里分别是 3 和 4，所以 sum 的值是 7。

2. Quo.prototype.get_status.apply(statusObj)：因为我们将 statusObj 绑定到了 get_status 方法的 this 上，相当于可以在 statusObj 上调用 get_status 方法。虽然 statusObj 没有 get_status 方法，也并没有继承 Quo.prototype。第二个参数没赋值，因为调用 get_status 方法不需要参数的。

 

---

 

4.8. 参数

当函数被调用时，会得到一个“免费”配送的参数，arguments。可以通过 arguments 来访问函数被调用时，传递给函数的参数列表。这使得编写一个无需指定参数个数的函数成为可能：

 

// 4.8 code 8
var sum = function () {
    var i, sum = 0; // this "sum" is different from the outer "sum"
    for (i = 0; i < arguments.length; i+= 1) {
        sum += arguments[i];
    }
    return sum;
}

sum(2, 4, 6, 8, 10); //

 

这种模式不是特别有用。在第六章，我们会给数组添加一个相似的方法来达到同样的效果。

 

因为语言的一个设计错误，arguments 并不是一个真正的数组，只是“类似数组”的对象。它有一个 length 属性，但没有任何数组的方法。

 

---

 

4.9. 返回

 

return 语句可以使函数提前返回。当 return 被执行时，函数立即返回而不再执行余下的语句。

 

一个函数总是会返回一个值。如果没有返回一个值，则返回 undefined。

 

---

 

4.10. 异常 

 

不出错是不可能的，你需要让你的程序在出错时抛出一个异常。

 

// 4.10 code 9
var add = function (a, b) {
    if (typeof a !== 'number' || typeof b !== 'number') {
        throw {
            name: 'TypeError',
            message: '相加需要数字，OK？'
        };
    }
    return a + b;
}

 

如果输入的两个参数不都是数字，则会进入 throw 区域的逻辑，抛出一个 exception 对象，这个对象包含表示异常类型的 name 属性和一个描述性的 message 属性。

 

该 exception 对象将被传递到一个 try 语句的 catch 从句：

 

// 4.10 code 10
var try_it = function () {
    try {
        add('Give me Five!');
    } catch (ex) {
        document.writeln(ex.name + '：' +　ex.message); // "TypeError：相加需要数字，OK？"
    }
}

try_it();

 

try 用来捕获异常，catch 用来处理异常。上面代码向文档里输出了异常类型的 name 和 message(“TypeError：add need numbers”)。

 

---

 

4.11. 给基本类型扩充功能

 

JavaScript 语言允许给基本类型扩充功能。就像第 3 章中通过给 Object.prototype 添加方法，那么该方法对所有对象都有用，比如：函数、数组、字符串、数字、正则表达式和布尔值。

 

我们举个例子，给 Function.prototype 添加一个 method 方法，这个方法所有的函数都可以使用。

 

// 4.11 code 11
Function.prototype.method = function (name, func) {
    this.prototype[name] = func;
    return this;
}

 

JavaScript 本身提供的取整方法有些丑陋，我们可以通过给 Number.prototype 添加一个方法 integer 来进行改善。

 

// 4.11 code 12
Number.method('integer', function () {
    return Math[this < 0 ? 'ceil' : 'floor'](this);
});

(-2.4).integer(); // -2
(-2.6).integer(); // -2
(2.4).integer();  //
(2.6).integer();  //

 

JavaScript 缺少一个去除字符串首尾空白的方法，这也很好弥补。

 

// 4.11 code 13
String.method('trim', function () {
    return this.replace(/^\s+|\s+$/g, '');
});

' so~ hot! '.trim(); // "so~ hot!"

 

我们的 trim 方法使用了正则表达式。我们会在第 7 章学习到更多的正则表达式的内容。

 

为了保险，我们判断只在没有这个方法的前提下，去添加这个方法：

 

// 4.11 code 14
Function.prototype.method = function (name, func) {
    if (!this.prototype[name]) {
        this.prototype[name] = func;
    }
    return this;
}

 

因为基本类型的原型是共有结构，防止在用类库时，与类库同名方法混淆。

 

---

 

4.12. 递归

 

递归函数就是直接或间接调用自己的一种函数。

 

递归函数的一个实际应用，就是“汉诺塔”了。

 

“汉诺塔”是一个著名的益智游戏。在塔上有三根柱子和一套直径各不相同的空心圆盘。开始时，源柱子上有从小到到大堆叠在一起的空心圆盘，我们每次移动一个圆盘到另一根柱子上，最后的结果是所有的渲染按照顺序堆在了目标柱子上，但过程中不允许出现大圆盘放在小圆盘上。这里有一个代码的实现：

 

// 4.12 code 15
var hanoi = function (disc, src, aux, dst) {
    if (disc > 0) {
        hanoi(disc - 1, src, dst, aux);
        document.writeln(disc + ' 从 ' + src + ' 转移到了 ' + dst + '<br>');
        hanoi(disc - 1, aux, src, dst);
    }
}

hanoi(3, 'SRC', 'AUX', 'DST');

 

当圆盘数为 3 的时候，会打印出这样的结果：

 

1 从 SRC 转移到了 DST
2 从 SRC 转移到了 AUX
1 从 DST 转移到了 AUX
3 从 SRC 转移到了 DST
1 从 AUX 转移到了 SRC
2 从 AUX 转移到了 DST
1 从 SRC 转移到了 DST

 

hanoi 函数把一堆圆盘从一根柱子上整体转移到另一根柱子上，中间必须使用辅助柱子。从函数中可以看到，我们把它分解成了三个子问题：

1. 首先，它移动一对圆盘中较小的圆盘到辅助柱子上；

2. 然后，将较大圆盘放到目标柱子上；

3. 最后，将较小圆盘也放到目标柱子上。

 

为了更好的理解，我们可以假设只有两个圆盘，那么移动的顺序就是就是上面的三步。

 

 

（图片说明：这只猩猩在玩四个圆盘的汉诺塔，很认真:）

 

三个圆盘可以想象成这样：上面两个圆盘是一个整体，下面是一个，那么又是两个了，那么首先就要把上面一部分移动到辅助柱子上……

 

递归函数还可以非常高效的地操作树形结构，比如浏览器的文档对象模型(DOM)。每次递归调用时，处理指定树的一小段。

 

// 4.12 code 16
var walk_the_DOM = function walk(node, func) {
    func(node);
    node = node.firstChild;
    while (node) {
        walk(node, func);
        node = node.nextSibling;
    }
} 

 

// 4.12 code 17
var getElementsByAttribute = function (att, value) {
    var result = [];

    walk_the_DOM(document.body, function (node) {
        var actual = node.nodeType === 1 && node.getAttribute(att);
        if (typeof actual === 'string' && (actual === value || typeof value !== 'string')) {
            result.push(node);
        }
    });

    return result;
}

有一种函数，会在最后执行递归调用的语句。称为尾递归，是一种特殊的递归函数。像下面这样的：

 

// 4.12 code 18
var factorial = function factorial(i, a) {
    a = a || 1;
    if (i < 2) {
        return a;
    }
    return factorial(i - 1, a * i);
}

factorial(4); //

 

遗憾的是，JavaScript 没有提供对于尾递归方面的优化。深度递归的函数可能会因为堆栈溢出而运行失败。

 

---

 

4.13. 作用域

 

// 4.13 code 19
var foo = function () {
    var a = 3, b = 5;

    var bar = function () {
        var b = 7, c =  11;

        // now. a = 3, b = 7, c =  11

        a += b + c;

        // now. a = 21, b = 7, c =  11
    }

    // now. a = 3, b = 5, c is undefined

    bar();

    // now. a = 21, b = 5
}

 

JavaScript 缺少块级作用域。因为这个，有一种情况要这样处理：在函数体的顶部声明函数中可能会用到的所有变量。

 

JavaScript 有函数作用域。那意味着，定义在函数内部的参数和变量对函数外部是不可见的，而在一个函数内部任何位置定义的参数和变量，在该函数内部任何位置都是可见的。

 

---

 

4.14. 闭包

 

 

 

（待续...）