---

一、 将对象拼接到url地址后面

ObjConcatURL(obj) {
   if (!(typeof obj == 'object') || Object.keys(obj).length == 0) {
     return "";
   } else {
     // 过滤对象中为NaN，undefined的属性
    for (let key in obj) {
       if (obj.hasOwnProperty(key) && (obj[key] == null || obj[key] == undefined || obj[key] == NaN || obj[key] == '')) {
         delete obj[key]
       }
     }
     // 拼接字符串到url
     return obj ? '?' + Object.keys(obj).map(i => `${i}=${obj[i]}`).join('&') : "";
   }
},

二、正则获取url中的图片名称

// 下载
handleDownload(url) {
   if (!url) {
      this.$message.warning("链接不存在")
      return
   }
   let link = document.createElement('a')
   link.style.display = 'none'
   link.href = url

   // 正则获取url中的图片名称
   const reg = /[^/]+(?!.*\/)/g
   const imgName = url.match(reg).filter(item => item).pop()

   link.setAttribute('download', imgName)
   document.body.appendChild(link)
   link.click()
   document.body.removeChild(link) //下载完成移除元素
   window.URL.revokeObjectURL(url) //释放掉blob对象
}

三、获取多数组之间的差集

// 获取多数组之间的差集
arrayAminus(arrA, arrB, arrC) {
  return arrA.filter(v => !arrB.includes(v) && !arrC.includes(v));
},

四、数组遍历判断是否需要拼接地址

/*
*  数组遍历判断是否需要拼接地址
* @param arr：需要遍历的数组
* @param type（["xxx" || "xxx"]/String）：用来区分毛重与皮重图片等 
*/
pushArrType(arr, type) {
      if (!Array.isArray(arr) || arr.length == 0) {
        return []
      } else {
        let newArr = [], filterUrl = ["http" || "https" || ";base64,"]
        arr.forEach(item => {
          if (typeof item == 'object' && item.url) {//判断数组里面是否为对象,url是否存在
            if (type) {
              // 存在type并判断是否需要拼接地址
              if (item.url.includes(filterUrl) && item.url.includes(type)) {//不需要拼接地址
                newArr.push(item.url)
              } else if (!item.url.includes(filterUrl) && item.url.includes(type)) {//需要拼接地址
                newArr.push(process.env.VUE_APP_FILE_URL + item.url)
              }
            } else {
              // 不存在type并判断是否需要拼接地址
              item.url.includes(filterUrl) ? newArr.push(item.url) : newArr.push(process.env.VUE_APP_FILE_URL + item.url)
            }
          } else {//数组里面就是字符串（即地址）
            if (type) {
              // 存在type并判断是否需要拼接地址
              if (item.includes(filterUrl) && item.includes(type)) {
                newArr.push(item)
              } else if (!item.includes(filterUrl) && item.includes(type)) {
                newArr.push(process.env.VUE_APP_FILE_URL + item)
              }
            } else {
              // 不存在type并判断是否需要拼接地址
              item.includes(filterUrl) ? newArr.push(item) : newArr.push(process.env.VUE_APP_FILE_URL + item)
            }
          }
        })
        return newArr
      }
},

五、 数组去重

// 数组去重
export function arrFilter(arr) {
	if (!Array.isArray(arr) && arr.length == 0) { return []; }
	return Array.from(new Set(arr)); // 利用Array.from将Set结构转换成数组
}

六、如果值不存在就 push 进数组， 反之不处理

/*
 * 如果值不存在就 push 进数组， 反之不处理
 * @param array 要操作的数据 
 * @param value 要添加的值 
 * @param key 可空， 如果比较的是对象， 可能存在地址不一样但值实际上是一样的情况， 可以传此字段判断对象中唯一的字段， 例如 id。 不传则直接比较实际值 
 * @returns { boolean } 成功 push 返回 true， 不处理返回 false 
 */
export function pushIfNotExist(array, value, key) {
	for (let item of array) {
		if (key && (item[key] === value[key])) {
			return false
		} else if (item === value) {
			return false
		}
	}
	array.push(value)
	return true
}

七、过滤对象中为NaN，undefined的属性

// 过滤对象中为NaN，undefined的属性
export function objFilter(obj, type) {
	if (!(typeof obj == 'object')) {
		return;
	}
	for (let key in obj) {
		if (obj.hasOwnProperty(key) && (obj[key] == null || obj[key] == undefined || obj[key] == NaN)) {
			console.log('---------过滤对象(null/undefined/NaN)：' + key + ':' + obj[key] + '----------')
			if (type) {
				obj[key] == type;
			} else {
				delete obj[key];
			}
		}
	}
	return obj;
}

八、字符串中插入千位分隔符

// 字符串中插入千位分隔符
export function thousandsSeparator(num) {
	if (!(typeof num == 'number') || !isNaN(num)) {
		return;
	}
	return (num + "").replace(/\d(?=(\d{3})+$)/g, "$&,")
}

九、保留小数位数

/**
 * 保留小数位数
 * @param {*} num 
 * @param {*} digit 需要保留小数位数（全部显示：则不传或传null）
 * @param {*} type 是否四舍五入（是：不传或传"四舍五入"）
 * @returns 
 */
export function keepDecimal(num, digit, type) {
  if (!type || type == null || type == '四舍五入') {
    // 1.四舍五入
    var result = parseFloat(num);
    if (isNaN(result)) { return }
    return digit && digit != null ? Number(result.toFixed(digit)) : Number(result)
  } else {
    // 2.不四舍五入 向下取整
    var result = digit && digit != null ? Math.floor(num * Math.pow(10, digit)) / Math.pow(10, digit) : parseFloat(num);
    if (isNaN(result)) { return }
    return result
  }
}