高阶函数的概念

1.一个函数参数是一个函数， 我们可以将这个函数认作是高阶函数 2. 一个函数返回一个函数 也可以称之为高阶函数 这两点满足任何一个都是高阶函数

对原函数进行扩展，但是不破坏原函数

function fn(who){
    console.log("say",who)
}
//在Function的原型上扩展一个before方法，此方法的参数是一个函数
Function.prototype.before=function(beforefun){
    return (...args)=>{
        beforefun(...args);
        this(...args);
    }
}

let beforefn=(args)=>{
    console.log("before",args)
}

let newfn=fn.before(beforefn);//fn是Function的实例，通过原型链找到before方法，执行返回一个箭头函数

newfn("哈哈")
输出：before 哈哈
     say 哈哈
     
     

柯里化函数

柯里化，英语：Currying(果然是满满的英译中的既视感)，是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数而且返回结果的新函数的技术

实现一个参数的累加1

function add(a,b,c){
    return a+b+c;
}
let curring = (fn,...args) => {
  // 需要根据fn的长度 和 我们当前调用时传递的参数做比较， 比较两个数的大小，如果参数个数大于用户传递的参数 需要返回一个新的函数，否则让这个函数执行
  function inner(args) {
    // args 每次用户调用时的参数列表
    // 累计参数  [1] [2,3] =》 【1,2,3】
    return fn.length > args.length ? (...args2) => inner([...args,...args2]): fn(...args);
  }
  return inner(args);
};
// let fn1 = curring(sum);
// let fn2 = fn1(1);
// let r = fn2(2,3);
// console.log(r);

//借用上面的 curring函数
function isType(type,val) {
    return Object.prototype.toString.call(val) === `[object ${type}]`
}
let isString = curring(isType,'String')
let r = isString('4356')
console.log(r);

实现一个参数的累加2

function curring() {
    let params = [];
    let add = function (...args) {
        params = params.concat(args);
        return add;
    }
    add.toString = function () {
        return params.reduce((result, item) => result + item);
    };
    return add;
}
let add = curring();
let res = add(1)(2)(3);
console.log(+res);
// +res 把res转化为数字
// console.log(fn + 1); //会依次调取fn的 Symbol.toPrimitive/valueOf/toString 这三个属性