js常用封装方法

/*
 * 生成随机数
 * @length 指定长度
 * return 随机数
*/
export function randomNum(length) {
   let ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
   ALPHABET += 'abcdefghijklmnopqrstuvwxyz';
   ALPHABET += '0123456789-_';
   let str = '';
   let i = 0;
   while(i < length){
      let rand = Math.floor(Math.random() * ALPHABET.length);
      str += ALPHABET.substring(rand, rand + 1);
      i++;
   }
   return str;
}

/*
* 浮点数精度丢失
* passive 被加减数
* active 加减数
* Symbol +加-减*乘/除
 	js数字精度丢失通常是出现在浮点数运算上，比如`0.1 + 0.2 != 0.3`
	解决思路：将浮点数乘倍数为整数进行计算完毕后再除倍数
* */
export function accuracyCalculation(passive,active,Symbol = '+'){
   let passiveNumber = String(passive)
   let activeNumber = String(active)
   let passivCount = ''  // 被加减数 小数点几位数
   let activeCount = ''  // 加减数 小数点几位数
   let Multiple = 1      // 倍数
   let MultipleActive = 1
   if(passiveNumber.indexOf('.') !== -1 || activeNumber.indexOf('.') !== -1){
      if(passiveNumber.indexOf('.') !== -1) passivCount = passiveNumber.length - (passiveNumber.indexOf('.')+1)
      if(activeNumber.indexOf('.') !== -1) activeCount = activeNumber.length - (activeNumber.indexOf('.')+1)
      if(Symbol === '+' || Symbol === '-'){
         let count = passivCount > activeCount ? passivCount : activeCount
         for (let i = 0; i < count ; i++) Multiple = Multiple * 10
      }else{
         for (let i = 0; i < passivCount ; i++) Multiple = Multiple * 10
         for (let i = 0; i < activeCount ; i++) MultipleActive = MultipleActive * 10
      }
   }
   let result = ''
   if(Symbol === '+') result = passive * Multiple + active * Multiple
   else if(Symbol === '-') result = passive * Multiple - active * Multiple
   else if(Symbol === '*') result = (passive * Multiple) * (active * MultipleActive)
   else if(Symbol === '/') result = (passive * Multiple) / (active * MultipleActive)

   return  Symbol === '/' ? result : result / Multiple / MultipleActive
}

/*
 * 替换String中所有子串
 * @string 字符串
 * @substr 子串 被替换值
 * @separator 分离器 替换的新增
 */
export function replaceStr(string,substr,separator){
   return string.split(substr).join(separator)
}

/*
* 查询字符串中子串出现的所有相应下标
* @string 字符串
* @substr 子串
* return 相应下标的数组
* */
export function search_substr_pos(string, substr) {
   let _search_pos = string.indexOf(substr), _arr_positions = [];
   while (_search_pos > -1) {
      _arr_positions.push(_search_pos);
      _search_pos = string.indexOf(substr, _search_pos + 1);
   }
   return _arr_positions;
}

/*
* 查找数组中重复值和对应重复下标
* @arr 数组
* return { duplicate_val:重复值 , duplicate_index:对应重复下标 }
* */
export function search_duplicate_val(arr){
   let duplicate_val = [] , duplicate_index = []
   arr.forEach((item,index)=>{
      arr.forEach((items,indexs)=>{
         if(index !== indexs){
            if(item === items){
               if(!duplicate_val.includes(item)) duplicate_val.push(item)
            }
         }
      })
   })
   duplicate_val.forEach(item=>{
      duplicate_index.push(search_substr_pos(arr,item).join('、'))
   })
   return { duplicate_val, duplicate_index }
}

/*
* 查询一组 数组日期是否为连续日
* dateArr 数组日期 ["2022-02-26","2022-02-27","2022-03-01", "2022-03-04","2022-03-05"]
* return 返回 连续日期value  ["2022-02-26,2022-02-27","2022-03-04,2022-03-04"]
* 注意使用sort()所有会打乱dateArr数组日期的顺序，由前到后排序
* */
export function search_duplicate_day(dateArr){
   dateArr = duplicateRemoval(dateArr.sort())  // 去重
   let _days = dateArr.sort().map((day, index) => {
      let date = new Date(day)
      date.setDate(date.getDate() + 4 - index) // 如果为连续日期则处理为相同日期，且转为时间戳
      return +date
   })
   let returnDays = []
   let getDaySequenceData = search_duplicate_val(_days).duplicate_index

   if(getDaySequenceData.length !== 0){
      getDaySequenceData.forEach(item=>{
         let str = []
         item.split('、').forEach(itemIndex=>{
            str.push(dateArr[itemIndex])
         })
         returnDays.push(str.join('、'))
      })
   }
   return returnDays
}

/*
* 数组去重 利用Set所有元素的唯一性
* @arr 数组
* */
export function duplicateRemoval(arr){
   return Array.from(new Set(arr))
}


/* 自定义对象类 */
export class CustomObject{
   constructor(obj) { this.obj = obj; }
   /*
   * 过滤掉value为空的key值
   * obj Object对象
   * */
   filterEmpty(obj = this.obj){
      let result = recursion_fil.call(this,obj)
      return result
   }
   /*
   * 替换key值
   * @this.newKey 新key
   * @this.oldKey 被替换的旧key
   * @obj Object对象
   * */
   replaceKey(obj = this.obj){
      let result = recursion_rep.call(this,obj,this.newKey,this.oldKey)
      return result
   }
}
// 递归 过滤掉value为空的key值
function recursion_fil(obj){
   let newObj = {}
   Object.keys(obj).forEach(item=>{
      if(Number(item) !== 0) {
         // 如果是Object对象
         if(obj[item] instanceof Object && Object.keys(obj[item]).length){
            if(obj[item]){
               newObj[item] = obj[item]
               // 当对象中有key的value为空则删除过滤掉
               Object.keys(newObj[item]).forEach(items=>{
                  if(!newObj[item][items]) delete newObj[item][items]
               })
               this.filterEmpty(obj[item])
            }
         }
         // 如果不是对象，且有value
         if(!(obj[item] instanceof Object)) {
            if(obj[item]) newObj[item] = obj[item]
         }
      }
   })
   return newObj
}
// 递归 替换key
function recursion_rep(obj,newKey,oldKey){
   let newObj = {}
   Object.keys(obj).forEach(item=>{
      if(Number(item) !== 0){
         if(obj[item] instanceof Object && Object.keys(obj[item]).length){
            if(obj[item]) this.replaceKey(obj[item])
         }
         if(item === oldKey) newObj[newKey] = obj[item]
         else newObj[item] = obj[item]
      }
   })
   return newObj
}
/*
* 计算字符串长度，中文为两个字符
* @str 字符串
* return 字符串长度
* */
export function computedStrLen(str) {
   let len = 0 , i= 0;
   while (i < str.length){
      let strData = str.charCodeAt(i);
      if ((strData >= 0x0001 && strData <= 0x007e) || (0xff60 <= strData && strData <= 0xff9f)) len++;
      else len += 2;
      i++;
   }
   return len;
}

export default {
   randomNum,
   accuracyCalculation,
   replaceStr,
   search_substr_pos,
   search_duplicate_val,
   search_duplicate_day,
   duplicateRemoval,
   CustomObject,
   computedStrLen,
}

// Math.pow(m，n)--m的n次方
// Math.pow(x,y)也存在精度丢失问题
let decimal = Math.pow(10, (num.length - (num.indexOf('.')+1)))