类型判断函数

const toString = Object.prototype.toString;
  检测参数是否为数组
  @param {Object} val  传入的参数
  @returns {boolean} truefalse

function isArray(val) {
  return toS	tring.call(val) === '[object Array]'
}


  检测参数是否为函数
  @param {} val
  @returns {boolean} truefalse

function isFunction(val) {
  return typeof val === 'function';
}


  检测参数是否为字符串
  @param {Object} val
  @returns {boolean} truefalse

function isString(val) {
  return typeof val === 'string';
}


  检测数据是否为数字
  @param {Object} val
  @returns {boolean} truefalse

function isNumber(val) {
  return typeof val === 'number';
}


  检测参数是否为对象
  @param {Object} val
  @returns {boolean} truefalse

function isObject(val) {
  return toString.call(val) === '[object Object]'
}


  检测参数是否为promise
  @param {Object} val
  @returns {boolean} truefalse

function isPromise(val) {
  return isObject(val) && isFunction(val.then) && isFunction(val.catch);
}


  判断是否相同
  注意点(value !== value && other !== other)判断NaN
  @param {} value
  @param {} other
  @returns {boolean} truefalse

function eq(value, other) {
  return value === other  (value !== value && other !== other)
}


  查询改key的索引
  @param {} array 数组
  @param {} key  想寻找的key
  @param {} start  开始的位置
  @returns 索引

function indexOf(array, key, start = 0) {
  let i = start,
    len = array.length;
  for (; i  len; i++) {
    if (eq(array[i], key)) {
      return i;
    }
  }
   循环过后完全没匹配到
  return -1;
}

  判断当前处在的环境
  浏览器端  服务器端  web worker  微信小程序  node vm( node 的 vm 模块中，也就是沙盒模块,runInContext 方法中，是不存在 window，也不存在 global 变量的)
  @returns {Object}

function curEnv() {
  var root = (typeof self == 'object' && self.self == self && self)
    (typeof global == 'object' && global.global == global && global)
    this  {};
  return root;
}




  缓存
  @param {} fn
  @returns

function cached(fn) {
  var cache = Object.create(null);
  return (function cachedFn(str) {
    var hit = cache[str];
    return hit  (cache[str] = fn(str))
  })
}

  去除字符串两侧的空白字符
  @param {String} str
  @returns {String}

function trim(str) {
  return str.replace(^s, '').replace(s$, '');
}



  遍历数组和对象, 并使用回调函数对键值和键名进行处理
  @param {ObjectArray} obj   可迭代的对象
  @param {Function} fn  回调函数

function forEach(obj, fn) {
   传入的obj不是null或者是undefined
  if (obj === null  typeof obj === 'undefined') {
    return;
  }
   如果不是对象, 强制成为数组
  if (typeof obj !== 'object') {
    obj = [obj];
  }
  if (isArray(obj)) {  是数组array
    for (let i = 0; i  obj.length; i++) {
      fn.call(null, obj[i], i, obj)
    }
  } else {  是 对象object
    for (const key in obj) {
      if (Object.hasOwnProperty.call(obj, key)) { 判断是否是自身属性
        fn.call(null, obj[key], key, obj)
      }
    }
  }
}


  获取26个大写或者小写字母
  @param {string} val 大写或者小写
  @returns 26个大写或者小写字母

function indexList(val = 'A') {
  if (!(val === 'a'  val === 'A')) return;
  var indexList = [];
  var charCodeOfA = val.charCodeAt(0);   获取开始A的 ASCLL值
  for (var i = 0; i < 26; i++) {
    indexList.push(String.fromCharCode(charCodeOfA + i));   String.fromCharCode(65) =A
  }
  return indexList;
};



  @param {} obj 对象
  @returns 二维数组---对象的详细信息

const entries = (obj) = {
  return Object.keys(obj  {})
    .map(key = ([key, obj[key]]));
};


  字母变小写
  @param {} str 字符串
  @returns

function changeLowerCase(str) {
  if (!isString(str)) return;
  return str.toLocaleLowerCase()
}


  字母变大写
  @param {} str 字符串
  @returns

function changeUpperCase(str) {
  if (!isString(str)) return;
  return str.toLocaleUpperCase()
}


  对象深度合并
  @param {Object} 多个对象
  @returns

function deepMerge( obj1, obj2, obj3, ... ) {
  var result = {};
  function assignValue(val, key) {
    if (typeof result[key] === 'object' && typeof val === 'object') {
      result[key] = deepMerge(result[key], val);
    } else if (typeof val === 'object') {
      result[key] = deepMerge({}, val);
    } else {
      result[key] = val;
    }
  }

  for (var i = 0, l = arguments.length; i  l; i++) {
    forEach(arguments[i], assignValue);
  }
  return result;
}
⭐️⭐️⭐️ 好啦！！！本文章到这里就结束啦。⭐️⭐️⭐️
✿✿ ヽ(°▽°)ノ ✿
撒花 🌸🌸🌸🌸🌸🌸
类型判断函数 ​

​

类型判断函数
