柯里化(Currying)是把承受多个参数的函数变换成承受一个繁多参数 (最后函数的第一个参数) 的函数,并且返回承受余下的参数且返回后果的新函数的技术。
例如上面的求和函数
function sum(a, b, c, d, e, f) {return a + b + c + d + e + f;}
// 柯里化后,能够这么调用
let r = currying(sum)(a)(b)(c)(d)(e)(f)
// 柯里化函数
const currying = (fn, arr=[]) => {
let len = fn.length;
return function(...args){let concatValue = [...arr, ...args];
if(concatValue.length<len){return currying(fn, concatValue);// 递归不停的产生函数
}else{fn(...concatValue)
}
}
}
咱们能够通过函数柯里化,判断变量的类型
- 罕用的判断类型的办法有四种:
a.typeof 毛病:不能判断对象类型
typeof []==="object"
typeof {} === "object"
b.constructor 能够找到这个变量是通过谁结构进去的
[].constructor === Array
({}).constructor === Object
c.instanceof 判断一个实例是否属于某种类型(判断谁是谁的实例) 原理是__proto__
new String("123") instanceof String
d.Object.prototype.toString.call()
缺点:不能细分谁是谁的实例
Object.prototype.toString.call() "[object Undefined]"
Object.prototype.toString.call('')"[object String]"Object.prototype.toString.call(1)"[object Number]"
2. 写一个函数,应用下面的判断条件,判断某一个变量是某个类型:
function isType(value, type){return Object.prototype.toString.call(value) === `[object ${type}]`
}
// 判断[] 是一个数组
console.log(isType([], 'Array'));
3. 改良下面的办法,能够更直观判断
function isType(type){return function(value){return Object.prototype.toString.call(value) === `[object ${type}]`
}
}
let isArray = isType('Array')
console.log(isArray('hello'));
console.log(isArray([]));
4. 通过一个柯里化函数 实现通用的柯里化办法
const currying = (fn, arr = []) => {
let len = fn.length;
return function (...args) {let concatValue = [...arr, ...args];
if (concatValue.length < len) {return currying(fn, concatValue); // 递归不停的产生函数
} else {return fn(...concatValue);
}
};
};
function isType(type, value) {return Object.prototype.toString.call(value) === `[object ${type}]`;
}
let isArray = currying(isType)("Array");
let isString = currying(isType)("String");
console.log(isArray([]));
console.log(isString("123"));