一. 柯里化函数实现:
1. 使用函数的length+arguments+apply的相关知识
var slice = Array.prototype.slice
var curry = function (fn) {
// 拿到fn参数之后的参数
var args = slice.call(arguments, 1)
return _curry.apply(this, [fn, fn.length].concat(args))
}
function _curry(fn, len) {
// 获取fn, len之外的其他参数
var oArgs = slice.call(arguments, 2);
return function () {
var args = oArgs.concat(slice.call(arguments))
if (args.length >= len) {
return fn.apply(this, args)
}
else {
return _curry.apply(this, [fn, len].concat(args))
}
}
}
2. 使用函数的length + 扩展运算符... + apply的知识:
var curry = function (fn, ...arg1) {
const len = fn.length
return _curry.apply(this, [fn, len, ...arg1])
}
function _curry(fn, len, ...rest1) {
return function (...rest2) {
var args = [...rest1, ...rest2]
if (args.length >= len) {
return fn.apply(this, args)
}
else {
return _curry.apply(this, [fn, len].concat(args))
}
}
}
实例运用:
测试计算总和的功能:
function calcSum(num1, num2, num3) {
return num1 + num2 + num3
}
var calcSum2 = function (...args) {
// const arr = Array.from(arguments);
const arr = Array.prototype.slice.call(arguments, 0);
// const arr = Array.of(...args);
let sum = 0;
return arr.reduce((obj, cur) => {
sum = obj + cur
return sum
}, sum)
}
const log = console.log
var len1 = 1
var calcSumCurry = _curry(calcSum2, 4)
log(calcSumCurry(3, 4, 5, 6))// 18
log(calcSumCurry(3)(4)(5)(6))//18
log(calcSumCurry(3)(4, 5)(6))//18
var calcSumCurry = curry(calcSum, 3)
log(calcSumCurry(4, 5))//12
log(calcSumCurry(4)(5))//12
每次只要在最后执行空参函数, 就开始计算, 下一次重新开始
function _curry(fn, len) {
var oArgs = slice.call(arguments, 2);
return function () {
var args = oArgs.concat(slice.call(arguments));
if (arguments.length === 0) {
if (args.length >= len) {
return fn.apply(this, args);
}
return console.warn('curry: 参数长度不足')
}
return _curry.apply(this, [fn, len].concat(args))
}
}
var calcSum2 = function (...args) {
// const arr = Array.from(arguments);
const arr = Array.prototype.slice.call(arguments, 0);
// const arr = Array.of(...args);
let sum = 0;
return arr.reduce((obj, cur) => {
sum = obj + cur
return sum
}, sum)
}
const log = console.log
var calcSumCurry = _curry(calcSum2, 4)
// 每次都从头开始算
log(calcSumCurry(3, 4, 5, 6)())// 18
log(calcSumCurry(3)(4)(5)(6)())//18
log(calcSumCurry(3)(4, 5)(6)())//18
log(calcSumCurry(3)(4, 5)()) // curry: 参数长度不足
想要一直累加:
var slice = Array.prototype.slice
function curry(fn, len0) {
const curArgs = []
const len = len0 || fn.length
return function () {
if (arguments.length === 0) {
if (curArgs.length >= len) return fn.apply(this, curArgs)
return console.warn('curry: 参数长度不足')
}
Array.prototype.push.apply(curArgs, [].slice.call(arguments));
return arguments.callee;
}
}
var calcSum2 = function (...args) {
// const arr = Array.from(arguments);
const arr = Array.prototype.slice.call(arguments, 0);
// const arr = Array.of(...args);
let sum = 0;
return arr.reduce((obj, cur) => {
sum = obj + cur
return sum
}, sum)
}
const log = console.log
var calcSumCurry = curry(calcSum2, 4)
log(calcSumCurry(3, 4, 5)())// curry: 参数长度不足
log(calcSumCurry(4)(5)())// 21
严格模式下callee会报错, 可以改成:
'use strict'
var slice = Array.prototype.slice
function curry(fn, len0) {
const curArgs = []
const arg2 = []
const len = len0 || fn.length
let tag = 'start'
return function start () {
if (arguments.length === 0) {
if (curArgs.length >= len) {
if(tag === 'end') return console.warn('curry: 参数长度不足, 请核对参数后重试')
return fn.apply(this, curArgs)
}
tag = 'end'
// 只有第一次执行计算的时候才会判断参数长度是否足够
return console.warn('curry: 参数长度不足')
}
Array.prototype.push.apply(curArgs, [].slice.call(arguments));
return start;
}
}
var calcSum2 = function (...args) {
const arr = Array.prototype.slice.call(arguments, 0);
let sum = 0;
return arr.reduce((obj, cur) => {
sum = obj + cur
return sum
}, sum)
}
const log = console.log
var calcSumCurry = curry(calcSum2, 4)
log(calcSumCurry(3, 4, 5)()) // curry: 参数长度不足
log(calcSumCurry(4)(5)()) // 参数长度不足, 请核对参数后重试
柯里化log方法:
var slice = Array.prototype.slice;
var curry = function (fn, length) {
var args = slice.call(arguments, 2)
return _curry.apply(this, [fn, length || fn.length].concat(args))
};
function _curry(fn, len) {
var oArgs = slice.call(arguments, 2);
return function () {
var args = oArgs.concat(slice.call(arguments));
if (args.length >= len) {
return fn.apply(this, args);
} else {
return _curry.apply(this, [fn, len].concat(args))
}
}
}
function log(logLevel, msg) {
console.log(`${logLevel}:${msg}:::${Date.now()}`)
}
//柯里化log 方法
const curryLog = curry(log);
const debugLog = curryLog("debug");
const errLog = curryLog("error");
//复用参数debug
debugLog("testDebug1");//debug:testDebug1:::1696145622354
debugLog("testDebug2");//debug:testDebug2:::1696145622360
//复用参数error
errLog("testError1");//error:testError1:::1696145622360
errLog("testError2");//error:testError2:::1696145622360
二. 非柯里化的实现方式:
1. 偏函数
偏函数求和:
// 偏函数
function partial(fn) {
// 接受fn之外的参数
const args = [].slice.call(arguments, 1)
return function () {
// 接收剩余参数
const newArgs = args.concat([].slice.call(arguments));
return fn.apply(this, newArgs)
}
}
function calcSum(...args) {
const arr = [...args]
let sum = 0;
return arr.reduce((obj, cur) => {
sum = obj + cur
return sum
}, sum)
}
// 偏函数是固定一部分参数(一个或者多个参数), 将一个N元函数转换为一个N-X函数
const pCalcSum = partial(calcSum, 10);
console.log(pCalcSum(11, 12))//33
2. 反柯里化
1. 反柯里化方法的几种写法:
Function.prototype.unCurry=function() {
var self = this
return function() {
return Function.prototype.call.apply(self, arguments)
}
}
Function.prototype.unCurry=function() {
return this.call.bind(this)
}
Function.prototype.unCurry=function() {
return (...args) => this.call(...args)
}
2. 反柯里化实例运用:
1) 克隆数组
function unCurry1(fn) {
return function(context) {
// this换成传入的参数context, context之外的参数作为apply的剩余参数
return fn.apply(context, Array.prototype.slice.call(arguments, 1));
}
}
Function.prototype.unCurry = function () {
const self = this
return function() {
return Function.prototype.call.apply(self, arguments)
}
}
// 复制数组
var clone = Array.prototype.slice.unCurry()
var a = [1, 2, 3]
var b = clone(a);
console.log('a == b', a === b); // 除非引用一样, 否则都是false
console.log(a, b);//[ 1, 2, 3 ] [ 1, 2, 3 ]
var slice = [].slice
var clone = unCurry1(slice)
var a = [1, 2, 3]
var b = clone(a);
console.log('a == b', a === b); // 除非引用一样, 否则都是false
console.log(a, b);//[ 1, 2, 3 ] [ 1, 2, 3 ]
2) 生成类数组
function unCurry1(fn) {
return function(context) {
// this换成传入的参数context, context之外的参数作为apply的剩余参数
return fn.apply(context, Array.prototype.slice.call(arguments, 1));
}
}
Function.prototype.unCurry = function () {
const self = this
return function() {
return Function.prototype.call.apply(self, arguments)
}
}
var push = Array.prototype.push.unCurry();
var obj = {}
// console.log(Array.prototype.slice.call({0:1, length: 1}, 0))//[1]
push(obj, 4, 5, 6); // 对象变成了类数组
console.log(obj)//{ '0': 4, '1': 5, '2': 6, length: 3 }
var obj = {}
unCurry1([].push)(obj, 7, 8, 9, 10)
console.log(obj)//{ '0': 7, '1': 8, '2': 9, '3': 10, length: 4 }