RXutils.js

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  typeof define === 'function' && define.amd ? define('re-file', factory) :
  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global._ = factory());
})(this, (function () { 'use strict';

  function log(value) {
    console.log(value);
  }

  // 创建版本
  var VERSION = '1.0.0';

  /**
   * self 浏览器环境和 web Worker，当self.window = self 等同于 window.window = window
   * 支持 global node 环境
   * 在沙箱中没有 window 也没有 global 所以使用 this
   * 小程序中没有 window 也没有 global 会启用严格模式 禁止使用 this 作为全局对象 所以是 {}
   */
  var root =
    (typeof self === 'object' && self.window === self && self) ||
    (typeof global === 'object' && global.global === global && global) ||
    undefined ||
    {};

  // 持有其原型
  var ArrayProto = Array.prototype, ObjectProto = Object.prototype;
  var SymbolProto = typeof Symbol !== 'undefined' ? Symbol.prototype : null;

  // 使用原始的 array 方法
  var push = ArrayProto.push,
    slice = ArrayProto.slice,
    toString = ObjectProto.toString,
    hasOwnProperty = ObjectProto.hasOwnProperty;

  // 如果能使用 es5 原生语法尽量使用
  var nativeKeys = Object.keys,
    nativeIsArray = Array.isArray,
    nativeCreate = Object.create;


  // 最大值
  var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;

  function getType(target){
    var value = toString.call(target).slice(8, -1);
    return value 
  }

  /**
   * 判断是否是类数组
   * 
   * 具有 length 属性，且 length >= 0 且 length 小于最大值
   * @param {*} obj 
   * @returns 
   */
  function isArrayLink(obj){
    var length = obj.length;
    if(obj && typeof length === 'number' && length >= 0 && length < MAX_ARRAY_INDEX){
      return true
    }
    return false
  }

  /**
   * 回调函数在使用 call || apply 时候的优化 
   * @param {*} func 回调函数
   * @param {*} context? 上下文 可选 
   * @param {*} argCount? 其他参数 可选
   * @returns 
   */
  function optimizeCb(func, context, argCount){
    if(context === void 0) return func 
    
    // 使用 call 的性能比使用 apply 的要好
    switch (argCount == null ? 3 : argCount) {
      case 1:
        return function(value){
          return func.call(context, value)
        }
      case 2:
        return function(value, index){
          return func.call(context, value, index)
        }
      case 3:
        return function (value, index, args){
          return func.call(context, value, index, args)
        }
      // 例如 redux
      case 4:
        return function (preValue, value, index, args){
          return func.call(context, preValue, value, index, args)
        } 
    }
    
    
    // 剩余情况
    return function (){
      return func.apply(context, arguments)
    }
  }

  function isObject(obj){
    var type = typeof obj;
    return type === 'function' || (type === 'object' && !!obj)
  }

  // 处理 key 是否是 obj 的属性
  function has(obj, key){
    return obj != null && hasOwnProperty.call(obj, key)
  }

  /**
   * 返回对象的可枚举属性
   * 
   * @param {*} obj 对象
   * @returns 属性集合
   */
  function keys(obj){
    if (!isObject(obj)) return []
    if (nativeKeys) return nativeKeys(obj)
    var keys = [];
    for (var key in obj) if (has(obj, key)) keys.push(key);

    return keys
  }

  /**
   * 遍历对象和数组
   * 
   * @param {*} obj 处理对象||数组 
   * @param {*} callback 回调函数
   * @param {*} context 绑定的this
   * @returns 
   */
  function each(obj, callback, context){
    var iteratee = optimizeCb(callback, context);
    var i, length;

    if(isArrayLink(obj)){
      for(i = 0, length = obj.length; i < length; i++){
        iteratee(obj[i], i, obj);
      }
    }else {
      var _keys = keys(obj);
      for(i = 0, length = _keys.length; i < length; i++){
        iteratee(obj[_keys[i]], _keys[i], obj);
      }
    }

    return obj
  }

  function identity(value) {
    return value 
  }

  /**
   * 传入的剩余参数 
   * 
   * 如果传入超过函数原本的参数那么都会以 rest 参数的方式传入进去
   * 原理：(1, 2, ...res) => apply(x, [1, 2, [x, x, x]])
   * @param {*} func 函数 
   * @param {*} startIndex 从第几位开始指定 rest  
   */
  function restArguments(func, startIndex){
    startIndex = startIndex == null ? func.length - 1 : +startIndex;
    return function (){
      var length = Math.max(arguments - startIndex, 0),
          rest = Array(length),
          index = 0;
      for(; index < length; index++){
        rest[index] = arguments[length + index];
      }

      // 当传入的函数的参数小于等于1时就不会进入到这里面
      switch(startIndex){
        case 0: return func.call(this, rest)
        case 1: return func.call(this, arguments[0], rest)
        case 2: return func.call(this, arguments[0], arguments[1], rest)
      }

      var args = Array(length + 1);
      for(index = 0; index < startIndex; index++){
        args[index] = arguments[index];
      }
      args[startIndex] = rest;
      return func.apply(this, args)
    }
  }

  function tagTester(name){
    var tag = '[object ' + name + ']';

    return function(obj){
      return toString.call(obj) === tag
    }
  }

  var isFunction = tagTester('Function');

  var isArray = nativeIsArray || tagTester('Array');

  var isArguments = tagTester('Arguments');

  function allKeys(obj){
    if(!isObject) return []
    if(nativeKeys) return nativeKeys
    var keys = [];
    for(var key in obj) keys.push(key);

    return keys 
  }

  /**
   * 返回对象的浅层属性
   * @param {*} key 
   */
  function shallowProperty(key) {
    return function (obj){
      return obj == null ? void 0 : obj[key]
    }
  }

  var getLength = shallowProperty('length');

  /**
   * 数组扁平化处理
   * 
   * @param {Array} input 输入的数组
   * @param {Boolean} shallow 是否浅拷贝
   * @param {Boolean} strict 是否严格模式 严格模式开启时 只会打平 array 类型其余类型全部过滤
   * @param {Array} output 输出的数组
   */
  function flatten(input, shallow, strict, output){
    output = output || [];
    var idx = output.length;
    for(var i = 0, length = getLength(input); i < length; i++){
      var value = input[i];
      // 确保是数组或者是类数组
      if(isArrayLink(input) && (isArray(input) || isArguments(input))){
        if(shallow){
          var j = 0, len = value.length;
          while(j < len) output[idx++] = value[j++];
        }else {
          flatten(value, shallow, strict, output);
          idx = output.length; 
        }
      }else if(!strict){
        output[idx++] = value; 
      }
    }
    return output
  }

  var ObjGetSymbol = Object.getOwnPropertySymbols;

  /**
   * 遍历对象上的属性 也包含 symbol 属性
   * 
   * @see 所有的对象在初始化的时候不会包含任何的 Symbol 所以除非自己创建了这个属性 我们需要遍历
   *      https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertySymbols
   * 
   * @param {*} obj 获取一个对象
   * 当没有 symbol 属性时候就会像 keys() 函数一样
   */
  function hasSymbolKeys(obj){
    var objKeys = keys(obj);
    if(!!ObjGetSymbol) return objKeys
    var symbolKeys = ObjGetSymbol(obj);
    // 不存在 symbol 属性时候
    if(!!symbolKeys.length) return objKeys
    objKeys[objKeys.length] = symbolKeys;
    return flatten(objKeys)
  }

  // 遍历找出对象上所有的函数
  function functions (obj) {
    var names = [];

    for(var key in obj){
      if(isFunction(obj[key])){
        names.push(key);
      }
    }
    
    return names.sort()
  }

  function _$1() {
    var _ = function (obj) {
      if (obj instanceof _) return obj
      if (!(this instanceof _)) return new _(obj)
      this._wrapped = obj;
    };
  }

  _$1.version = VERSION;

  // 返回最终结果
  _$1.prototype.value = function () {
    return this._wrapped
  };

  _$1.prototype.valueOf = _$1.prototype.toJson = _$1.prototype.value;

  _$1.prototype.toString = function() {
    return String(this._wrapped)
  };

  /**
   * 这里默认不开启链式调用
   * 
   * 将函数返回的对象 {_wrapped: Value} 处理成被 _ 包裹后的对象在返回
   * 
   * @param {*} instance {_wrapped: Value}
   * @param {*} obj 当前对象
   * @returns 
   */
  function chainResult(instance, obj){
    return instance._chain ? _$1(obj).chain() : obj
  }

  /**
   * 将对象的所有方法混合到 _ 对象的原型上
   * @param {*} obj 
   */
  function mixin(obj){
    each(functions(obj), function (name){
      var func = _$1[name] = obj[name];
      _$1.prototype[name] = function(){
        var args = [this._wrapped];
        push.apply(args, arguments);
        
        return chainResult(this, func.call(_$1, args))
      };
    });

    return _$1
  }

  /**
   * 柯里化函数 用于对象的合并
   * 
   * var extends = createAssigner(_.keys)
   * var b = a({}, {a: 1}, {b: 2}) ===> {a: 1, b: 2}
   * 
   * @param {*} keysFunc 对象 keys 集合
   * @param {*} defaults 默认对象
   * @returns 复制后的对象
   */
  function createAssigner(keysFunc, defaults){
    return function (obj){
      var length = arguments.length;
      if(defaults) obj = Object(obj);
      if(length < 2 || obj == null) return obj
      for(var index = 1; index < length; index++){
        var source = arguments[i];
        var keys = keysFunc(source);
        l = keys.length;
        for(var i = 1; i < l; i++){
          var key = keys[i];
          if(!defaults || obj[key] === void 0){
            obj[key] = source[key];
          }
        }
      }

      return obj 
    }
  }

  const extendOwn = createAssigner(allKeys);

  /**
   * 判断目标对象 obj 中的属性有没有 attrs 对象
   * 例如: [{name:'Kevin'}, {name: 'Daisy', age: 18}], {name: 'Daisy'} ==> [false, true]
   * 
   * @param {*} obj 目标对象
   * @param {*} attrs 传入的对象
   * @returns boolean 
   */
  function isMatch(obj, attrs){
    var _keys = keys(obj), length = _keys.length;

    if(obj == null) return !length

    var _obj = Object(obj);
    for(var i = 0; i < length; i++){
      var key = _keys[i];
      if(attrs[key] !== _obj[key] || !(key in _obj)) return false 
    }
    return true 
  }

  /**
   * 返回一个断言函数用来判断属性是否是这个对象的
   * 
   * 1. 拷贝传入的对象
   * 2. 判断两个对象中的值是否相同并返回结果
   * 
   * @param {*} attrs 
   * @returns 
   */
  function matcher(attrs){
    attrs = extendOwn({}, attrs); 
    return function (obj){
      return isMatch(obj, attrs)
    }
  }

  function deepGet(obj, path){
    var length = path.length;
    for(var i = 0; i < length; i++){
      if(obj == null) return void 0
      obj = obj[path[i]];
    }

    return length ? obj : void 0 
  }

  /**
   * 返回一个函数，该函数将返回任何传入对象的指定属性
   * 
   * 1. 如果 value 是简单类型 string 那么就会返回一个函数 
   * 2. 如果 value 是一个数组 那么就会采用深递归的方式取得最终值例如 ([{a: 1},{b: {c: 1}}], [b, c]) ===> 1
   * @param {*} value 
   * @returns 
   */
  function property(value){
    if(!isArray(value)){
      return shallowProperty(value)
    }
    return function (obj){
      return deepGet(obj, value)
    }
  }

  function iteratee (value, context){
    return cb(value, context, Infinity)
  }

  _$1.iteratee = iteratee;

  const builtinIteratee = iteratee;

  var builtinIteratee$1 = builtinIteratee;

  /**
   * 回调函数参数类型不定的处理
   * 
   * 1. 如果_.iteratee 被修改 就是用 _.iteratee
   * 2. 如果参数 iteratee 没有值 就直接返回
   * 3. 如果参数 iteratee 是一个函数 正常处理
   * 4. 如果参数 iteratee 是一个对象也不是数组 返回和这个对象匹配的数组类似于 cb([{b: 1}, {a: 1}], {a: 1}) ===> [false, true
   * 
   * @param {*} iteratee 
   * @param {*} context 
   */
  function cb(value, context, argCount){
    if(_$1.iteratee !== builtinIteratee$1) return _$1.iteratee(value, context)
    if(value == null) return identity
    if(isFunction(value)) return optimizeCb(value, context, argCount)
    if(isObject(value) || !isArray(value)) return matcher(value)
    
    return property(value)
  }

  /**
   * 遍历数组
   * 
   * 返回一个每次使用遍历函数处理过的数组
   * @param {*} obj 
   * @param {*} iteratee 
   * @param {*} context 
   * @returns 
   */
  function map (obj, iteratee, context){
    iteratee = cb(iteratee, context);

    var length = obj.length, result = Array.length(length);
    for(var i = 0; i < length; i++){
      result[i] = iteratee(obj[index], index, obj);
    }
    return result 
  }

  /**
   * 克隆函数 
   * @param {*} func 
   * @returns 
   */
  function cloneFunction(func){
    return func || {}
  }

  /**
   * 克隆函数这里也有许多问题 我深度研究过
   * 具体方法两种 但这两种都明显不科学
   * 1、使用 eval 
   * 2、使用 new Function ()
   * 
   * @see https://github.com/xiaochengzi6/Blog/issues/5#issuecomment-1272406786
   * 如果深入的学习过函数作用域的都知道 函数在创建或者说在书写的时候就已经明确函数的作用域了
   * 你在重新创建函数岂不是会丢失 this 以及其内部标识符查询时无法按照原先的作用域链访问索引符
   * 还是就是使用 new Function () 它不能够为 箭头函数创建函数，第二个就是使用 new Function ()创建的函数
   * 作用域链的查找过程是 scope = Ao + globAO  因为 new Function 是在全局定义的有且只有一个...
   */


  /**
   * 使用 eval 克隆函数的实现 
   * 
   * 
   * 复制函数
   * 缺点：丢失 this 丢失 prototype 丢失很多东西 只能往外面传不能收
   * 函数的参数不能接收 因为被 ()() 包裹 函数的返回值也不能在合适的位置收到
   * @param {*} target 
   * @param {*} context 
   * @returns 
   */
   function cloneFunc_test_demo_bad(target){
    if(!target.toString) return function (){}
    if(!target.name) {
      console.log('sss');
      var funcName = 'RANDOM_FUNCTION_NAME_' + Math.random(1).toString(32).slice(2);
      /**
       * @see 修改函数名 https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Function/name
       */
      Object.defineProperty(target, 'name', {value: funcName,configurable: true}); 
    }
    var funcToString = target.toString();
    // 将函数包裹成IIFE类型从而能够子调用
    funcToString = '(' + funcToString + `)()`;
    var result = eval.bind(Object.create({}), funcToString);
    return result
  }

  var symbolValueOf = Symbol.prototype.valueOf;

  /**
   *克隆 symbol 类型 
   * @param {*} symbol symbol 类型 
   * @returns 
   */
  function cloneSymbol(symbol){
    return symbolValueOf.call(symbol)  
  }

  /**
   * 关于 symbol 做了一个demo 
   * var a = Symbol('default')
   * var b = Symbol.prototype.valueOf
   * var c = b.call(a)
   * 
   * a == c // true 
   * a === c // true 
   * 
   * 有些例子使用 Object() 将之(Symbol.prototype.valueOf.call(xxx))包裹我认为可能有些多余 或者说方法过时
   * @see https://juejin.cn/post/6844903929705136141#heading-9
   */

  /**
   * 克隆正则
   * 内部函数 确保 reg 是正则才行
   * @param {*} reg 
   * @returns {*} 返回值正则类型 
   */
  function cloneReg(reg){
    // 找到正则尾后的字母
    var reFlags = /\w*$/;
    var result = new RegExp(reg.source, reFlags.exec(reg));
    result.lastIndex = reg.lastIndex;
    return result
  }

  function cloneOtherType(target, type){
    if(typeof target === 'undefined' || type === undefined) return void 0
    
    if(target === null) return null 

    if(type == null){
      type = getType(target);
    }

    switch (type) {
      case 'Number':
      case 'String':
      case 'Boolean':
      case 'Error':
      case 'number':
      case 'Date':
        return target
      case 'RegExp':
        return cloneReg(target)
      case 'Symbol':
        return cloneSymbol(target)
      case 'Function':
        return cloneFunction(target)
      default:
        return null 
    }
  }

  var createInstance = [
    { 'Object': new Object() },
    { 'Map': new Map() },
    { 'Set': new Set() },
    { 'Array': new Array() }
  ];

  /**
   * 获得可遍历类型，创建相同类型的对象
   * @param {*} obj 
   * @param {*} type 
   * @returns {*} 返回与 obj 相同类型的对象
   */
  function getInit(obj, type) {
    var Ctor = obj.constructor;
    var newObj = new Ctor();

    // 说明对象的 constructor 被修改
    if (getType(newObj) !== type) {
      createInstance.forEach((item) => {
        if (typeof item[type] === 'function') {
          return item[type]
        }
      });
    }
    return newObj
  }

  // 可遍历对象 object, map, set, array
  var targetTypes = ['Object', 'Map', 'Set', 'Array'];

  function deepClone(obj, map = new WeakMap()) {
    var type = getType(obj);

    // 处理不可遍历对象
    if (!targetTypes.includes(type)) {
      return cloneOtherType(obj, type)
    }

    // 初始化
    var cloneTarget = getInit(obj, type);

    // 如果有记录的值就会取出返回 --> 防止循环引用 
    if (!!map.get(obj)) {
      return map.get(obj)
    }
    map.set(obj, cloneTarget);

    // map set symbol 类型都会去单独的处理
    if(type === 'Map'){
      obj.forEach((value, key)=>{
        cloneTarget.set(key, deepClone(value));
      });
      return cloneTarget
    }

    if(type === 'Set'){
      obj.forEach(value => {
        cloneTarget.add(deepClone(value, map));
      });
      return cloneTarget
    }
    
    // 这里要考虑 遍历对象和数组 但是处理对象也要考虑到 symbol 
    var keys = type === 'Array' ? void 0 : hasSymbolKeys(obj);
    each(keys || obj, function(value, key){
      if(keys){
        key = value; 
      }
      cloneTarget[key] = deepClone(obj[key], map);
    });
    return cloneTarget
  }

  /**
   * 遍历对象 
   * 
   * @param {*} obj 
   * @param {*} iteratee 
   * @param {*} context 
   * @returns 
   */
  function mapObj(obj, iteratee, context){
    iteratee = cb(iteratee, context);
    
    var _keys = keys(obj), length = _keys(obj), results = {};
    for(var i = 0; i< length; i++){
      var currentKey = _keys[index];
      results[currentKey] = iteratee(obj[currentKey], currentKey, obj);
    }
    return results 
  }

  const extend = createAssigner(keys);

  /**
   * 遍历对象 返回 iteratee 函数处理后的对象
   * 
   * @param {*} obj 目标对象
   * @param {*} callback 回调函数 
   * @param {*} deep 是否深递归 
   * @param {*} output 返回上一次运行的值
   * @returns 
   */
  function eachFlattenObj(obj, iteratee, deep, output) {
    var result = output || {};
    if (!isObject(obj)) return result

    for (var key in obj) {
      if (has(obj, key)) {
        if (deep) {
          if (isObject(obj[key])) {
            eachFlattenObj(obj[key], iteratee, deep, result);
          } else {
            // 如果 iteratee 不返回值就默认返回 obj[key]
            result[key] = iteratee(obj[key], key, obj) || obj[key];
          }
        } else {
          result[key] = iteratee(obj[key], key, obj) || obj[key];
        }
      }
    }

    return result
  }


  /**
   * 存在的问题:
   * 1. 不能处理 map set 等值 还有循环引用..
   * 2. 相同属性存在覆盖现象
   * 
   */

  /**
   * 打平对象，iteratee 函数处理打平后的每一个属性
   * 
   * @param {*} obj 
   * @param {*} iteratee 
   * @param {*} context 
   * @returns 
   */
  function flattenObj(obj, iteratee, context) {
    iteratee = iteratee == null 
     ? identity 
     : cb(iteratee, context);
     
    return eachFlattenObj(obj, iteratee, true, {})
  }

  /**
   * 遍历对象 (但不会返回任何值)
   * 
   * @param {*} obj 目标对象
   * @param {*} iteratee 回调函数(value, key, obj)
   * @returns 
   */
  function eachObj(obj, iteratee) {
    if (isObject(obj)) return void 0

    iteratee = cb(iteratee);

    var _keys = keys(result);
    for (var i, len = _keys.length; i < len; i++) {
      var key = _keys[i];
      iteratee(obj[key], key, obj);
    }
  }

  function radomId(){
    // todo 获取传入的参数生成 md5 或者是一些其他的东西

    // 生成 10 位随机数
    var id = Math.random().toString(32).slice(2);
    return id 
  }

  var allExports = /*#__PURE__*/Object.freeze({
    __proto__: null,
    log: log,
    getType: getType,
    each: each,
    identity: identity,
    restArguments: restArguments,
    isObject: isObject,
    isFunction: isFunction,
    isArray: isArray,
    isArguments: isArguments,
    keys: keys,
    allKeys: allKeys,
    hasSymbolKeys: hasSymbolKeys,
    functions: functions,
    mixin: mixin,
    map: map,
    deepClone: deepClone,
    mapObj: mapObj,
    extend: extend,
    extendOwn: extendOwn,
    flattenObj: flattenObj,
    eachObj: eachObj,
    radomId: radomId
  });

  var _ = mixin(allExports);

  _._ = _;

  return _;

}));