JavaScript 对象操作函数库：合并、转换、拷贝、获取值、判断类型等

JavaScript 对象操作函数库

该函数库提供一系列 JavaScript 对象操作函数，可以帮助您轻松地处理对象数据。

| 函数名称 | 函数描述 | 参数 | 返回值 | |---|---|---|---| | mergeObjects | 合并多个对象 | target: 目标对象, sources: 源对象 | 合并后的对象 | | objToUrlParams | 将对象转换为 URL 参数字符串 | obj: 要转换的对象 | 转换后的 URL 参数字符串 | | urlToObj | 将链接转换成对象 | url: 需要转换的链接 | 包含链接参数的对象 | | copyObject | 对象拷贝函数，根据参数控制进行深拷贝或浅拷贝 | obj: 要拷贝的对象, deepCopy: 是否进行深拷贝，默认为 false 表示浅拷贝 | 拷贝后的新对象 | | getValueByKey | 根据 key 获取对象的值 | obj: 要获取值的对象, key: 属性键名 | 对应属性的值，如果 obj 中不存在该属性则返回 undefined | | allPropertiesAreNotEmpty | 检测整个对象是否没有空属性 | obj: 要检测的对象 | 是否所有属性都不为空 | | arrayToJSON | 将对象数组转换为 JSON 格式 | arr: 要转换的对象数组 | 对象数组的 JSON 字符串 | | deleteProperties | 删除对象中指定的属性，并返回新对象 | obj: 要删除属性的对象, keys: 要删除的属性键名数组 | 删除对应属性后的新对象 | | pickProperties | 从对象中取多个属性，并生成一个全新的对象 | obj: 要取属性的对象, keys: 要取的属性键名数组 | 包含对应属性的新对象 | | isObject | 判断变量是否为对象类型 | varible: 要检查的变量 | 是否为对象类型 |

函数实现

/**
 * 合并多个对象
 * @param {Object} target - 目标对象
 * @param {...Object} sources - 源对象
 * @returns {Object} 合并后的对象
 */
export function mergeObjects(target, ...sources) {
   sources.forEach(source => {
      Object.keys(source).forEach(key => {
         if (typeof source[key] === 'object') {
            // 如果源对象的属性值是对象，则递归合并
            if (!target[key]) {
               target[key] = {};
            }
            mergeObjects(target[key], source[key]);
         } else {
            // 否则直接覆盖目标对象的属性值
            target[key] = source[key];
         }
      });
   });
   return target;
}

/**
 * 将对象转换为URL参数字符串
 * @param {Object} obj - 要转换的对象
 * @returns {string} - 转换后的URL参数字符串
 */
export function objToUrlParams(obj) {
   let params = [];

   // 遍历对象，将键值对转换为参数字符串
   for (let key in obj) {
      if (obj.hasOwnProperty(key)) {
         let value = obj[key];

         // 如果值是数组，则将数组中的每个元素都转换为参数字符串
         if (Array.isArray(value)) {
            value.forEach(item => {
               params.push(`${encodeURIComponent(key)}[]=${encodeURIComponent(item)}`);
            });
         } else {
            params.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
         }
      }
   }

   // 返回参数字符串
   return params.join('&');
}

/**
 * 将链接转换成对象
 * @param {string} url - 需要转换的链接
 * @returns {Object} - 返回包含链接参数的对象
 */
export function urlToObj(url) {
   const params = new URLSearchParams(new URL(url).search);
   const obj = {};
   // 遍历所有参数，将其存储在对象中
   for (let [key, value] of params.entries()) {
      obj[key] = value;
   }
   return obj;
}


/**
 * 对象拷贝函数，根据参数控制进行深拷贝或浅拷贝
 * @param {Object} obj - 要拷贝的对象
 * @param {boolean} [deepCopy=false] - 是否进行深拷贝，默认为false表示浅拷贝
 * @returns {Object} - 拷贝后的新对象
 */
export function copyObject(obj, deepCopy = false) {
   // 如果不进行深拷贝，直接返回obj
   if (!deepCopy) {
      return obj;
   }

   // 进行深拷贝
   /**
    * 深度拷贝一个对象
    * @param {Object} obj - 要拷贝的对象
    * @returns {Object} - 拷贝后的新对象
    */
   function deepCopy(obj) {
      // 如果obj不是对象或者是null，则直接返回obj
      if (typeof obj !== 'object' || obj === null) {
         return obj;
      }
      let copy;
      // 如果obj是数组，则创建空数组copy，并遍历obj中所有元素递归调用deepCopy
      if (Array.isArray(obj)) {
         copy = [];
         obj.forEach((item, index) => {
            copy[index] = deepCopy(item);
         });
         return copy;
      }
      // 如果obj是对象，则创建空对象copy，并遍历obj中所有属性递归调用deepCopy
      copy = {};
      Object.keys(obj).forEach(key => {
         copy[key] = deepCopy(obj[key]);
      });
      return copy;
   }
   return deepCopy(obj);
}




/**
 * 根据key获取对象的值
 * @param {Object} obj - 要获取值的对象
 * @param {string} key - 属性键名
 * @returns {*} - 对应属性的值，如果obj中不存在该属性则返回undefined
 */
export function getValueByKey(obj, key) {
   // 判断obj是否是对象，如果不是则返回undefined
   if (typeof obj !== 'object' || obj === null) {
      return undefined;
   }

   // 使用split将key拆分成数组形式，依次访问obj中的每个属性
   const keys = key.split('.');
   let value = obj;
   for (let i = 0; i < keys.length; i++) {
      value = value[keys[i]];
      // 如果当前属性值为undefined或null，则返回undefined
      if (value === undefined || value === null) {
         return undefined;
      }
   }

   return value;
}



/**
 * 检测整个对象是否没有空属性
 * @param {Object} obj - 要检测的对象
 * @returns {boolean} - 是否所有属性都不为空
 */
export function allPropertiesAreNotEmpty(obj) {
   // 循环遍历obj中的每一个属性
   for (const key in obj) {
      if (Object.hasOwnProperty.call(obj, key)) {
         const value = obj[key];

         // 如果当前属性值为null、undefined、空字符串或全是空格的字符串，则返回false
         if (value === null || value === undefined || value.trim() === '') {
            return false;
         }

         // 如果当前属性值是对象，则递归调用该函数
         if (typeof value === 'object' && !Array.isArray(value)) {
            if (!allPropertiesAreNotEmpty(value)) {
               return false;
            }
         }
      }
   }

   return true;
}




/**
 * 将对象数组转换为JSON格式
 * @param {Object[]} arr - 要转换的对象数组
 * @returns {string} - 对象数组的JSON字符串
 */
export function arrayToJSON(arr) {
   // 循环遍历arr中的每个对象，使用JSON.stringify将其转换为JSON字符串，并将结果保存到新数组中
   const jsonArr = arr.map(obj => JSON.stringify(obj));

   // 使用Array.join方法将jsonArr中所有元素连接起来，使用','分隔每个元素
   return `[${jsonArr.join(',')}]`;
}



/**
 * 删除对象中指定的属性，并返回新对象
 * @param {Object} obj - 要删除属性的对象
 * @param {string[]} keys - 要删除的属性键名数组
 * @returns {Object} - 删除对应属性后的新对象
 */
export function deleteProperties(obj, keys) {
   // 创建一个新对象，遍历obj的所有属性，将不在keys中的属性复制到新对象中
   const newObj = {};
   for (const key in obj) {
      if (Object.hasOwnProperty.call(obj, key) && !keys.includes(key)) {
         newObj[key] = obj[key];
      }
   }

   return newObj;
}



/**
 * 从对象中取多个属性，并生成一个全新的对象
 * @param {Object} obj - 要取属性的对象
 * @param {string[]} keys - 要取的属性键名数组
 * @returns {Object} - 包含对应属性的新对象
 */
export function pickProperties(obj, keys) {
   // 创建一个新对象，遍历keys数组，将obj中对应属性复制到新对象中
   const newObj = {};
   for (const key of keys) {
      if (obj.hasOwnProperty(key)) {
         newObj[key] = obj[key];
      }
   }

   return newObj;
}



/**
 * 判断变量是否为对象类型
 * @param {*} varible - 要检查的变量
 * @returns {boolean} - 是否为对象类型
 */
export function isObject(varible) {
   return typeof varible === 'object' && varible !== null;
}