js函数式编程/js的this/js的call()

<script>
/*
	高阶函数作为函数式编程众多风格中的一个显著特征。满足的条件是，接受函数作为输入，输出一个函数。
*/
//声明三个对象，每个对象都有属性id和date，按照date属性进行排序
/*
var a = new Object();
var b = new Object();
var c = new Object();

a.id = 1;
b.id = 2;
c.id = 3;

a.date = new Date(2012, 3, 12);
b.date = new Date(2012, 1, 15);
c.date = new Date(2012, 2, 10);
*/

var a = {
		id : 1,
		date : new Date(2012, 3, 12)
	};
var b = {
		id : 2,
		date : new Date(2012, 1, 15)
	};
var c = {
		id : 3,
		date : new Date(2012, 2, 10)
	};
//存放在arr数组中
var arr = [a, b, c];
//开始调试，留意id的排列顺序是1,2,3
arr.sort(
	function(x, y){
		return x.date - y.date;	
	});
for (var i = 0; i < 3; i++){
	document.write(arr[i].id + " " + arr[i].date + "</br>");
}
/*
	2 Wed Feb 15 2012 00:00:00 GMT+0800 (中国标准时间)
	3 Sat Mar 10 2012 00:00:00 GMT+0800 (中国标准时间)
	1 Thu Apr 12 2012 00:00:00 GMT+0800 (中国标准时间)
*/

//包装函数
function wrap(tag){
	var stag = '<' + tag + '>';
	var etag = '</' + tag.replace(/s.*/, '') + '>';
	return function(x){
			return stag + x + etag;
		}
	}
var B = new wrap('B');
document.write('B' + "</br>");
document.write(B('粗体字') + "</br>");
document.write("</br>");
document.write(wrap('B')('粗体字') + "</br>");

//map函数
function map(array, func){
		var res = [];
		for (var i = 0, len = array.length; i < len; i++){
			res.push(func(array[i]));
		}
		return res;
	}
var mapped = map([1, 3, 5, 7, 8], function(n){
		return n = n + 1;
	});
document.write(mapped + "</br>");//2,4,6,8,9

var mapped = map(["one", "two", "three", "four"], function(item){
	return "(" + item + ")";	
});

document.write(mapped + "</br>");//(one),(two),(three),(four)

/*
		函数柯里化，就是利用自己有的函数，再创建一个动态的函数，该动态的函数内部还是通过已有的函数来发生作用，
	只是传入更多的参数来简化函数的参数方面的调用。
*/
</script>

<script>
/*
	this总是指向当前作用域对象，如果当前定义对象的作用域没有发生改变，则this会指向当前对象。
	引用函数能够改变函数的执行作用域，而调用函数是不会改变函数执行作用域的。
*/
var o = {
		name : "对象o",
		f : function(){
			return this;
		}
	}
	
o_o1 = {
		name : "对象o1",
		me : o.f//引用对象o的方法f，那么此时me的属性就是function 
	}
var who1 = o_o1.me();//此时me指向一个方法
alert(who1.name);//f

o_o2 = {
		name : "对象o1",
		me : o.f()//调用对象o的方法f，此时me的属性是string,表示执行对象o中的方法得到的值，"对象o"
	}
var who2 = o_o2.me;
alert(who2.name);//对象o
</script>

<script>
/*
		call()和apply()方法可以直接改变执行函数的作用域，使其作用域指向所传递的参数，因此函数中包含
	的this关键字也指向参数对象。
*/
function f(){
		//如果当前执行域对象的构造函数等于当前函数，则表示this为实例对象
		if (this.constructor == arguments.callee) alert("this = 实例对象");
		else if (this == window) alert("this = widow对象");
		else alert("this = 其他对象 \nthis.constructor = " + this.constructor);
	}
f();//this = widow对象
new f();//this = 实例对象
f.call(1);
/*
	this = 其他对象 
	this.constructor = function Number() {
    	[native code]
	}
	call()方法执行函数f()时候，call会把函数的作用域强制修改为参数对象所在的上下文。
	由于call()方法的参数值是数字1，因此js解释器会把数字1强制封装为数值对象。
*/
/*
		call()方法把函数f()强制转换成对象o的一个方法并执行。这样函数中的this就指代对象o，
		this.x和this.y分别指向1，2。
*/
function f(){
		alert(this.x + this.y);
	}
var o = {			//对象直接量
		x : 1,
		y : 2
	}
f.call(o);//3


</script>

js函数式编程/js的this/js的call()

猜你喜欢