<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>