第四章 函数 Functions （二）
参数 arguments
arguments数组： 函数能够经由历程此参数接见一切它被挪用时通报给它的参数列表，包含哪些没有被分配给函数声明时定义的情势参数的过剩参数。
类似数组”(array-like)”的对象。arguments具有一个length属性，没有任何数组要领。
返回 return
return被实行，函数马上返回而不再实行余下的语句
- 一个函数老是会返回一个值，没有指定返回值，则返回 undefined
- 运用 new 挪用函数，且返回值不是一个对象，则返回this (该新对象)
非常 Exceptions
非常是滋扰递次的平常流程的不寻常（但并不是完全是出人意料的）变乱
try {
if(false) {
throw {
name:"TypeError",
message:"number is required"
}
}
}catch(e) {
document.write(e.name + ": "+e.message)
}
throw 语句中缀函数的运转。对象被通报到catch 从句中被捕捉。
扩大范例的功用
经由历程给Function.prototype 增添要领，来使得该要领对一切函数可用：
Function.prototype.method = function(name,func) {
this.prototype[name] = func;
return this;
}如许在函数，数组，字符串，数字，正则表达式和布尔值等基础范例的组织函数上增加要领时，就能够省去prototype 这几个字符。使得对应的一切变量都实用改要领
为Number范例加上一个取整要领
Number.method('integer',function(){
return Math[this<0?'ceil':'floor'](this);
});为String加上一个去除首尾空缺的要领
String.method("trim",function(){
return this.replace(/^\s+|\s+$/g,'');
})与类库一同混用是，在肯定没有该要领时才增加它
// 相符前提时才增添要领
Function.prototype.method = function(name,func) {
if(!this.prototype[name]) {
this.prototype[name] = func;
}
return this;
}递归
直接或许间接地挪用本身的一种函数，它把一个题目分解为一组类似的子题目
典范的递归题目汉诺塔。塔上有3根柱子（1,2,3）和一套子直径各不相同的空心圆盘。
最先盘子从小到大的递次堆叠在1号柱子上，目的是要经由2号柱子悉数移动到3号柱子上，中心不许可较大的盘放在较小的盘上;
分解成子题目：
- 将1号柱子上的从上到下的n-1个盘应用3号柱子移动到2号柱子上。
- 将1号柱子上最下面的一个盘，直接移动到3号柱子上.
- 末了把2号柱子上n-1个盘应用递归挪用要领，悉数移动到3号柱子上。
var hanoi = function(disc,src,aux,dst) {
if(disc > 0) {
hanoi(disc -1,src,dst,aux);
document.writeln('Move disc '+disc + " from "+src+"to "+dst);
hanoi(disc-1,aux,src,dst)
}
};
hanoi(3,'Src','Aux',"Dst");
//
Move disc 1 from Srcto Dst
Move disc 2 from Srcto Aux
Move disc 1 from Dstto Aux
Move disc 3 from Srcto Dst
Move disc 1 from Auxto Src
Move disc 2 from Auxto Dst
Move disc 1 from Srcto Dst应用递归高效地操纵树形构造，比方浏览器端的文档对象模子（DOM），
var walk_the_DOM = function walk(node,func) {
func(node);
node = node.firstChild;
while(node) {
walk(node,func);
node = node.nextSibling;
}
}
// 定义 getElementsByAttribute 函数，
//它以一个属性称号字符串和一个可选的婚配值作为参数。
var getElementsByAttribute = function(att,value) {
var results = [];
walk_the_DOM(document.body,function(node) {
var actual = node.nodeType === 1 $$ node.getAttribute(att);
if(typeof actual === 'string' && (actual === value || typeof value != 'string')) {
results.push(node)
}
});
return results;
}一些言语供应了尾递归优化。这意味着假如一个函数返回本身递归挪用的效果，那末挪用的历程会被替换为一个轮回，能够明显进步速率。
//构建一个带尾递归的函数。由于它会返回本身挪用的效果
// 完成 factorial = n*(n-1)(n-2)... 1;
var factorial = function factorial(i,a) {
a = a || 1;
if(i<2) {
return a;
}
return factorial(i-1,a*i);
};
document.writeln(factorial(4)) // 4*3*2*1 = 24作用域
作用域掌握着变量与参数的可见性及生命周期
函数作用域： 定义在函数中的参数和变量在函数外部是不可见的，而在一个函数内部任何位置定义的变量，在该函数内部任何处所都可见。
在JavaScript中缺乏管帐作用域，最好的做法是在函数体的顶部声明函数中能够用到的一切变量。
闭包 Closure
闭包：函数能够接见它被建立时所处的上下文环境。
内部函数能够接见外部函数的现实变量而无需复制
作用域的优点是内部函数能够接见定义它们的外部函数的参数和变量（除了this 和arguments）
内部函数具有比它的外部函数更长的生命周期。
var myObject = (function(){
var value = 0;
return {
increment:function(inc) {
value += typeof inc === 'number' ?inc :1;
},
getValue:function() {
return value;
}
}
})()上面定义的value变量对increment和getValue要领老是可用的，但函数的作用域使得它对其他的递次来说是不可见的
回调 Callbacks
异步要求，供应一个服务器的相应抵达是随即触发的回调函数，
异步函数马上返回。
模块 Module
运用 函数 和 闭包制造模块
模板的平常情势：
- 一个定义了私有变量和函数的函数
- 应用闭包建立能够接见私有变量和函数的特权函数
- 返回这个特权函数，或许把它们保留到一个可接见到的处所。
应用前面运用的method要领，为String 增添一个deentityify 要领，寻觅字符串中的HTML字符实体并把它们替换为对应的字符。
String.method('deentityify',function(){
// 字符实体表，它映照字符实体的名字到对应的字符
var entity = {
quot: '"',
lt:'<',
gt:'>'
};
// 返回 deetityify 要领
return function() {
// 下面就是deetityify要领，
return this.replace(/&([^&;]+);/g,
function(a,b){
var r = entity[b];
return typeof r === 'string'?r:a;
}
)
}
}());末了，运用()运算符马上挪用我们方才组织出来的函数，这个挪用所建立并返回的函数才是deentityify要领
document.writeln('<">'.deentityify()) // <">级联
让实行后的函数返回this 而不是 undefined，就能够启用级联
一个级联中就，我们能够在零丁一条语句中顺次挪用同一个对象的许多要领。一个启用了Ajax类库能够许可我们以如许的情势去编码
getElement('myBoxDiv')
.move(300,150)
.width(100)
.height(200)
...
.tip('This box is resizeable')上面的例子中，每次挪用返回的效果都会被下一次挪用所用。
柯里化
柯里化许可我们把函数与通报给它的参数相结合，发生一个新的函数
Function.method('curry',function(){
var slice = Array.prototype.slice,
args = slice.apply(arguments),
that = this;
return function() {
return that.apply(null,args.concat(slice.apply(arguments)))
}
})
function add (a,b) {return a+b}
add.curry(1)(6) //7影象
函数能够将先前操纵的效果记录在某个对象里，从而防止无谓的反复运算，这类优化被称为影象
以Fibonacci数列为例，一个Fibonacci数字是之前两个Fibonacci数字之和。最前面的两个数字时0和1
var fibonacci = function (n) {
return n<2? n:fibonacci(n-1) + fibonacci(n-2)
}
for(var i =0 ;i< = 10;i+=1) {
document.writeln('//'+i+': '+fibonacci(i))
}
//0: 0
//1: 1
//2: 1
//3: 2
//4: 3
//5: 5
//6: 8
//7: 13
//8: 21
//9: 34
//10: 55革新，应用memo数组保留我们的存储效果，存储效果能够隐藏在闭包中。
var fibonacci = function() {
var memo = [0,1];
var fib = function(n) {
var result = memo[n];
// 搜检效果是不是已存在，假如已存在，就马上返回这个效果
if(typeof result !== "number") {
result = fib(n-1) + fib(n-2);
memo[n]= result;
}
return result
};
return fib;
}();
fibonacci(10) //55推而广之，编写一个函数来协助我们组织带影象功用的函数。
var memoizer = function(memo,formula) {
var recur = function(n) {
var result = memo[n];
if(typeof result !== "number") {
result = formula(recur,n);
memo[n] = result;
}
return result;
};
return recur;
}
var fibonacci = memoizer([0,1],function(recur,n) {
return recur(n-1) + recur(n-2);
});
fibonacci(10) // 55