四种常用类型判断方法

1. typeof

• 缺点: 不能判断对象类型

typeof []  //"object"
typeof {} "object"  
typeof null "object"

2.constructor 可以找到这个变量是谁构造出来的

[].constructor
// ƒ Array() { [native code] }
({}).constructor
//ƒ Object() { [native code] }

3.instanceof 判断谁是谁的实例 proto(不太准确)

4. Object.prototype.toString.call()

// 拿到对象原型的 toString方法把this 指向当前对象
缺点: 不能区分谁是谁的实例

Object.prototype.toString.call()
// "[object Undefined]"
Object.prototype.toString.call('')
// "[object String]"
Object.prototype.toString.call(1)
// "[object Number]"
Object.prototype.toString.call([])
// "[object Array]"
Object.prototype.toString.call({})
// "[object Object]"
Object.prototype.toString.call(null)
// "[object Null]"
Object.prototype.toString.call(NaN)
// "[object Number]"

例子: 实现一个功能判断变量类型

function isType (value, type) {
  return Object.prototype.toString.call(value) === `[object ${type}]`;
}
isType([], 'Array');

细分 实现

function isType (type) {
  return function (value) {
    return Object.prototype.toString.call(value) === `[object ${type}]`;
  }
};
let isArray =  isType('Array');
isArray('hello');  // false 
isArray([]);  // true

通过一个科里化函数 实现通用的科里化方法

function isType (type, value) {
  return Object.prototype.toString.call(value) === `[object ${type}]`;
};
const currying = (fn, arr = []) => {
  let len = fn.length;
  return function (...args) {  // 高阶函数
    arr = [...arr, ...args];
    if (arr.length < len) {
        return currying(fn, arr);  // 递归不停地产生函数
    } else {
      return fn(...arr);
    }
  }
}

let isArray = currying(isType)('Array');
let isString = currying(isType)('String');
console.log(isArray([]));
console.log(isArray('123'));

// 思路 比如实现这个
// function sum (a, b, c, d, e, f) {
//  return a + b + c +d + e + f
//}
// let r = currying(sum)(1,2)(3,4)(5)(6);

------- 我是没太明白最后一个 而且 有点问题...

------- 问题解决了 中间用变量存了一下

function isType (type, value) {
  return Object.prototype.toString.call(value) === `[object ${type}]`;
};
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);
    }
  }
}

let isArray = currying(isType)('Array');
//let isString = currying(isType)('String');
console.log(isArray([]));
console.log(isArray(123));