utils-＞js-＞ecma-＞object

/**
 * 深度合并对象
 * Merges two objects, giving the last one precedence
 * @param {Object} target
 * @param {(Object|Array)} source
 * @returns {Object}
 */
export function objectMerge(target, source) {
  if (typeof target !== 'object') {
    target = {}
  }
  if (Array.isArray(source)) {
    return source.slice()
  }
  Object.keys(source).forEach(property => {
    const sourceProperty = source[property]
    if (typeof sourceProperty === 'object') {
      target[property] = objectMerge(target[property], sourceProperty)
    } else {
      target[property] = sourceProperty
    }
  })
  return target
}



/**
 * 通过拷贝属性的方式,对象深拷贝
 * 知识点:
 * 不使用json拷贝的原因就是RegExp、Date、函数 ,symbol, undefined不是 JSON 安全的
 * typeof == object的只有object 和array对象
 * 思路：
 *  1.首先排除简单对象
 *  2.考虑Array，根据source.constructor确定初始类型
 *  3.循环，补充这个初始类型
 * @param {Object} source
 * @returns {Object}
 */
export function deepClone(source) {
  if (!source && typeof source !== 'object') {
    throw new Error('error arguments', 'deepClone')
  }
  const targetObj = source.constructor === Array ? [] : {}
  Object.keys(source).forEach(keys => {
    if (source[keys] && typeof source[keys] === 'object') {
      targetObj[keys] = deepClone(source[keys])
    } else {
      targetObj[keys] = source[keys]
    }
  })
  return targetObj
}

/*
参数大驼峰命名改成小驼峰命名
入参: 参数
返参：无
auth： 杨超
time： 2019/04/
*/
export function changeCamelCased(data) {
  if (Array.isArray(data)) {
    data.map(function (outervalue) {
      console.log(Object.prototype.toString.call(outervalue))
      if (Object.prototype.toString.call(outervalue) == '[object Object]') {
        console.log(1)
        let objArr = Object.keys(outervalue); //Object.keys(data[index]);
        objArr.map(function (innerValue) {
          outervalue[innerValue.substring(0, 1).toLowerCase() + innerValue.substring(1)] =
            outervalue[innerValue];
          delete outervalue[innerValue];
        });
      } else if (Array.isArray(outervalue)) {
        console.log(2)
        changeCamelCased(outervalue);
      };
    });
  } else if (Object.prototype.toString.call(data) == '[object Object]') {
    let objArr = Object.keys(data); //Object.keys(data[index]);
    objArr.map(function (innerValue) {
      data[innerValue.substring(0, 1).toLowerCase() + innerValue.substring(1)] = data[innerValue];
      delete data[innerValue];
    });
  };

  return data;
};

/**
 * 是对象的情况，判断是不是空对象，分从属性和json形式两个方向
 * @export
 * @param  {any} obj 
 * @return {void}
 */
export function empty_Obj(obj) {
  // 1.1从属性入手
  // for (var i in obj) { // 如果不为空，则会执行到这一步，返回true
  //     return true
  // }
  // return false // 如果为空,返回false

  // 1.2
  // var a = {}
  // Object.keys(a) // []

  // if (Object.keys(object).length === 0) {
  //     return false // 如果为空,返回false
  // }
  // return true // 如果不为空，则会执行到这一步，返回true

  if (JSON.stringify(obj) === '{}') {
    return false // 如果为空,返回false
  }
  return true
};

/**
 * 对象属性为数字，对象属性排序
 * @export
 * @param  {any} obj 
 * @return 
 */
export function sortObjProperties(obj) {
  var objp = Object.keys(obj).sort(function (a, b) {
    return Number(a) - Number(b)
  });
  var newObj = {};
  objp.length > 0 && objp.forEach((v, i) => {
    newObj[String(Number(objp[i]))] = obj[objp[i]]
  });
  return newObj;
};


/**
 * 对象中属性中键值相同的属性合并，并以，符号分隔
 * @export
 * @param  {any} requestParams 
 * @return 
 */
export function mergeObjProperties(requestParams) {
  //用于保存最后格式化的对象
  var formatRequestParams = {};
  //通过keys去对应属性值做比较
  var keys = Object.keys(requestParams);
  //不污染原对象的keys所以另外声明一个用于保存并且初始化第一个地域
  var formatKeys = [];
  formatKeys.push(keys[0]);

  var currentKey = 0;
  formatRequestParams[keys[0]] = requestParams[keys[0]];
  //遍历原对象去和新对象属性值一一比较，相同则更新新对象属性和其对应值，不同则添加新的属性即对应值
  for (var i = 1; i < keys.length; i++) {

    if (equal(formatRequestParams[formatKeys[currentKey]], requestParams[keys[i]])) {
      formatRequestParams[formatKeys[currentKey] + ',' + keys[i]] = requestParams[keys[i]];
      //删除新对象原有属性值
      delete formatRequestParams[formatKeys[currentKey]];
      //更新新对象的属性值
      formatKeys[currentKey] = formatKeys[currentKey] + ',' + keys[i]

    } else {
      currentKey++;
      formatKeys.push(keys[i]);
      formatRequestParams[formatKeys[currentKey]] = requestParams[keys[i]];
    }
  }

  return formatRequestParams;
}

// 判断属性键名是否相同
function equal(a, b) {

  // 判断数组的长度
  if (a.length !== b.length) {
    return false
  } else {
    // 循环遍历数组的值进行比较
    for (let i = 0; i < a.length; i++) {
      if (a[i].toString() !== b[i].toString()) {
        return false
      }
    }
    return true;
  }
}

/**
 * 向类(构造函数)添加函数
 * @export
 * @param  {any} obj 
 * @param  {any} funArr 
 * @return 
 */
export function addFun(obj, ...funArr) {
  return Object.assign(obj.prototype, {
    ...funArr
  })
}



/**
 * 剔除多余的属性,或者保留部分属性
 */
export function  eliminateRedundantAttr(source, attArr, containbl) {
  let newSource = deepClone(source);

  if (containbl) {
      attArr.forEach(v => {
          if (newSource.hasOwnProperty(v)) {
              delete newSource[v];
          }
      });
  } else {
      Object.keys(source).forEach((v, i) => {
          if (attArr.indexOf(v) === -1) {
              delete newSource[v];
          }
      });
  };

  return newSource;
}