JavaScript学习-高阶函数

一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数

一个例子

function add(x, y, f) {
    return f(x) + f(y);
}

var x = add(-5, 6, Math.abs); // 11
console.log(x);

Map

map()方法定义在JavaScript的Array中

传入我们自己的函数，就得到了一个新的Array作为结果

将数组里面的元素，按照传入map里面的函数，进行转换

function pow(x) {
    return x * x;
}

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var results = arr.map(pow); // [1, 4, 9, 16, 25, 36, 49, 64, 81]
console.log(results);

把Array的所有数字转为字符串

var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
arr.map(String); // ['1', '2', '3', '4', '5', '6', '7', '8', '9']

Reduce

有点难说，看表达式吧，就是将当前元素和下一个进行累积计算

[x1, x2, x3, x4].reduce(f) = f(f(f(x1, x2), x3), x4)

假设先计算A = f（x1,x2）

再计算B = f（A，x3）

再计算f（B，x4）

对array求和

var arr = [1, 3, 5, 7, 9];
arr.reduce(function (x, y) {
    return x + y;
}); // 25

filter

它用于把Array的某些元素过滤掉，然后返回剩下的元素

sort

var arr = [10, 20, 1, 2];

arr.sort(function (x, y) {
    if (x < y) {
        return -1;
    }
    if (x > y) {
        return 1;
    }
    return 0;
});
console.log(arr); // [1, 2, 10, 20]

闭包

这个概念有点难懂，而且暂时没怎么用到过

简单来说就是返回一个函数然后延迟执行，但是又不仅限如此

function lazy_sum(arr) {
    var sum = function () {
        return arr.reduce(function (x, y) {
            return x + y;
        });
    }
    return sum;
}


//并没有求和，而是返回了一个求和函数
var f = lazy_sum([1, 2, 3, 4, 5]); 

//这时候才是调用
f(); // 15

这也是一个闭包的用法

//前面一个括号是返回了一个函数，后面的（3）是函数调用
(function (x) { return x * x }) (3);

闭包实现的计数器....

说实话不知道为什么不能直接实现一个计数器，说是为了使得x变成private，私有变量，因为js根本就没有private这种东西

那可不可以说。。。为了省略private以及变量类型等东西，导致添加了很多复杂的东西去填补这些坑。

function create_counter(initial) {
    var x = initial || 0;
    return {
        inc: function () {
            x += 1;
            return x;
        }
    }
}

其实，根本没法写一个带状态的函数。(自己试过了)

只能写一个类，然而没法私有

f = function（initial）{

     //这样写，没有用，因为每次调用就是一个新的，根本没法实现计数的功能  
     var x = initial||0；


}


var cal{

  current:0;
  ins:function(){
  return current+=1;
}


}

闭包就是携带状态的函数，并且它的状态可以完全对外隐藏起来。

JavaScript学习-高阶函数

猜你喜欢