对象转化为FormData对象

  1. /**
  2.  * 对象转化为formdata
  3.  * @param {Object} object
  4.  */
  6.  export function getFormData(object) {
  7.     const formData = new FormData()
  8.     Object.keys(object).forEach(key => {
  9.         const value = object[key]
  10.         if (Array.isArray(value)) {
  11.             value.forEach((subValue, i) =>
  12.                 formData.append(key + `[${i}]`, subValue)
  13.             )
  14.         } else {
  15.             formData.append(key, object[key])
  16.         }
  17.     })
  18.     return formData
  19. }

使用场景：上传文件时我们要新建一个FormData对象，然后有多少个参数就append多少次，使用该函数可以简化逻辑。使用：

  1. let req={
  2.     file:xxx,
  3.     userId:1,
  4.     phone:'15198763636',
  5.     //...
  6. }
  7. fetch(getFormData(req))

深拷贝

  1. // 深拷贝
  2. export function deepClone(target: any): any {
  3.   // 定义一个变量
  4.   let result: any
  5.   // 如果当前需要深拷贝的是一个对象的话
  6.   if (typeof target === 'object') {
  7.     // 如果是一个数组的话
  8.     if (Array.isArray(target)) {
  9.       result = [] // 将result赋值为一个数组，并且执行遍历
  10.       for (const i in target) {
  11.         // 递归克隆数组中的每一项
  12.         result.push(deepClone(target[i]))
  13.       }
  14.       // 判断如果当前的值是null的话；直接赋值为null
  15.     } else if (target === null) {
  16.       result = null
  17.       // 判断如果当前的值是一个RegExp对象的话，直接赋值
  18.     } else if (target.constructor === RegExp) {
  19.       result = target
  20.     } else {
  21.       // 否则是普通对象，直接for in循环，递归赋值对象的所有值
  22.       result = {}
  23.       for (const i in target) {
  24.         result[i] = deepClone(target[i])
  25.       }
  26.     }
  27.     // 如果不是对象的话，就是基本数据类型，那么直接赋值
  28.   } else {
  29.     result = target
  30.   }
  31.   // 返回最终结果
  32.   return result
  33. }
  2. function deepClone(obj, hash = new WeakMap()) {
  3.   if (obj === null) return obj; 
  4.   // 如果是null或者undefined我就不进行拷贝操作
  5.   if (obj instanceof Date) return new Date(obj);
  6.   if (obj instanceof RegExp) return new RegExp(obj);
  7.   // 可能是对象或者普通的值  如果是函数的话是不需要深拷贝
  8.   if (typeof obj !== "object") return obj;
  9.   // 是对象的话就要进行深拷贝
  10.   if (hash.get(obj)) return hash.get(obj);
  11.   let cloneObj = new obj.constructor();
  12.   // 找到的是所属类原型上的constructor,而原型上的 constructor指向的是当前类本身
  13.   hash.set(obj, cloneObj);
  14.   for (let key in obj) {
  15.     if (obj.hasOwnProperty(key)) {
  16.       // 实现一个递归拷贝
  17.       cloneObj[key] = deepClone(obj[key], hash);
  18.     }
  19.   }
  20.   return cloneObj;
  21. }
  22. let obj = { name: 1, address: { x: 100 } };
  23. obj.o = obj; // 对象存在循环引用的情况
  24. let d = deepClone(obj);
  25. obj.address.x = 200;
  26. console.log(d);