JavaScript深入---函数式编程

一、纯函数

给定一个输入总是返回相同的输出

var double = (value) => value*2;

二、高阶函数

1.什么是高阶函数

函数能够被存储、传递并像JavaScript其他数据类型一样被赋值，这种极端JavaScript特性允许函数被传递给另一个函数，我们称为高阶函数，高阶函数就是接受另一个函数作为参数或返回一个函数的函数

const forEach = (array,fn) => {
   let i;
   for(i=0;i<array.length;i++)
      fn(array[i])
}

2.数组中的高阶函数

const every = (arr,fn) => {
    let result = true;

    for(const value of arr) {
        result = result && fn(value);
    }

    return result;
}

const some = (arr,fn) => {
    let result = false;

    for(const value of arr) {
        result = result || fn(value)
    }

    return result;
}

const map = (arr,fn) => {
    let results = [];

    for(const value of arr) {
        results.push(fn(value));
    }

    return results;  
}

const filter = (arr,fn) => {
    let results = [];

    for(const value of arr) {
        (fn(value)) ? results.push(value) : undefined;
    }

    return results;  
}

const reduce = (arr,fn,initialValue) => {
    let accumlator;

    if(initialValue != undefined) {
        accumlator = initialValue;
    }
    else {
        accumlator = array[0];
    } 

    for(const value of arr) {
        accumlator = fn(accumlator,value)
    }
    

  return [accumlator];
}

三、函数闭包

1.什么是函数闭包

有权访问另一个函数作用域链中的变量的函数，下例中函数inner就是闭包函数

function outer(){
    let outer = "outer";
    function inner{
       console.log(outer);                                   
    }
    return inner;
}

2.闭包的作用域链

• 在它自身之内声明的变量
• 对全局变量的访问
• 对外部函数变量的访问（重点）

function outer(){
    var result = new Array();
    for(var i = 0; i < 10; i++){
       result[i] = function(){
           return i;
       }
    }
    return result;
}

上例中result数组中的每个函数返回的都是10

四、柯里化与偏应用

1.函数柯里化

把一个多参函数转化为一个嵌套的一元函数的过程

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


// 柯里化
function curryAdd(x){
    return function(y){
        return x+y;
    }
}
curryAdd(1)(2);

const curry =(fn) => {
    if(typeof fn!=='function'){
        return;
    }
    return function curriedFn(...args){
      if(args.length < fn.length){
        return function(){
          return curriedFn.apply(null, args.concat( [].slice.call(arguments) ));
        };
      }
      return fn.apply(null, args);
    };
};

2.偏应用

const partial = function (fn,...partialArgs){
  let args = partialArgs.slice(0);
  return function(...fullArguments) {
    let arg = 0;
    for (let i = 0; i < args.length && arg < fullArguments.length; i++) {
      if (args[i] === undefined) {
        args[i] = fullArguments[arg++];
        }
      }
      return fn.apply(this, args);
  };
};