函数
函数声明
方法一：赋给变量
变量式声明先创建一个匿名函数，然后把它赋值给一个指定的变量：
var f = function () { /* function body */ };
通常我们不必关心等号右边表达式的作用域是全局还是某个闭包内，因为它只能通过等号
左边的变量f来引用，应该关注的是变量f的作用域。
如果f指向函数的引用被破坏（f = null），且函数没有被赋值给任何其它变量或
对象属性，匿名函数会因为失去所有引用而被垃圾回收机制销毁。
方法二：函数表达式
也可以使用函数表达式创建函数：
function f() { /* function body */ }
与变量式不同的是，这种声明方式会为函数的一个内置属性name赋值。同时把函数
赋值给当前作用域的一个同名变量。（函数的name属性，configurable、
enumerable和writable均为false）
function f() { /* function body */ }
console.log(f.name); // "f"
console.log(f); // f()
Javascript变量有一个的特别之处，就是会把变量的声明提前，表达式式的函数声明， 也会把整个函数的定义前置，因此你可以在函数定义之前使用它：
console.log(f.name); // "f"
console.log(f); // f()
function f() { /* function body */ }
函数表达式的声明会被提升到作用域顶层，试试下面的代码，它们不是本文的重点：
var a = 0;
console.log(a); // 0 or a()?
function a () {}
Crockford建议永远使用第一种方式声明函数，他认为第二种方式放宽了函数必须先声明 后使用的要求从而会导致混乱。（Crockford是一个类似于罗素口中用来比喻维特根斯坦的 "有良心的艺术家"那样的"有良心的程序员"，这句话很拗口吧）
函数式声明function f() {}看起来是var f = function f(){};的简写。
而表达式：
var a = function b(){};
创建一个函数并把内置的name属性赋值为"b"，然后把这个函数赋值给变量a，
你可以在外部使用a()来调用它，但却不能使用b()，因为函数已被赋值给a，
所以不会再自动创建一个变量b，除非你使用var b = a声明一个变量b。
当然这个函数的name是"b"而不是"a"。
方法三：Function构造函数
使用Function构造函数也可用来创建函数：
var f = new Function("a,b,c","return a+b+c;");
这种方式其实是在全局作用域内生成一个匿名函数，并把它赋值给变量f。
Arguments对象
JavaScript 函数有个内置的对象 arguments 对象. argument 对象包含了函数调用的参数数组。
通过这种方式你可以很方便的找到最后一个参数的值：
x = findMax(1, 123, 500, 115, 44, 88);
function findMax() {
var i, max = 0;
for (i = 0; i < arguments.length; i++) {
if (arguments[i] > max) {
max = arguments[i];
}
}
return max;
}
或者创建一个函数用来统计所有数值的和：
x = sumAll(1, 123, 500, 115, 44, 88);
function sumAll() {
var i, sum = 0;
for (i = 0; i < arguments.length; i++) {
sum += arguments[i];
}
return sum;
}
JavaScript 函数调用
JavaScript 函数有 4 种调用方式。
每种方式的不同方式在于 this 的初始化。
this 关键字
一般而言，在Javascript中，this指向函数执行时的当前对象。
作为一个函数调用
function myFunction(a, b) {
return a * b;
}
myFunction(10, 2); // myFunction(10, 2) 返回 20
以上函数不属于任何对象。但是在 JavaScript 中它始终是默认的全局对象。
在 HTML 中默认的全局对象是 HTML 页面本身，所以函数是属于 HTML 页面。
在浏览器中的页面对象是浏览器窗口(window 对象)。以上函数会自动变为 window 对象的函数。
myFunction() 和 window.myFunction() 是一样的：
function myFunction(a, b) {
return a * b;
}
window.myFunction(10, 2); // window.myFunction(10, 2) 返回 20
Note 这是调用 JavaScript 函数常用的方法， 但不是良好的编程习惯 全局变量，方法或函数容易造成命名冲突的bug。
全局对象
当函数没有被自身的对象调用时， this 的值就会变成全局对象。
在 web 浏览器中全局对象是浏览器窗口（window 对象）。
该实例返回 this 的值是 window 对象:
function myFunction() {
return this;
}
myFunction(); // 返回 window 对象
Note 函数作为全局对象调用，会使 this 的值成为全局对象。 使用 window 对象作为一个变量容易造成程序崩溃。
函数作为方法调用
在 JavaScript 中你可以将函数定义为对象的方法。
以下实例创建了一个对象 (myObject), 对象有两个属性 (firstName 和 lastName), 及一个方法 (fullName):
var myObject = {
firstName:"John",
lastName: "Doe",
fullName: function () {
return this.firstName + " " + this.lastName;
}
}
myObject.fullName(); // 返回 "John Doe"
fullName 方法是一个函数。函数属于对象。 myObject 是函数的所有者。
this对象，拥有 JavaScript 代码。实例中 this 的值为 myObject 对象。
测试以下！修改 fullName 方法并返回 this 值:
var myObject = {
firstName:"John",
lastName: "Doe",
fullName: function () {
return this;
}
}
myObject.fullName(); // 返回 [object Object] (所有者对象)
Note 函数作为对象方法调用，会使得 this 的值成为对象本身。
使用构造函数调用函数
如果函数调用前使用了 new 关键字, 则是调用了构造函数。
这看起来就像创建了新的函数，但实际上 JavaScript 函数是重新创建的对象：
// 构造函数:
function myFunction(arg1, arg2) {
this.firstName = arg1;
this.lastName = arg2;
}
// This creates a new object
var x = new myFunction("John","Doe");
x.firstName; // 返回 "John"
构造函数的调用会创建一个新的对象。新对象会继承构造函数的属性和方法。
Note 构造函数中 this 关键字没有任何的值。 this 的值在函数调用时实例化对象(new object)时创建。
作为函数方法调用函数
在 JavaScript 中, 函数是对象。JavaScript 函数有它的属性和方法。
call() 和 apply() 是预定义的函数方法。 两个方法可用于调用函数，两个方法的第一个参数必须是对象本身。
function myFunction(a, b) {
return a * b;
}
myFunction.call(myObject, 10, 2); // 返回 20
function myFunction(a, b) {
return a * b;
}
myArray = [10,2];
myFunction.apply(myObject, myArray); // 返回 20
两个方法都使用了对象本身作为第一个参数。 两者的区别在于第二个参数： apply传入的是一个参数数组，也就是将多个参数组合成为一个数组传入，而call则作为call的参数传入（从第二个参数开始）。
在 JavaScript 严格模式(strict mode)下, 在调用函数时第一个参数会成为 this 的值， 即使该参数不是一个对象。
在 JavaScript 非严格模式(non-strict mode)下, 如果第一个参数的值是 null 或 undefined, 它将使用全局对象替代。
Note 通过 call() 或 apply() 方法你可以设置 this 的值, 且作为已存在对象的新方法调用。
call()、apply()、bind()
比较一下这两者this的差别，第一个打印里面的this指向obj，
第二个全局声明的shows()函数this是window：
var name = 'Foo', age = 17;
var obj = {
name : 'Bar',
objAge : this.age,
myFun : function () {
console.log("name: " + this.name + " , ages: " + this.age);
}
}
obj.objAge // 17
obj.myFun() // name: Bar , ages: undefined
var fav = 'Adda';
function shows() {
console.log(this.fav);
}
shows(); // Adda
call()、apply()、bind()都是用来重定义 this 这个对象的：
var name = 'Foo', age = 17;
var obj = {
name : 'Bar',
objAge : this.age,
myFun : function () {
console.log("name: " + this.name + " , ages: " + this.age);
}
}
var db = {name: 'Tom', age: '60'}
obj.myFun.call(db); // name: Tom , ages: 60
obj.myFun.apply(db); // name: Tom , ages: 60
obj.myFun.bind(db); // [Function: bound myFun]
obj.myFun.bind(db)(); // name: Tom , ages: 60
以上出了bind方法后面多了个返回的是一个新的函数，其他的结果返回都一致！
var name = 'Foo', age = 17;
var obj = {
name : 'Bar',
objAge : this.age,
myFun : function (fm, t) {
console.log("name: " + this.name + " , ages: " + this.age + //
" , from: " + fm + " , to: " + t);
}
}
var db = {name: 'Tom', age: '60'}
obj.myFun.call(db,'成都','上海');
// name: Tom , ages: 60 , from: 成都 , to: 上海
obj.myFun.call(db,['成都','上海']);
// name: Tom , ages: 60 , from: 成都,上海 , to: undefined
obj.myFun.apply(db,['成都','上海']);
// name: Tom , ages: 60 , from: 成都 , to: 上海
obj.myFun.apply(db,'成都','上海');
// TypeError: CreateListFromArrayLike called on non-object
obj.myFun.bind(db,'成都','上海')();
// name: Tom , ages: 60 , from: 成都 , to: 上海
obj.myFun.bind(db,['成都','上海'])();
// name: Tom , ages: 60 , from: 成都,上海 , to: undefined
call、bind、apply这三个函数的第一个参数都是this的指向对象，
第二个参数差别就来了：
-
call的参数是直接放进去的，第二第三第 n 个参数全都用逗号分隔 -
apply的所有参数都必须放在一个数组里面传进去 -
bind除了返回是函数以外，它的参数和 call 一样
递归
递归被用来简化许多问题，这需要在一个函数体中调用它自己：
// 一个简单的阶乘函数
var f = function (x) {
if (x === 1) {
return 1;
} else {
return x * f(x - 1);
}
};
Javascript中函数的巨大灵活性，导致在递归时使用函数名遇到困难，对于上面的变量式
声明，f是一个变量，所以它的值很容易被替换：
var fn = f;
f = function () {};
函数是个值，它被赋给fn，我们期待使用fn(5)可以计算出一个数值，但是由于
函数内部依然引用的是变量f，于是它不能正常工作了。
函数式的声明看起来好些，但很可惜：
function f(x) {
if (x === 1) {
return 1;
} else {
return x * f(x - 1);
}
}
var fn = f;
f = function () {}; // may been warning by browser
fn(5); // NaN
看起来，一旦我们定义了一个递归函数，便须注意不要轻易改变变量的名字。
上面谈论的都是函数式调用，函数还有其它调用方式，比如当作对象方法调用。
我们常常这样声明对象：
var obj1 = {
num : 5,
fac : function (x) { /* function body */ }
};
声明一个匿名函数并把它赋值给对象的属性fac。
如果我们想要在这里写一个递归，就要引用属性本身：
var obj1 = {
num : 5,
fac : function (x) {
if (x === 1) {
return 1;
} else {
return x * obj1.fac(x - 1);
}
}
};
当然，它也会遭遇和函数调用方式一样的问题：
var obj2 = { fac: obj1.fac };
obj1 = {};
obj2.fac(5); // Sadness
方法被赋值给obj2的fac属性后，内部依然要引用obj1.fac，于是失败了。
换一种方式会有所改进：
var obj1 = {
num : 5,
fac : function (x) {
if (x === 1) {
return 1;
} else {
return x * this.fac(x - 1);
}
}
};
var obj2 = {fac: obj1.fac};
obj1 = {};
obj2.fac(5); // ok
通过this关键字获取函数执行时的context中的属性，这样执行obj2.fac时，
函数内部便会引用obj2的fac属性。
可是函数还可以被任意修改context来调用，那就是万能的call和apply：
obj3 = {};
obj1.fac.call(obj3, 5); // dead again
于是递归函数又不能正常工作了。
我们应该试着解决这种问题，还记得前面提到的一种函数声明的方式吗？
var a = function b(){};
这种声明方式叫做内联函数（inline function），虽然在函数外没有声明变量b，
但是在函数内部，是可以使用b()来调用自己的，于是：
var fn = function f(x) {
// try if you write "var f = 0；" here
if (x === 1) {
return 1;
} else {
return x * f(x - 1);
}
};
var fn2 = fn;
fn = null;
fn2(5); // OK
// here show the difference between "var f = function f() {}" and "function f() {}"
var f = function f(x) {
if (x === 1) {
return 1;
} else {
return x * f(x - 1);
}
};
var fn2 = f;
f = null;
fn2(5); // OK
var obj1 = {
num : 5,
fac : function f(x) {
if (x === 1) {
return 1;
} else {
return x * f(x - 1);
}
}
};
var obj2 = {fac: obj1.fac};
obj1 = {};
obj2.fac(5); // ok
var obj3 = {};
obj1.fac.call(obj3, 5); // ok
就这样，我们有了一个可以在内部使用的名字，而不用担心递归函数被赋值给谁以及 以何种方式被调用。
Javascript函数内部的arguments对象，有一个callee属性，指向的是函数本身。
因此也可以使用arguments.callee在内部调用函数：
function f(x) {
if (x === 1) {
return 1;
} else {
return x * arguments.callee(x - 1);
}
}
但arguments.callee是一个已经准备被弃用的属性，很可能会在未来的ECMAscript版本中
消失，在ECMAscript 5中"use strict"时，不能使用arguments.callee。
最后一个建议是：如果要声明一个递归函数，请慎用new Function这种方式，Function
构造函数创建的函数在每次被调用时，都会重新编译出一个函数，递归调用会引发性能
问题——你会发现你的内存很快就被耗光了。