柯理化

柯理化代码演示

function checkAge (age) {
  let min = 18
  return age >= min
}


// 普通的纯函数
function checkAge (min, age) {
  return age >= min
}

柯理化就是讲多个参数转化为几个分开的参数

// 函数的柯里化
function checkAge (min) {
  return function (age) {
    return age >= min
  }
}

// ES6
let checkAge = min => (age => age >= min)

let checkAge18 = checkAge(18)
let checkAge20 = checkAge(20)

console.log(checkAge18(20))
console.log(checkAge18(24))

实现一个柯理化函数

// 生成柯理化函数
function curry(func) {
    return function curriedFn(...args) {
        // 判断函数的参数是否与形参相等
        if (args.length < func.length) {
            return function () {
                // 递归组合参数
                return curriedFn(...args.concat(Array.from(arguments)));
            }
        }
        // 相等则直接执行函数
        return func(...args);
    }
}

function getSum(a, b, c) {
    return a + b + c;
}
let curried = curry(getsum)
curried(1, 2, 3)
curried(1)(2)(3)
curried(1, 2)(3)

函数对象中有很多用到柯理化如 函数中的延迟执行方法  bind

实现mybind

// bind

function fn(a, b, c) {

}
/**
 * context 上下文对象
 */
const f = fn.bind(context, 1, 2)
f(3)

Function.prototype.mybind = function (context, ...args) {
    return (...rest) => this.call(context, ...args, ...rest,)
}

实现mycall

function fn(a, b, c) {
    console.log(this)
    return a + b + c
}
const obj = {
    name: 'xxx'
}
fn.call(obj,1,2,3)
Function.prototype.mycall = function (context, ...args) {
    // 如果对象上下文为null，则赋值window
    context = context || window
    context.fn = this
    const relust = context.fn(...args)
    delete context.fn
    return relust
}

fn.mycall(obj,1,2,3)

这样可以实现，但是会打印出赋值的操作

可以用Object.defineProperty操作，使之不能打印出来

Function.prototype.mycall = function (context, ...args) {
    // 如果对象上下文为null，则赋值window
    context = context || window
    Object.defineProperty(context, "fn", {
        enumerable: false,//不可被枚举
        value: this
    })
    const relust = context.fn(...args)
    delete context.fn
    return relust
}