javascript高级程序设计笔记-第七章（函数表达式）

一、递归

递归函数是在一个函数通过名字调用自身的情况下构成的

function factorial(num) {
	if (num <= 1) {
		return 1;
	} else {
		return num * factorial(num-1);
	}
}

但是将此函数赋值给另一个函数时会出错

var anotherFactorial = factorial;
factorial = null;
alert(anotherFactorial(4));		//报错

使用arguments.callee

function factorial(num) {
	if (num <= 1) {
		return 1;
	} else {
		return num * arguments.callee(num-1);
	}
}
var anotherFactorial = factorial;
factorial = null;
alert(anotherFactorial(4));		//24

但是arguments.callee在严格模式下会导致错误
所以严格模式下，使用命名函数表达式

var factorial = (function f(num) {
	if (num <= 1) {
		return 1;
	} else {
		return num * f(num-1);
	}
});
//创建一个名为f()的命名函数表达式，然后将其赋值给变量factorial

二、闭包

闭包是有权访问另一个函数作用域中的变量的函数，通常是通过在一个函数内部创建另一个函数来创建闭包

function compare(value1, value2) {
	if (value1 < value2) {
		return -1;
	} else if (value1 > value2) {
		return 1;
	} else {
		return 0;
	}
}
var result = compare(5, 10);

下图是compare()函数执行时的作用域链

一般当函数执行完毕后，局部活动对象就会被销毁，但是闭包不是，当creatComparisonFunction()函数返回后，其执行环境的作用域链会被销毁，但是它的活动对象仍然会留在内存中；直到匿名函数被销毁后，它的活动对象才会被销毁

function creatComparisonFunction(propertyName) {
	return function(object1, object2) {
		var value1 = object1[propertyName];
		var value2 = object2[propertyName];
		if (value1 < value2) {
			return -1;
		} else if (value1 > value2) {
			return 1;
		} else {
			return 0;
		}
	};
}
//创建函数
var compareNames = creatComparisonFunction("name");
//调用函数
var result = compareNames({name: "Nicholas"}, {name: "Greg"});

1、闭包与变量

副作用：闭包只能取得包含函数中任何变量的最后一个值

function createFunctions() {
	var result = new Array();
	for (var i = 0; i < 10; i++) {
		result[i] = function() {
			return i;
		};
	}
	return result;
}

这个函数会返回一个数组，表面上看，似乎每个函数都应该返回自己的索引值，实际上每个函数都返回10

可以定义一个匿名函数，并将立即执行该匿名函数的结果赋值给数组。而在这个匿名函数内部，创建一个闭包

function createFunctions() {
	var result = new Array();
	for (var i = 0; i < 10; i++) {
		result[i] = function(num) {
			return function() {
				return num;
			};
		}(i);
	}
	return result;
}

2、关于this对象

在全局函数中，this等于window，当函数被作为某个对象的方法调用时，this等于那个对象。
匿名函数的执行环境具有全局性，其this通常指向window。

var name = "the window";
var object = {
	name: "my object",
	getNameFunc: function() {
		return function() {
			return this.name;
		};
	}
};
alert(object.getNameFunc()());		//the window

把外部作用域中的this对象保存在一个闭包能够访问到的变量里，就可以让闭包访问该对象

var name = "the window";
var object = {
	name: "my object",
	getNameFunc: function() {
		var that = this;
		return function() {
			return that.name;
		};
	}
};
alert(object.getNameFunc()());		//my object

三、模仿块级作用域（私有作用域）

(function() {
	//这里是块级作用域
})();

将函数声明包含在一对圆括号中，表示它实际上是一个函数表达式，紧随其后的另一对圆括号会立即调用这个函数

function() {
	//这里是块级作用域
}();	//报错
//函数声明后面不能跟圆括号，而函数表达式后面可以跟圆括号

如果只是临时需要一些变量，就可以使用私有作用域

function outputNumbers() {
	(function() {
		for (var i = 0; i < 10; i++) {
			console.log(i);		//0,1,2,3,4,5,6,7,8,9
		}
	})();
	console.log(i);		//报错
}
outputNumbers();

这种技术通常在全局作用域中被用在函数外部，从而限制向全局作用域中添加过多的变量和函数

四、私有变量

任何在函数中定义的变量，都可以认为是私有变量。私有变量包括函数的参数、局部变量和函数内部定义的其他函数

特权方法：有权访问私有变量和私有函数的共有方法

方法是在构造函数中定义特权方法

function MyObject() {
	var privateVariable = 10;
	function privateFunction() {
		return false;
	}
	//特权方法
	this.publicMethod = function() {
		privateVariable ++;
		return privateFunction();
	};
}
//变量privateVariable和函数privateFunction()只能通过特权方法publicMethod()来访问

可以利用私有和特权成员，隐藏那些不应该被直接修改的数据

function Person(name) {
	this.getName = function() {
		return name;
	};
	this.setName = function(value) {
		name = value;
	};
}
var person = new Person("Nicholas");
alert(person.getName());		//Nicholas
person.setName("Greg");
alert(person.getName());		//Greg

1、静态私有变量

(function MyObject() {
	//私有变量和私有函数
	var privateVariable = 10;
	function privateFunction() {
		return false;
	}
	//构造函数
	MyObject = function() {};
	//特权方法
	MyObject.prototype.publicMethod = function() {
		privateVariable ++;
		return privateFunction();
	};
})();

2、模块模式

为单例创建私有变量和特权方法，单例指只有一个实例的对象

var singleton = function() {
	//私有变量和函数
	var var privateVariable = 10;
	function privateFunction() {
		return false;
	}
	//特权方法和属性
	return {
		publicProperty: true,
		publicMethod: function() {
			privateVariable ++;
			return privateFunction();
		}
	};
}();

如果必须创建一个对象并以某些数据对其进行初始化，同时还要公开一些能够访问这些私有数据的方法，就可以使用模块模式

3、增强的模块模式

适合那些单例必须是某种类型的实例，同时还必须添加某些属性和方法对其加以增强的情况

var singleton = function() {
	//私有变量和函数
	var var privateVariable = 10;
	function privateFunction() {
		return false;
	}
	//创建对象
	var object = new CustomType();
	//添加特权方法和属性
	object.publicProperty = true;
	object.publicMethod = function() {
		privateVariable ++;
		return privateFunction();
	};
	//返回这个对象
	return object;
}();