• 函数柯里化的简单实现和应用

    一. 柯里化函数实现:

    1. 使用函数的length+arguments+apply的相关知识

    1. var slice = Array.prototype.slice
    2. var curry = function (fn) {
    3.     // 拿到fn参数之后的参数
    4.     var args = slice.call(arguments, 1)
    5.     return _curry.apply(this, [fn, fn.length].concat(args))
    6. }
    7.  
    8. function _curry(fn, len) {
    9.     // 获取fn, len之外的其他参数
    10.     var oArgs = slice.call(arguments, 2);
    11.     return function () {
    12.         var args = oArgs.concat(slice.call(arguments))
    13.         if (args.length >= len) {
    14.             return fn.apply(this, args)
    15.         }
    16.         else {
    17.             return _curry.apply(this, [fn, len].concat(args))
    18.         }
    19.     }
    20. }

    2. 使用函数的length + 扩展运算符...  + apply的知识:

    1. var curry = function (fn, ...arg1) {
    2.     const len = fn.length
    3.     return _curry.apply(this, [fn, len, ...arg1])
    4. }
    5.  
    6. function _curry(fn, len, ...rest1) {
    7.     return function (...rest2) {
    8.         var args = [...rest1, ...rest2]
    9.         if (args.length >= len) {
    10.             return fn.apply(this, args)
    11.         }
    12.         else {
    13.             return _curry.apply(this, [fn, len].concat(args))
    14.         }
    15.     }
    16. }

    实例运用:

    测试计算总和的功能:

    1. function calcSum(num1, num2, num3) {
    2.     return num1 + num2 + num3
    3. }
    4.  
    5. var calcSum2 = function (...args) {
    6.     // const arr = Array.from(arguments);
    7.     const arr = Array.prototype.slice.call(arguments, 0);
    8.     // const arr = Array.of(...args);
    9.     let sum = 0;
    10.     return arr.reduce((obj, cur) => {
    11.         sum = obj + cur
    12.         return sum
    13.     }, sum)
    14. }
    15.  
    16. const log = console.log
    17. var len1 = 1
    18. var calcSumCurry = _curry(calcSum2, 4)
    19. log(calcSumCurry(3, 4, 5, 6))// 18
    20. log(calcSumCurry(3)(4)(5)(6))//18
    21. log(calcSumCurry(3)(4, 5)(6))//18
    22.  
    23. var calcSumCurry = curry(calcSum, 3)
    24. log(calcSumCurry(4, 5))//12 
    25. log(calcSumCurry(4)(5))//12

    每次只要在最后执行空参函数, 就开始计算, 下一次重新开始

    1. function _curry(fn, len) {
    2.     var oArgs = slice.call(arguments, 2);
    3.     return function () {
    4.         var args = oArgs.concat(slice.call(arguments));
    5.         if (arguments.length === 0) {
    6.             if (args.length >= len) {
    7.                 return fn.apply(this, args);
    8.             }
    9.             return console.warn('curry: 参数长度不足')
    10.         }
    11.  
    12.         return _curry.apply(this, [fn, len].concat(args))
    13.     }
    14. }
    15.  
    16. var calcSum2 = function (...args) {
    17.     // const arr = Array.from(arguments);
    18.     const arr = Array.prototype.slice.call(arguments, 0);
    19.     // const arr = Array.of(...args);
    20.     let sum = 0;
    21.     return arr.reduce((obj, cur) => {
    22.         sum = obj + cur
    23.         return sum
    24.     }, sum)
    25. }
    26.  
    27. const log = console.log
    28. var calcSumCurry = _curry(calcSum2, 4)
    29. // 每次都从头开始算
    30. log(calcSumCurry(3, 4, 5, 6)())// 18
    31. log(calcSumCurry(3)(4)(5)(6)())//18
    32. log(calcSumCurry(3)(4, 5)(6)())//18
    33. log(calcSumCurry(3)(4, 5)()) // curry: 参数长度不足

    想要一直累加:

    1. var slice = Array.prototype.slice
    2. function curry(fn, len0) {
    3.     const curArgs = []
    4.     const len = len0 || fn.length
    5.     return function () {
    6.         if (arguments.length === 0) {
    7.             if (curArgs.length >= len) return fn.apply(this, curArgs)
    8.  
    9.             return console.warn('curry: 参数长度不足')
    10.         }
    11.         Array.prototype.push.apply(curArgs, [].slice.call(arguments));
    12.         return arguments.callee;
    13.     }
    14. }
    15.  
    16. var calcSum2 = function (...args) {
    17.     // const arr = Array.from(arguments);
    18.     const arr = Array.prototype.slice.call(arguments, 0);
    19.     // const arr = Array.of(...args);
    20.     let sum = 0;
    21.     return arr.reduce((obj, cur) => {
    22.         sum = obj + cur
    23.         return sum
    24.     }, sum)
    25. }
    26.  
    27. const log = console.log
    28.  
    29. var calcSumCurry = curry(calcSum2, 4)
    30. log(calcSumCurry(3, 4, 5)())// curry: 参数长度不足
    31. log(calcSumCurry(4)(5)())// 21
    32.  
    33.  
    34.

    严格模式下callee会报错, 可以改成:

    1. 'use strict'
    2.  
    3. var slice = Array.prototype.slice
    4. function curry(fn, len0) {
    5.     const curArgs = []
    6.     const arg2 = []
    7.     const len = len0 || fn.length
    8.     let tag = 'start'
    9.     return function start () {
    10.         if (arguments.length === 0) {
    11.             if (curArgs.length >= len) {
    12.                 if(tag === 'end') return console.warn('curry: 参数长度不足, 请核对参数后重试')
    13.                 return fn.apply(this, curArgs)
    14.             }
    15.             
    16.             tag = 'end'
    17.             // 只有第一次执行计算的时候才会判断参数长度是否足够
    18.             return console.warn('curry: 参数长度不足')
    19.         }
    20.         Array.prototype.push.apply(curArgs, [].slice.call(arguments));
    21.         return start;
    22.     }
    23. }
    24.  
    25. var calcSum2 = function (...args) {
    26.     const arr = Array.prototype.slice.call(arguments, 0);
    27.     let sum = 0;
    28.     return arr.reduce((obj, cur) => {
    29.         sum = obj + cur
    30.         return sum
    31.     }, sum)
    32. }
    33.  
    34. const log = console.log
    35.  
    36. var calcSumCurry = curry(calcSum2, 4)
    37. log(calcSumCurry(3, 4, 5)()) // curry: 参数长度不足
    38. log(calcSumCurry(4)(5)()) // 参数长度不足, 请核对参数后重试

    柯里化log方法:

    1. var slice = Array.prototype.slice;
    2. var curry = function (fn, length) {
    3.     var args = slice.call(arguments, 2)
    4.     return _curry.apply(this, [fn, length || fn.length].concat(args))
    5. };
    6.  
    7. function _curry(fn, len) {
    8.     var oArgs = slice.call(arguments, 2);
    9.     return function () {
    10.         var args = oArgs.concat(slice.call(arguments));
    11.         if (args.length >= len) {
    12.             return fn.apply(this, args);
    13.         } else {
    14.             return _curry.apply(this, [fn, len].concat(args))
    15.         }
    16.     }
    17. }
    18.  
    19.  
    20. function log(logLevel, msg) {
    21.     console.log(`${logLevel}:${msg}:::${Date.now()}`)
    22. }
    23.  
    24. //柯里化log 方法
    25. const curryLog = curry(log);
    26.  
    27. const debugLog = curryLog("debug");
    28.  
    29. const errLog = curryLog("error");
    30.  
    31. //复用参数debug
    32. debugLog("testDebug1");//debug:testDebug1:::1696145622354
    33. debugLog("testDebug2");//debug:testDebug2:::1696145622360
    34.  
    35. //复用参数error
    36. errLog("testError1");//error:testError1:::1696145622360
    37. errLog("testError2");//error:testError2:::1696145622360

    二. 非柯里化的实现方式:

    1. 偏函数

    偏函数求和:

    1. // 偏函数
    2. function partial(fn) {
    3.     // 接受fn之外的参数
    4.     const args = [].slice.call(arguments, 1)
    5.     return function () {
    6.         // 接收剩余参数
    7.         const newArgs = args.concat([].slice.call(arguments));
    8.         return fn.apply(this, newArgs)
    9.     }
    10. }
    11.  
    12. function calcSum(...args) {
    13.     const arr = [...args]
    14.     let sum = 0;
    15.     return arr.reduce((obj, cur) => {
    16.         sum = obj + cur
    17.         return sum
    18.     }, sum)
    19. }
    20.  
    21. // 偏函数是固定一部分参数(一个或者多个参数), 将一个N元函数转换为一个N-X函数
    22. const pCalcSum = partial(calcSum, 10);
    23. console.log(pCalcSum(11, 12))//33

    2. 反柯里化

    1. 反柯里化方法的几种写法:

    1. Function.prototype.unCurry=function() {
    2.     var self = this
    3.     return function() {
    4.         return Function.prototype.call.apply(self, arguments)
    5.     }
    6. }
    7.  
    8. Function.prototype.unCurry=function() {
    9.     return this.call.bind(this)
    10. }
    11.  
    12. Function.prototype.unCurry=function() {
    13.     return (...args) => this.call(...args)
    14. }
    15.  
    16.

    2. 反柯里化实例运用:

    1) 克隆数组
    1. function unCurry1(fn) {
    2.     return function(context) {
    3.         // this换成传入的参数context, context之外的参数作为apply的剩余参数
    4.         return fn.apply(context, Array.prototype.slice.call(arguments, 1));
    5.     }
    6. }
    7.  
    8. Function.prototype.unCurry = function () {
    9.     const self = this
    10.     return function() {
    11.         return Function.prototype.call.apply(self, arguments)
    12.     }
    13. }
    14.  
    15.  
    16. // 复制数组
    17. var clone = Array.prototype.slice.unCurry()
    18. var a = [1, 2, 3]
    19. var b = clone(a);
    20.  
    21. console.log('a == b', a === b); // 除非引用一样, 否则都是false
    22. console.log(a, b);//[ 1, 2, 3 ] [ 1, 2, 3 ]
    23.  
    24. var slice = [].slice
    25. var clone = unCurry1(slice)
    26. var a = [1, 2, 3]
    27. var b = clone(a);
    28. console.log('a == b', a === b); // 除非引用一样, 否则都是false
    29. console.log(a, b);//[ 1, 2, 3 ] [ 1, 2, 3 ]
    2) 生成类数组
    1. function unCurry1(fn) {
    2.     return function(context) {
    3.         // this换成传入的参数context, context之外的参数作为apply的剩余参数
    4.         return fn.apply(context, Array.prototype.slice.call(arguments, 1));
    5.     }
    6. }
    7.  
    8. Function.prototype.unCurry = function () {
    9.     const self = this
    10.     return function() {
    11.         return Function.prototype.call.apply(self, arguments)
    12.     }
    13. }
    14. var push = Array.prototype.push.unCurry();
    15. var obj = {}
    16. // console.log(Array.prototype.slice.call({0:1, length: 1}, 0))//[1]
    17. push(obj, 4, 5, 6); // 对象变成了类数组
    18. console.log(obj)//{ '0': 4, '1': 5, '2': 6, length: 3 }
    19.  
    20. var obj = {}
    21. unCurry1([].push)(obj, 7, 8, 9, 10)
    22. console.log(obj)//{ '0': 7, '1': 8, '2': 9, '3': 10, length: 4 }

  • 相关阅读:
    Docker快速安装Oracle 12c
    内网渗透面试问题
    哈希表长度为素数的试证明
    Element UI table 修改定位
    性能优化：Redis使用优化（1）
    SpringBoot集成Redis主从架构实现读写分离（哨兵模式）
    javascript字符串对象之字符串
    第5周学习：ShuffleNet & EfficientNet & 迁移学习
    【23真题】很少见！第6题有点新颖！
    【Vue+element_ui】生成Ubuntu自定义壁纸幻灯片的核心xml文本
  • 原文地址：https://blog.csdn.net/qq_42750608/article/details/133446241