1.概念
一个函数接受另一个函数作为参数，这就是高阶函数。
e.g.
function add(x, y, f) {
return f(x) + f(y);
}
add(-5, 6, Math.abs); // 11
2. ES5中新增的Array方法
1) forEach
[1, 2, 3, 4].forEach(console.log);
// 1 0 [1, 2, 3, 4]
// 2 1 [1, 2, 3, 4]
// 3 2 [1, 2, 3, 4]
// 4 3 [1, 2, 3, 4]
由此可见，forEach参数中的回调函数接收三个参数，分别是value, index, array，即元素值、元素索引、数组本身。对此，我们有：
（ 注意index在第二个参数位置）
var sum = 0;
[1, 2, 3, 4].forEach(function (item, index, array) {
console.log(array[index] == item); // true
sum += item;
});
alert(sum); // 10
forEach除了接收一个回调函数，还可以接收一个上下文参数（可选，默认是全局对象window），即：
array.forEach(callback,[ thisObject])
var database = {
users: ["张含韵", "江一燕", "李小璐"],
sendEmail: function (user) {
if (this.isValidUser(user)) {
console.log("你好，" + user);
} else {
console.log("抱歉，"+ user +"，你不是本家人");
}
},
isValidUser: function (user) {
return /^张/.test(user);
}
};
// 给每个人发邮件
database.users.forEach( // database.users中人遍历
database.sendEmail, // 发送邮件
database // 使用database代替上面标红的this
);
// 结果：
// 你好，张含韵
// 抱歉，江一燕，你不是本家人
// 抱歉，李小璐，你不是本家人
2) map
即“映射”，callback要有返回值，否则会返回一个全是undefined的数组。
array.map(callback,[ thisObject]);
可以利用map获得对象数组中的特定属性值：
var users = [
{name: "张含韵", "email": "zhang@email.com"},
{name: "江一燕", "email": "jiang@email.com"},
{name: "李小璐", "email": "li@email.com"}
];
var emails = users.map(function (user) { return user.email; });
console.log(emails.join(", ")); // zhang@email.com, jiang@email.com, li@email.com
3) filter
返回过滤后的新数组。callback函数需要返回值，弱等于Boolean值。
var data = [0, 1, 2, 3];
var arrayFilter = data.filter(function(item) {
return item;
});
console.log(arrayFilter); // [1, 2, 3]
var emailsZhang = users
// 获得邮件
.map(function (user) { return user.email; })
// 筛选出zhang开头的邮件
.filter(function(email) { return /^zhang/.test(email); });
console.log(emailsZhang.join(", ")); // zhang@email.com
4) some
数组中的某些项是否符合条件（至少1个），只要发现一个符合立刻返回true。返回值为true或false。
var scores = [5, 8, 3, 10];
var current = 7;
function higherThanCurrent(score) {
return score > current;
}
if (scores.some(higherThanCurrent)) {
alert("朕准了！");
}
// 朕准了！
5) every
和some相反，要全部符合条件才返回true，否则返回false。
if (scores.every(higherThanCurrent)) {
console.log("朕准了！");
} else {
console.log("来人，拖出去斩了！");
}
// 来人，拖出去斩了！
6) indexOf
略
7) lastIndexOf
略
8) reduce
callback函数接受4个参数：之前值、当前值、索引值以及数组本身。initialValue参数可选，表示初始值。若指定，则当作最初使用的previous值；如果缺省，则使用数组的第一个元素作为previous初始值，同时current往后排一位，相比有initialValue值少一次迭代。
array.reduce(callback[, initialValue])
var sum = [1, 2, 3, 4].reduce(function (previous, current, index, array) {
return previous + current;
});
console.log(sum); // 10
说明：
因为initialValue不存在，因此一开始的previous值等于数组的第一个元素。
从而current值在第一次调用的时候就是2.
最后两个参数为索引值index以及数组本身array。
// 初始设置
previous = initialValue = 1, current = 2
// 第一次迭代
previous = (1 + 2) = 3, current = 3
// 第二次迭代
previous = (3 + 3) = 6, current = 4
// 第三次迭代
previous = (6 + 4) = 10, current = undefined (退出)
二维数组扁平化：
var matrix = [
[1, 2],
[3, 4],
[5, 6]
];
// 二维数组扁平化
var flatten = matrix.reduce(function (previous, current) {
return previous.concat(current);
});
console.log(flatten); // [1, 2, 3, 4, 5, 6]
类似的reduceRight，从数组末尾开始：
var data = [1, 2, 3, 4];
var specialDiff = data.reduceRight(function (previous, current, index) {
if (index == 0) {
return previous + current;
}
return previous - current;
});
console.log(specialDiff); // 0
// 初始设置
index = 3, previous = initialValue = 4, current = 3
// 第一次迭代
index = 2, previous = (4- 3) = 1, current = 2
// 第二次迭代
index = 1, previous = (1 - 2) = -1, current = 1
// 第三次迭代
index = 0, previous = (-1 + 1) = 0, current = undefined (退出)
3.Reducer深入
首先是基本函数：
var words = [ "You", "have", "written", "something", "very", "interesting" ];
function strUppercase(str) { return str.toUpperCase(); }
function isLongEnough(str) {
return str.length >= 5;
}
function isShortEnough(str) {
return str.length <= 10;
}
要对数组过滤，可以直接map、连续filter，但显得过于重复，且每个 filter(..) 方法都会产生一个单独的 observable 值，数据量大时就会出现性能问题。所以可以使用reduce，initialValue设为空数组[]作为初始的list：
function strUppercaseReducer(list,str) {
return list.concat( [strUppercase( str )] );
}
function isLongEnoughReducer(list,str) {
if (isLongEnough( str )) return list.concat( [str] );
return list;
}
function isShortEnoughReducer(list,str) {
if (isShortEnough( str )) return list.concat( [str] );
return list;
}
除了判断函数不同其他基本相同，所以可以利用闭包把判断函数作为参数，建立一个filterReducer，同理还有mapReducer：
function filterReducer(predicateFn) {
return function reducer(list, val) {
if (predicateFn(val)) {
return list.concat( [val] );
}
return list;
}
}
var isLongEnoughReducer = filterReducer( isLongEnough );
var isShortEnoughReducer = filterReducer( isShortEnough );
function mapReducer(fn) {
return function reducer(list, val) {
return list.concat( [fn(val)] );
}
}
var strToUppercaseReducer = mapReducer( strUppercase );
调用链就可以写成这样：
words
.reduce( strUppercaseReducer, [] )
.reduce( isLongEnoughReducer, [] )
.reduce( isShortEnough, [] )
.reduce( strConcat, "" );
// "WRITTENSOMETHING"
提取共用组合逻辑
仔细观察上面的 mapReducer(..) 和 filterReducer(..) 函数。你发现共享功能了吗？
这部分：
return list.concat( .. );
// 或者
return list;
所以还可以再提取出一个listCombination函数出来：
function listCombination(list,val) { return list.concat( [ val ] ); }
所以最新的filterReducer和mapReducer如下：
function filterReducer(predicateFn) {
return function reducer(list, val) {
if (predicateFn(val)) {
return listCombination( list, val );
}
return list;
}
}
function mapReducer(fn) {
return function reducer(list, val) {
return listCombination( list, fn(val) );
}
}
进一步，可以使用不同的类似listCombination的工具函数，所以再对reducer进行改造如下：
function filterReducer(predicateFn,combinationFn) {
return function reducer(list,val){
if (predicateFn( val )) return combinationFn( list, val );
return list;
};
}
function mapReducer(mapperFn,combinationFn) {
return function reducer(list,val){
return combinationFn( list, mapperFn( val ) );
};
}
var strToUppercaseReducer = mapReducer( strUppercase, listCombination );
var isLongEnoughReducer = filterReducer( isLongEnough, listCombination );
var isShortEnoughReducer = filterReducer( isShortEnough, listCombination );
将这些实用函数定义为接收两个参数而不是一个参数不太方便组合，因此我们使用我们的 curry(..) （柯里化）方法：
var curriedMapReducer = curry( function mapReducer(mapperFn,combinationFn){
return function reducer(list,val){
return combinationFn( list, mapperFn( val ) );
};
} );
var curriedFilterReducer = curry( function filterReducer(predicateFn,combinationFn){
return function reducer(list,val){
if (predicateFn( val )) return combinationFn( list, val );
return list;
};
} );
var strToUppercaseReducer =
curriedMapReducer( strUppercase )( listCombination );
var isLongEnoughReducer =
curriedFilterReducer( isLongEnough )( listCombination );
var isShortEnoughReducer =
curriedFilterReducer( isShortEnough )( listCombination );
参考资料：
ES5中新增的Array方法详细说明
翻译连载 | 附录 A：Transducing（上）－《JavaScript轻量级函数式编程》 |《你不知道的JS》姊妹篇
网友评论