前端常用的方法

时间处理

moment时间处理函数

// 时间日期相关常用的方法变量
import moment from 'moment';

// 获取当前时间 moment
export const nowDateMoment = moment(new Date());
export const nowDateY = moment(new Date()).format('YYYY');
export const nowDateM = moment(new Date()).format('MM');
export const nowDateYM = moment(new Date()).format('YYYY-MM');
export const nowDateYMD = moment(new Date()).format('YYYY-MM-DD');
export const nowDateYMDHms = moment(new Date()).format('YYYY-MM-DD HH:mm:ss');

// 把年月 转换为 年-月
export const YMFormattedYM = (year: number | string, month: number | string) => {
  let newMonth = Number(month) > 9 ? month : `0${month}`;
  return `${dateFormattedY(year)}-${newMonth}`;
};

// 日期格式转换为moment
export const dateFormattedMoment = (date: any) => {
  let newDate = date;
  if (date && typeof date === 'string') {
    newDate = moment(date);
  }
  return newDate;
};

// 格式化时间 YYYY
export const dateFormattedY = (date: any) => {
  return date ? dateFormattedMoment(date).format('YYYY') : date;
};

// 格式化时间 MM
export const dateFormattedM = (date: any) => {
  return date ? dateFormattedMoment(date).format('MM') : date;
};

// 格式化时间 YYYY-MM
export const dateFormattedYM = (date: any) => {
  return date ? dateFormattedMoment(date).format('YYYY-MM') : date;
};

// 格式化时间 YYYY-MM-DD
export const dateFormattedYMD = (date: any) => {
  return date ? dateFormattedMoment(date).format('YYYY-MM-DD') : date;
};

// 格式化时间 YYYY-MM-DD HH:mm:ss
export const dateFormattedYMDHms = (date: any) => {
  return date ? dateFormattedMoment(date).format('YYYY-MM-DD HH:mm:ss') : date;
};

// 格式化时间  YYYY-MM-DDTHH:mm:ss.SSSZ
export const dateFormattedSSSZ = (date: any) => {
  return date ? dateFormattedMoment(date).format('YYYY-MM-DDTHH:mm:ss.SSSZ') : date;
};

// 格式化时间  'YYYY-MM-DDTHH:mm:ss.000+0800  2022-03-24T08:56:36.000+0800
export const dateFormattedTimezone = (date: any) => {
  return date ? dateFormattedSSSZ(date).slice(0, -3) + '00' : date;
};

// 获取本周周几的日期
export const getWeekDate = (day: number) => {
  // moment().weekday(0).format('YYYY/MM/DD') //本周一
  // moment().weekday(6).format('YYYY/MM/DD') //本周日
  return moment().weekday(day).format('YYYYMMDD');
};

// 比较两个时间 是否等于
export const isEqDate = (startDate: any, endDate: any) => {
  return compareDate(startDate, endDate, 'eq');
};

// 比较两个时间 是否大于
export const isGtStartDate = (startDate: any, endDate: any) => {
  return compareDate(startDate, endDate, 'gt');
};

// 比较两个时间 是否大于等于
export const isGeStartDate = (startDate: any, endDate: any) => {
  return compareDate(startDate, endDate, 'ge');
};

// 比较两个时间 是否小于
export const isLtEndDate = (startDate: any, endDate: any) => {
  return compareDate(startDate, endDate, 'lt');
};

// 比较两个时间 是否小于等于
export const isLeEndDate = (startDate: any, endDate: any) => {
  return compareDate(startDate, endDate, 'le');
};

// 对时间进行排序
export const isSortDate = (startDate: any, endDate: any) => {
  return startDate === endDate ? 0 : isGtStartDate(startDate, endDate) ? 1 : -1;
};

// 比较时间公共方法
const compareDate = (startDate: any, endDate: any, type: string) => {
  if (!startDate || !endDate) return false;

  let newStartDate = dateFormattedYMD(startDate);
  let newEendDate = dateFormattedYMD(endDate);

  let condition;
  switch (type) {
    case 'eq':
      condition = newStartDate === newEendDate;
      break;
    case 'gt':
      condition = newStartDate > newEendDate;
      break;
    case 'ge':
      condition = newStartDate >= newEendDate;
      break;
    case 'lt':
      condition = newStartDate < newEendDate;
      break;
    case 'le':
      condition = newStartDate <= newEendDate;
      break;
  }
  return condition ? true : false;
};

// 是否在两个日期范围内
export const isDateRange = (startDate: any, endDate: any, date: any) => {
  let newDate = dateFormattedYMD(date);
  if (dateFormattedYMD(startDate) <= newDate && newDate <= dateFormattedYMD(endDate)) {
    return true;
  }
  return false;
};

// 获取两个日期的差值  2022-03-25  2022-03-20  5天
export const getDiffDays = (endDate: any, startDate: any) => {
  if (endDate && startDate) {
    return moment(endDate).diff(moment(startDate), 'day');
  } else {
    return 0;
  }
};

// 开始时间增加N天
export const getAddDays = (startDate: any, days: number) => {
  let newStartDate = dateFormattedMoment(startDate);
  if (days >= 0) {
    newStartDate.add(days, 'days');
  }
  return newStartDate;
};

// 开始时间减N天
export const getSubtractDays = (startDate: any, days: number) => {
  let newStartDate = dateFormattedMoment(startDate);
  if (days >= 0) {
    newStartDate.subtract(days, 'days');
  }
  return newStartDate;
};

时间戳处理成为年月日时分秒

//方法1  
const convertTimestampToHMS=(timestampStr) =>{
    const timestampdata = Number(timestampStr);
    var date = new Date(timestampdata);
    var year = date.getFullYear();
    var month = String(date.getMonth() + 1).padStart(2, '0'); // 月份从0开始，需要加1
    var day = String(date.getDate()).padStart(2, '0');
    var hours = String(date.getHours()).padStart(2, '0');
    var minutes = String(date.getMinutes()).padStart(2, '0');
    var seconds = String(date.getSeconds()).padStart(2, '0');
    return `${year}年${month}月${day}日 ${hours}:${minutes}:${seconds}`;
  }
//方法2
 const convertTimestampToDateTime=(timestamp)=> {
        const date = new Date(timestamp);
        return date.toLocaleString('zh-CN', {
          year: 'numeric',
          month: '2-digit',
          day: '2-digit',
          hour: '2-digit',
          minute: '2-digit',
          second: '2-digit',
          hour12: false,
        });
      }

将年月日时分秒的数据处理成为时间戳

 function convertDateTimeToTimestamp(dateTimeStr, year = 2024) {
        const fullDateTimeStr = `${year}-${dateTimeStr}`;
        const date = new Date(fullDateTimeStr.replace('-', 'T'));
        const timestamp = date.getTime();
        return timestamp;
      }

获取时间戳的方法

//方法1
var timestamp = Date.parse(new Date());
console.log(timestamp); // 1622427159000
//方法2
var timestamp = (new Date()).valueOf();
console.log(timestamp);	// 1622427218359
//方法3
new Date().getTime() ; // 1622427445085

日期时间脚本库方法列表

​
/*
	Date.prototype.isLeapYear;	//判断闰年
	Date.prototype.Format ;	//日期格式化
	Date.prototype.DateAdd ;	//日期计算
	Date.prototype.DateDiff;	// 比较日期差
	Date.prototype.toString ;	//日期转字符串
	Date.prototype.toArray ;	//日期分割为数组
	Date.prototype.DatePart ;	//取日期的部分信息
	Date.prototype.MaxDayOfDate;	// 取日期所在月的最大天数
	Date.prototype.WeekNumOfYear;	// 判断日期所在年的第几周
	StringToDate ;	//字符串转日期型
	IsValidDate ;	//验证日期有效性
	CheckDateTime ;	//完整日期时间检查
	daysBetween ;	//日期天数差
*/

// 案例代码如下：
	// 判断闰年
Date.prototype.isLeapYear = function(){
	return (0==this.getYear()%4&&((this.getYear()%100!=0)||(this.getYear()%400==0)));
}
/*
	// 日期格式化
	// 格式 YYYY/yyyy/YY/yy 表示年份
	// MM/M 月份
	// W/w 星期
	// dd/DD/d/D 日期
	// hh/HH/h/H 时间
	// mm/m 分钟
	// ss/SS/s/S 秒
*/
Date.prototype.Format = function(formatStr){
	var str = formatStr;
	var Week = ['日','一','二','三','四','五','六'];
 
	str=str.replace(/yyyy|YYYY/,this.getFullYear());
	str=str.replace(/yy|YY/,(this.getYear() % 100)>9?(this.getYear() % 100).toString():’0′ + (this.getYear() % 100));
 
	str=str.replace(/MM/,this.getMonth()>9?this.getMonth().toString():’0′ + this.getMonth());
	str=str.replace(/M/g,this.getMonth());
 
	str=str.replace(/w|W/g,Week[this.getDay()]);
	 
	str=str.replace(/dd|DD/,this.getDate()>9?this.getDate().toString():’0′ + this.getDate());
	str=str.replace(/d|D/g,this.getDate());
	 
	str=str.replace(/hh|HH/,this.getHours()>9?this.getHours().toString():’0′ + this.getHours());
	str=str.replace(/h|H/g,this.getHours());
	str=str.replace(/mm/,this.getMinutes()>9?this.getMinutes().toString():’0′ + this.getMinutes());
	str=str.replace(/m/g,this.getMinutes());
	 
	str=str.replace(/ss|SS/,this.getSeconds()>9?this.getSeconds().toString():’0′ + this.getSeconds());
	str=str.replace(/s|S/g,this.getSeconds());
	 
	return str;
}
 
/*
//| 求两个时间的天数差 日期格式为 YYYY-MM-dd
*/
function daysBetween(DateOne,DateTwo){
	var OneMonth = DateOne.substring(5,DateOne.lastIndexOf (‘-’));
	var OneDay = DateOne.substring(DateOne.length,DateOne.lastIndexOf (‘-’)+1);
	var OneYear = DateOne.substring(0,DateOne.indexOf (‘-’));
	 
	var TwoMonth = DateTwo.substring(5,DateTwo.lastIndexOf (‘-’));
	var TwoDay = DateTwo.substring(DateTwo.length,DateTwo.lastIndexOf (‘-’)+1);
	var TwoYear = DateTwo.substring(0,DateTwo.indexOf (‘-’));
 
	var cha=((Date.parse(OneMonth+’/'+OneDay+’/'+OneYear)- Date.parse(TwoMonth+’/'+TwoDay+’/'+TwoYear))/86400000);
	return Math.abs(cha);
}
 
/*
//| 日期计算
*/
Date.prototype.DateAdd = function(strInterval, Number) {
	var dtTmp = this;
	switch (strInterval) {
		case ‘s’ :return new Date(Date.parse(dtTmp) + (1000 * Number));
		case ‘n’ :return new Date(Date.parse(dtTmp) + (60000 * Number));
		case ‘h’ :return new Date(Date.parse(dtTmp) + (3600000 * Number));
		case ‘d’ :return new Date(Date.parse(dtTmp) + (86400000 * Number));
		case ‘w’ :return new Date(Date.parse(dtTmp) + ((86400000 * 7) * Number));
		case ‘q’ :return new Date(dtTmp.getFullYear(), (dtTmp.getMonth()) + Number*3, dtTmp.getDate(), dtTmp.getHours(), dtTmp.getMinutes(), dtTmp.getSeconds());
		case ‘m’ :return new Date(dtTmp.getFullYear(), (dtTmp.getMonth()) + Number, dtTmp.getDate(), dtTmp.getHours(), dtTmp.getMinutes(), dtTmp.getSeconds());
		case ‘y’ :return new Date((dtTmp.getFullYear() + Number), dtTmp.getMonth(), dtTmp.getDate(), dtTmp.getHours(), dtTmp.getMinutes(), dtTmp.getSeconds());
	}
}
 
/*
//| 比较日期差 dtEnd 格式为日期型或者有效日期格式字符串
*/
Date.prototype.DateDiff = function(strInterval, dtEnd) {
	var dtStart = this;
	if (typeof dtEnd == ‘string’ )//如果是字符串转换为日期型
	{
		dtEnd = StringToDate(dtEnd);
	}
	switch (strInterval) {
		case ‘s’ :return parseInt((dtEnd – dtStart) / 1000);
		case ‘n’ :return parseInt((dtEnd – dtStart) / 60000);
		case ‘h’ :return parseInt((dtEnd – dtStart) / 3600000);
		case ‘d’ :return parseInt((dtEnd – dtStart) / 86400000);
		case ‘w’ :return parseInt((dtEnd – dtStart) / (86400000 * 7));
		case ‘m’ :return (dtEnd.getMonth()+1)+((dtEnd.getFullYear()-dtStart.getFullYear())*12) – (dtStart.getMonth()+1);
		case ‘y’ :return dtEnd.getFullYear() – dtStart.getFullYear();
	}
}
 
/*
//| 日期输出字符串，重载了系统的toString方法
*/
Date.prototype.toString = function(showWeek){
	var myDate= this;
	var str = myDate.toLocaleDateString();
	if (showWeek){
		var Week = ['日','一','二','三','四','五','六'];
		str += ‘ 星期’ + Week[myDate.getDay()];
	}
	return str;
}
 
/*
//| 日期合法性验证
//| 格式为：YYYY-MM-DD或YYYY/MM/DD
*/
function IsValidDate(DateStr){
	var sDate=DateStr.replace(/(^\s+|\s+$)/g,”); //去两边空格;
	if(sDate==”) return true;
	//如果格式满足YYYY-(/)MM-(/)DD或YYYY-(/)M-(/)DD或YYYY-(/)M-(/)D或YYYY-(/)MM-(/)D就替换为”
	//数据库中，合法日期可以是:YYYY-MM/DD(2003-3/21),数据库会自动转换为YYYY-MM-DD格式
	var s = sDate.replace(/[\d]{ 4,4 }[\-/]{ 1 }[\d]{ 1,2 }[\-/]{ 1 }[\d]{ 1,2 }/g,”);
	if (s==”) //说明格式满足YYYY-MM-DD或YYYY-M-DD或YYYY-M-D或YYYY-MM-D
	{
		var t=new Date(sDate.replace(/\-/g,’/'));
		var ar = sDate.split(/[-/:]/);
		if(ar[0] != t.getYear() || ar[1] != t.getMonth()+1 || ar[2] != t.getDate())
		{
//alert(‘错误的日期格式！格式为：YYYY-MM-DD或YYYY/MM/DD。注意闰年。’);
			return false;
		}
	}else{
//alert(‘错误的日期格式！格式为：YYYY-MM-DD或YYYY/MM/DD。注意闰年。’);
		return false;
	}
	return true;
}
 
/*
//| 日期时间检查
//| 格式为：YYYY-MM-DD HH:MM:SS
*/
function CheckDateTime(str){
	var reg = /^(\d+)-(\d{ 1,2 })-(\d{ 1,2 }) (\d{ 1,2 }):(\d{ 1,2 }):(\d{ 1,2 })$/;
	var r = str.match(reg);
	if(r==null)return false;
	r[2]=r[2]-1;
	var d= new Date(r[1],r[2],r[3],r[4],r[5],r[6]);
	if(d.getFullYear()!=r[1])return false;
	if(d.getMonth()!=r[2])return false;
	if(d.getDate()!=r[3])return false;
	if(d.getHours()!=r[4])return false;
	if(d.getMinutes()!=r[5])return false;
	if(d.getSeconds()!=r[6])return false;
	return true;
}
 
/*
//| 把日期分割成数组
*/
Date.prototype.toArray = function(){
	var myDate = this;
	var myArray = Array();
	myArray[0] = myDate.getFullYear();
	myArray[1] = myDate.getMonth();
	myArray[2] = myDate.getDate();
	myArray[3] = myDate.getHours();
	myArray[4] = myDate.getMinutes();
	myArray[5] = myDate.getSeconds();
	return myArray;
}
 
/*
//| 取得日期数据信息
//| 参数 interval 表示数据类型
//| y 年 m月 d日 w星期 ww周 h时 n分 s秒
*/
Date.prototype.DatePart = function(interval){
	var myDate = this;
	var partStr=”;
	var Week = ['日','一','二','三','四','五','六'];
	switch (interval){
		case ‘y’ :partStr = myDate.getFullYear();break;
		case ‘m’ :partStr = myDate.getMonth()+1;break;
		case ‘d’ :partStr = myDate.getDate();break;
		case ‘w’ :partStr = Week[myDate.getDay()];break;
		case ‘ww’ :partStr = myDate.WeekNumOfYear();break;
		case ‘h’ :partStr = myDate.getHours();break;
		case ‘n’ :partStr = myDate.getMinutes();break;
		case ‘s’ :partStr = myDate.getSeconds();break;
	}
	return partStr;
}
 
/*
//| 取得当前日期所在月的最大天数
*/
Date.prototype.MaxDayOfDate = function(){
	var myDate = this;
	var ary = myDate.toArray();
	var date1 = (new Date(ary[0],ary[1]+1,1));
	var date2 = date1.dateAdd(1,’m',1);
	var result = dateDiff(date1.Format(‘yyyy-MM-dd’),date2.Format(‘yyyy-MM-dd’));
	return result;
}
 
/*
//| 取得当前日期所在周是一年中的第几周
*/
Date.prototype.WeekNumOfYear = function(){
	var myDate = this;
	var ary = myDate.toArray();
	var year = ary[0];
	var month = ary[1]+1;
	var day = ary[2];
	document.write(‘< script language=VBScript\> \n’);
	document.write(‘myDate = Datue(”+month+’-'+day+’-'+year+”) \n’);
	document.write(‘result = DatePart(‘ww’, myDate) \n’);
	document.write(‘ \n’);
	return result;
}
 
/*
//| 字符串转成日期类型
//| 格式 MM/dd/YYYY MM-dd-YYYY YYYY/MM/dd YYYY-MM-dd
*/
function StringToDate(DateStr){
	var converted = Date.parse(DateStr);
	var myDate = new Date(converted);
	if (isNaN(myDate)){
		//var delimCahar = DateStr.indexOf(‘/’)!=-1?’/':’-';
		var arys= DateStr.split(‘-’);
		myDate = new Date(arys[0],–arys[1],arys[2]);
	}
	return myDate;
}
 
// 若要显示:当前日期加时间(如:2009-06-12 12:00)
function CurentTime(){
	var now = new Date();
	
	var year = now.getFullYear(); //年
	var month = now.getMonth() + 1; //月
	var day = now.getDate(); //日
	 
	var hh = now.getHours(); //时
	var mm = now.getMinutes(); //分
	 
	var clock = year + “-”;
 
	if(month < 10)
	clock += “0″;
 
	clock += month + “-”;
 
	if(day < 10)
	clock += “0″;
	 
	clock += day + ” “;
	 
	if(hh < 10)
	clock += “0″;
	 
	clock += hh + “:”;
	if (mm < 10) clock += ’0′;
	clock += mm;
	return(clock);
}

​

处理对象的方法对象的属性

遍历对象

//方法1  
let obj = {
      user: "name",
    };
    for (let k in obj) {
      console.log(k);
    }
//输出 user
//方法2
   let a = {
      1733813940000: [
        {
          occurTime: 1733813940000,
        },
      ],
      1733814000000: [
        {
          occurTime: 1733814000000,
        },
      ],
    };
    Object.keys(a).forEach((key) => {
      console.log(key);
      console.log(a[key]);
    });

对象的浅拷贝

let a={
name:1
}；
let b={
type:”Add“
}；
Object.assign(a,b)
let obj ={...a,...b}

处理2个数据相同的数据处理类型2个都是对象，且数据完全一致把他筛选出来

//方法1
function filterDuplicates(arr) {
        return arr.reduce((acc, current) => {
          const stringifiedCurrent = JSON.stringify(current);
          if (!acc.map(JSON.stringify).includes(stringifiedCurrent)) {
            acc.push(current);
          }
          return acc;
        }, []);
      }
//方法2
  const filterDuplicates = (arr) => {
        const seen = new Set();
        console.log(seen);
        return arr.filter((item) => {
          const stringifiedItem = JSON.stringify(item);
          if (!seen.has(stringifiedItem)) {
            seen.add(stringifiedItem);
            return true;
          }
          return false;
        });
      };

本地存储

拿到本地存储的对象的方法

   export const getLocalStorageuserInfo = (localName, data) => {
      const storedUserInfo = localStorage.getItem(localName);
      if (storedUserInfo) {
        const parsedUserInfo = JSON.parse(storedUserInfo)[data];
        return parsedUserInfo;
      }
    };

设置本地存储的方法

  export const setLocalStorage = (localName, data) => {
      localStorage.setItem(localName, JSON.stringify(data));
      return;
    };
    setLocalStorage("data", a);

删除设定的值的本地存储

 const removeLocalStorage = (data) => {
      localStorage.removeItem(data);
      return;
    };

删除所有的本地存储

  const removeTotalLocalStorage = () => {
      localStorage.clear();
      return;
    };

数组处理

将平铺的数组转化为属性结构的数组

const wbsArray = [{
        id: '1',
        pid: '0',
        name: 'Parent'
      },
      {
        id: '2',
        pid: '1',
        name: 'Child 1'
      },
      {
        id: '3',
        pid: '1',
        name: 'Child 2'
      }
      // ...其他数据
    ]
    
   function wbsArrayToTree(array, rootId = '0'){
        let parent = []
        let children = []
        array.forEach((item) => {
          item.pid === rootId ?
            (parent = [...parent, item]) :
            (children = [...children, item])
        })
        const translator = (parent, children) => {
          parent.forEach((parent) => {
            children.forEach((current, index) => {
              if (current.pid === parent.id) {
                // const temp = JSON.parse(JSON.stringify(children))
                const temp = [...children]
                temp.splice(index, 1)
                translator([current], temp)
                typeof parent['children'] !== 'undefined' ?
                  parent.children.push(current) :
                  (parent.children = [current])
                parent['childIds'] && delete parent['childIds']
              }
            })
          })
        }
        translator(parent, children)
        return parent
      }
      const tree = wbsArrayToTree(wbsArray);
    console.log(tree);

树形数组转为一维数组

//方法1
    function flattenAndSort(array) {
      return array.reduce((result, element) => {
        // 如果元素是数组，则递归调用flattenAndSort
        if (Array.isArray(element)) {
          console.log(element, "1");
          result = result.concat(flattenAndSort(element));
        } else {
          result.push(element);
        }
        return result;
      }, []).sort((a, b) => a - b); // 排序数组
    }
    const flattenedAndSortedArray = flattenAndSort(arr);
    console.log(flattenedAndSortedArray, "27");
//方法2
 function getArry(arr) {
      const trust= []
      function fn(arr) {
        arr.forEach(element => {
          if (Array.isArray(element)) {
            fn(element);
          } else {
            trust.push(element);
          }
        });
      }
      fn(arr)
      return trust.sort((a, b) => a - b)
    }
    const trust = getArry(arr)
    console.log(trust);

当一个需要另一个数组的数据的时候需要怎么样进行处理

 success.forEach((item) => {
          list.forEach((item1) => {
            if (item.time !== item1.time) {
              obj.push({ ...item, type: '有效告警', value: 0 });
              obj.push({ ...item, type: '无效告警', value: 0 });
            }
          });
        });
        let uniqueData = filterDuplicates(obj);
        uniqueData.sort((a, b) => parseInt(a.time1) - parseInt(b.time1));
//这样的使用的时候可能造成的情况就是会导致重复的数据需要借助上方的过滤对象的方法

处理数组的数组的需要判断是否有一个数据是false或者为true来达到自增的目的

 const getValues = (r, v) => {
        let Noise = 0;
        v.forEach((item) => {
          if (!item.ruleAlarmNoise) {
            // 正确的自增方式
            Noise++;
          }
        });
        return Noise;
      };

根据数组里边的数据处理利用时间戳，判断上面和下边的数据

 const sortCount = (arr) => {
    let getHascount = [];
    arr.forEach((item, index) => {
      if (item.hasOwnProperty('count')) {
        getHascount.push({
          ...item,
        });
      } else {
        let beforeIndex = index - 1;
        while (beforeIndex >= 0 && !arr[beforeIndex].hasOwnProperty('count')) {
          beforeIndex--;
        }
        let afterIndex = index + 1;
        while (afterIndex < arr.length && !arr[afterIndex].hasOwnProperty('count')) {
          afterIndex++;
        }
        let countToUse;
        if (beforeIndex >= 0 && afterIndex < arr.length) {
          const beforeDiff = Math.abs(item.time1 - arr[beforeIndex].time1);
          const afterDiff = Math.abs(item.time1 - arr[afterIndex].time1);
          countToUse = beforeDiff < afterDiff ? arr[beforeIndex].count : arr[afterIndex].count;
        } else if (beforeIndex >= 0) {
          countToUse = arr[beforeIndex].count;
        } else if (afterIndex < arr.length) {
          countToUse = arr[afterIndex].count;
        } else {
          countToUse = null;
        }
        getHascount.push({
          ...item,
          count: countToUse,
        });
      }
    });
    getHascount.sort((a, b) => parseInt(a.time1) - parseInt(b.time1));
    console.log(getHascount);

    return getHascount;
  };

对字符串进行处理

对 "#### 日均量: 884159.01笔/天\n#### 日均有流量时间占比: 100.00%\n\n#### >

 const getNosrt = (value) => {
        if (!value) return [];
        let parts = value.split('#');
        let result = [];
        parts = parts.filter((part) => part.trim() !== '');
        for (let part of parts) {
          result.push(part.trim());
        }
        let joinedString = result.join(',');
        return joinedString;
      };