高阶函数：一个函数接受另外一个函数作为参数
下面介绍：map, reduce, filter, sort, 回调函数，其中map和filter的回调函数接受三个参数，reduce和sort方法的回调函数接受两个参数。
//示例
function add(x, y, f) {
return f(x) + f(y);
}
add(-5, 6, Math.abs) //11
map
function pow(x) {
return x * x;
}
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
//把pow(x)作用在Array的每一个元素并把结果生成一个新的Array
//arr中的每个元素会作为参数被传递给pow函数
arr.map(pow); // [1, 4, 9, 16, 25, 36, 49, 64, 81]
//不使用map的代码实现
var f = function (x) {
return x * x;
};
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var result = [];
for (var i=0; i<arr.length; i++) {
result.push(f(arr[i]));
}
//使用map把数组中的值全部变为字符串
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
arr.map(String); // ['1', '2', '3', '4', '5', '6', '7', '8', '9']
//使用map把['adam', 'LISA', 'barT']变成首字母大写，其他小写
//解法1
arr = ['adam', 'LISA', 'barT']
result = [];
arr.map(function(x){
var one = x[0].toUpperCase();
var others = "";
for(let i=1; i<x.length; i++){
others = others + x[i].toLowerCase();
}
return result.push(one+others);
})
//解法2
arr = ['adam', 'LISA', 'barT']
result = [];
arr.map(function(x){
var one = x[0].toUpperCase();
var others = x.substring(1).toLowerCase();
return result.push(one+others);
})
//解法2简洁版本
arr = ['adam', 'LISA', 'barT']
arr.map(function(x){
return x[0].toUpperCase() + x.substring(1).toLowerCase();
})
reduce
//reduce函数必须接收两个参数，把结果继续和序列的下一个元素做累积计算
//利用reduce计算求和和求积
var arr = [1, 3, 5, 7, 9];
arr.reduce(function (x, y) {
return x + y;
}); // 25
arr.reduce(function (x, y){
return x*y;
});
//利用reduce将[1,2,3]转化为123
var arr = [1,2,3];
arr.reduce(function(x, y){
return 10*x+y;
});
//利用reduce和map把“123”变成[1,2,3],然后变为数值123
var arr="123";
result = [];
for(let i=0; i<arr.length; i++){
result.push(arr[i]-0);
}ba
result; //[1,2,3]
result.reduce(function(x, y){
return 10*x+y;
});//123
filter
//接受函数，通过返回值的true或者false判断所选元素的去留
//去除偶数，保留奇数
var arr = [1, 2, 4, 5, 6, 9, 10, 15];
var r = arr.filter(function (x) {
return x % 2 !== 0;
});
r; // [1, 5, 9, 15]
//把数组中的空字符串去除
var arr = ['A', '', 'B', null, undefined, 'C', ' '];
var r = arr.filter(function (s) {
return s && s.trim(); // 注意：IE9以下的版本没有trim()方法
});
r; // ['A', 'B', 'C']
sort
//如果sort方法不接受函数，默认按照字符在ascii中的排列进行排序，ascii中的字符越靠前，排名越前
['Google', 'apple', 'Microsoft'].sort(); // ['Google', 'Microsoft", 'apple']
[10, 20, 1, 2].sort(); // [1, 10, 2, 20]
//自定义比较函数进行排序，比较的过程必须通过函数抽象出来。
//通常规定，对于两个元素x和y，如果认为x < y，则返回-1，如果认为x == y，则返回0，如果认为x > y，则返回1
var arr = [10, 20, 1, 2];
arr.sort(function (x, y) {
if (x < y) {
return -1;
}
if (x > y) {
return 1;
}
return 0;
}); // [1, 2, 10, 20]，升序
var arr = [10, 20, 1, 2];
arr.sort(function (x, y) {
if (x < y) {
return 1;
}
if (x > y) {
return -1;
}
return 0;
}); // [20, 10, 2, 1],倒序
//注意，sort方法会改变数组
var a1 = ['B', 'A', 'C'];
var a2 = a1.sort();
a1; // ['A', 'B', 'C']
a2; // ['A', 'B', 'C']
a1 === a2; // true, a1和a2是同一对象
回调函数
高阶函数中接受函数作为参数，这个作为参数的函数其实就是回调函数，在filter和map中回调函数的参数一般为1个，但是其实是有3个，一般只使用一个。
//三个参数分别代表的意义
var arr = ['A', 'B', 'C'];
var r = arr.filter(function (element, index, self) {
console.log(element); // 依次打印'A', 'B', 'C'，element代表元素本身
console.log(index); // 依次打印0, 1, 2， index代表元素的索引值
console.log(self); // self就是变量arr， self代表整个arr
return true;
});
//使用filter删除重复的元素
'use strict';
var r,arr = ['apple', 'strawberry', 'banana', 'pear', 'apple', 'orange', 'orange', 'strawberry'];
r = arr.filter(function (element, index, self) {
return self.indexOf(element) === index;
});
//使用map转化字符
'use strict';
var arr = ['1', '2', '3'];
var r;
r = arr.map(parseInt);
alert('[' + r[0] + ', ' + r[1] + ', ' + r[2] + ']'); //[1, NaN, NaN]
//结果为[1, NaN, NaN]的原因是map传递给parseInt函数三个参数，分别是element,index,self, parseInt接受两个参数
//parseInt(string, radix);第一个参数是传递进来的字符，第二个是数值进制的表示方式
//["1","2","3"].map(parseInt)等于[parseInt('1',0),parseInt('2',1),parseInt('3',2)]
//parseInt(1,0)//radix为0，1十进制为1, parseInt(2,1)//radix小于2，返回NaN ,parseInt(3,2)//radix为2,3的二进制NaN
//使用filter判断素数（不能被除了被自身之外的任何数整除，1既不是质数也不是合数）
arr.filter(function(element,index,self){
for(let a=2;a<element-1;a++){
if(element%a==0)
return false;
}
return element!=1;
});