函数包含一组语句，用来指定对象的行为，其代码可以用来重复使用。
一般来说，编程就是将一组需求分解成一组函数和数据结构的技能。
概览：函数对象 | 函数字面量 | 调用 | 方法调用模式 | 函数调用模式 | 构造函数调用模式 | 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 // 1 myObj.increment(2); myObj.value // 3
通过 this 可取得它们所属对象的上下文的方法称为公共方法，代码里 increment 方法就是公共方法。
4.5. 函数调用模式
当一个函数并非一个对象的属性时，那么它就被当作一个函数来调用的。
// 4.5 code 3 var sum = add(3, 4); // 7
以此模式调用函数时，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 // 6
将外部函数的 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 // 7 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); // 30
这种模式不是特别有用。在第六章，我们会给数组添加一个相似的方法来达到同样的效果。
因为语言的一个设计错误，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 (2.6).integer(); // 2
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); // 24
遗憾的是，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. 闭包
（待续...）