前端utils工具库

最新推荐文章于 2024-08-30 09:09:11 发布
南庐
最新推荐文章于 2024-08-30 09:09:11 发布
阅读量178
点赞数
文章标签：前端
本文链接：https://blog.csdn.net/weixin_73184582/article/details/131755023
版权
本文提供了一系列JavaScript函数，包括验证手机号、身份证、车牌号的合法性，字符串处理如空格去除、首字母大小写转换，以及数字操作如四舍五入、随机数生成等。此外，还包括全屏操作、加密解密、文件下载、时间处理等相关功能函数。
摘要由CSDN通过智能技术生成


/*
 * 验证手机号是否合格
 * true--说明合格
 */
const isPhone = (phoneStr) => {
	let myreg = /^[1][3,4,5,6,7,8,9][0-9]{9}$/;
	if (!myreg.test(phoneStr)) {
		return false;
	} else {
		return true;
	}
}
/*
 * 验证身份证号是否合格
 * true--说明合格
 */
const isIdCard = (idCardStr) => {
	let idcardReg = /^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$|^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}([0-9]|X)$/;
	if (idcardReg.test(idCardStr)) {
		return true;
	} else {
		return false;
	}
}
/**
 * 验证车牌号是否合格
 * true--说明合格
 */
const isVehicleNumber = (vehicleNumber) => {
	let xreg = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}(([0-9]{5}[DF]$)|([DF][A-HJ-NP-Z0-9][0-9]{4}$))/;
	let creg = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}[A-HJ-NP-Z0-9]{4}[A-HJ-NP-Z0-9挂学警港澳]{1}$/;
	if (vehicleNumber.length == 7) {
		return creg.test(vehicleNumber);
	} else if (vehicleNumber.length == 8) {
		return xreg.test(vehicleNumber);
	} else {
		return false;
	}
}
/*
 * 验证字符串是否为空（也不能为纯空格）
 * true--说明为空， false--说明不为空
 */
const isEmptyString = (string) => {
	if (
		string == undefined ||
		typeof string == 'undefined' ||
		!string ||
		string == null ||
		string == '' ||
		/^\s+$/gi.test(string)
	) {
		return true;
	} else {
		return false;
	}
}
/*
 * 生日转为年龄（精确到月份）
 */
const birsdayToAge = (birsday) => {
	let aDate = new Date();
	let thisYear = aDate.getFullYear();
	let bDate = new Date(birsday);
	let brith = bDate.getFullYear();
	let age = thisYear - brith;
	if (aDate.getMonth() == bDate.getMonth()) {
		if (aDate.getDate() < bDate.getDate()) {
			age = age - 1;
		}
	} else {
		if (aDate.getMonth() < bDate.getMonth()) {
			age = age - 1;
		}
	}
	return age;
}
/**
 * 判断数据类型
 * @param {any} val - 基本类型数据或者引用类型数据
 * @return {string} - 可能返回的结果有，均为小写字符串
 * number、boolean、string、null、undefined、array、object、function等
 */
const getType = (val) => {
	//判断数据是 null 和 undefined 的情况
	if (val == null) {
		return val + "";
	}
	return typeof(val) === "object" ?
		Object.prototype.toString.call(val).slice(8, -1).toLowerCase() :
		typeof(val);
}
/*
 * 验证是否为数字
 */
const isNumber = (n) => {
	return !isNaN(parseFloat(n)) && isFinite(n);
}
/*
 * 是否为数组
 */
const isArray = (obj) => {
	return Object.prototype.toString.call(obj) === '[object Array]';
}
/*
 * 是否空数组
 */
const isArrayEmpty = (val) => {
	if (val && val instanceof Array && val.length > 0) {
		return false;
	} else {
		return true;
	}
}
/*
 * 获取url参数字符串
 * 没有返回null
 */
const getQueryString = (name) => {
	let reg = new RegExp('(^|&)' + name + '=([^&]*)(&|$)', 'i');
	let r = window.location.search.substr(1).match(reg);
	if (r != null) {
		return unescape(r[2]);
	}
	return null;
}
/*
 * 递归深拷贝
 */
const deepCopy = (obj) => {
	let result = Array.isArray(obj) ? [] : {};
	for (let key in obj) {
		if (obj.hasOwnProperty(key)) {
			if (typeof obj[key] === 'object' && obj[key] !== null) {
				result[key] = deepCopy(obj[key]);
			} else {
				result[key] = obj[key];
			}
		}
	}
	return result;
}
/**
 * 去除参数空数据（用于向后台传递参数的时候）
 * @param {Object} obj [参数对象]
 */
const filterEmptyData = (obj) => {
	for (let prop in obj) {
		obj[prop] === '' ? delete obj[prop] : obj[prop];
	}
	return obj;
}
/**
 * @desc  函数防抖，用于将多次执行变为最后一次执行
 * @param {function} func - 需要使用函数防抖的被执行的函数。必传
 * @param {Number} wait - 多少毫秒之内触发，只执行第一次，默认1000ms。可以不传
 */
const debounce = (fn, delay) => {
	delay = delay || 1000; //默认1s后执行
	let timer = null;
	return function() {
		let context = this;
		let arg = arguments;
		if (timer) {
			clearTimeout(timer);
		}
		timer = setTimeout(() => {
			fn.apply(context, arg);
		}, delay);
	};
}
/**
 * 节流函数, 用于将多次执行变为每隔一段时间执行
 * @param fn 事件触发的操作
 * @param delay 间隔多少毫秒需要触发一次事件
 */
const throttle2 = (fn, delay) => {
	let timer = null;
	return function() {
		let context = this;
		let args = arguments;
		if (!timer) {
			timer = setTimeout(function() {
				fn.apply(context, args);
				clearTimeout(timer);
			}, delay);
		}
	};
}
// 数字四舍五入（保留n位小数）
const round = (number, n) => {
	n = n ? parseInt(n) : 0
	if (n <= 0) return Math.round(number)
	number = Math.round(number * Math.pow(10, n)) / Math.pow(10, n)
	return number
}
/**
 *数字金额转文字  函数
 *
 * @export
 * @param {*} money
 * @returns
 */
const convertCurrency = (money) => {
	//汉字的数字
	var cnNums = new Array('零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖');
	//基本单位
	var cnIntRadice = new Array('', '拾', '佰', '仟');
	//对应整数部分扩展单位
	var cnIntUnits = new Array('', '万', '亿', '兆');
	//对应小数部分单位
	var cnDecUnits = new Array('角', '分', '毫', '厘');
	//整数金额时后面跟的字符
	var cnInteger = '整';
	//整型完以后的单位
	var cnIntLast = '元';
	//最大处理的数字
	var maxNum = 999999999999999.9999;
	//金额整数部分
	var integerNum;
	//金额小数部分
	var decimalNum;
	//输出的中文金额字符串
	var chineseStr = '';
	//分离金额后用的数组，预定义
	var parts;
	if (money == '') {
		return '';
	}
	money = parseFloat(money);
	if (money >= maxNum) {
		//超出最大处理数字
		return '';
	}
	if (money == 0) {
		chineseStr = cnNums[0] + cnIntLast + cnInteger;
		return chineseStr;
	}
	//转换为字符串
	money = money.toString();
	if (money.indexOf('.') == -1) {
		integerNum = money;
		decimalNum = '';
	} else {
		parts = money.split('.');
		integerNum = parts[0];
		decimalNum = parts[1].substr(0, 4);
	}
	//获取整型部分转换
	if (parseInt(integerNum, 10) > 0) {
		var zeroCount = 0;
		var IntLen = integerNum.length;
		for (var i = 0; i < IntLen; i++) {
			var n = integerNum.substr(i, 1);
			var p = IntLen - i - 1;
			var q = p / 4;
			var m = p % 4;
			if (n == '0') {
				zeroCount++;
			} else {
				if (zeroCount > 0) {
					chineseStr += cnNums[0];
				}
				//归零
				zeroCount = 0;
				chineseStr += cnNums[parseInt(n)] + cnIntRadice[m];
			}
			if (m == 0 && zeroCount < 4) {
				chineseStr += cnIntUnits[q];
			}
		}
		chineseStr += cnIntLast;
	}
	//小数部分
	if (decimalNum != '') {
		var decLen = decimalNum.length;
		for (var i = 0; i < decLen; i++) {
			var n = decimalNum.substr(i, 1);
			if (n != '0') {
				chineseStr += cnNums[Number(n)] + cnDecUnits[i];
			}
		}
	}
	if (chineseStr == '') {
		chineseStr += cnNums[0] + cnIntLast + cnInteger;
	} else if (decimalNum == '') {
		chineseStr += cnInteger;
	}
	return chineseStr;
}
/*
 *时间增加或减少几天
 * date  当前日期 例： 2020-06-10
 * days  增加的天数 例： 30
 * return 增加后的天数
 */
const addDate = (date, days) => {
	var d = new Date(date.replace(/-/g, '/'));
	d.setDate(d.getDate() + days);
	var month = d.getMonth() + 1;
	var day = d.getDate();
	if (month < 10) {
		month = "0" + month;
	}
	if (day < 10) {
		day = "0" + day;
	}
	var val = d.getFullYear() + "-" + month + "-" + day;
	return val;
}
/*
 *数字每千位加逗号
 * 
 */
const commafy = (num) => {
	return num && num.toString().replace(/\d+/, function(s) {
		return s.replace(/(\d)(?=(\d{3})+$)/g, '$1,')
	})
}
/*
 *数字补位
 * numberPad用于按照位数补0,默认为2
 */
const numberPad = (source, length = 2) => {
	let pre = ''
	const negative = source < 0
	const string = String(Math.abs(source))
	if (string.length < length) {
		pre = (new Array(length - string.length + 1)).join('0')
	}
	return (negative ? '-' : '') + pre + string
}
/*
 *随机数
 *
 */
const numberRandom = (min, max) => {
	return Math.floor(Math.random() * (max - min + 1) + min)
}
/*
 *手机号码中间4位隐藏花号（*）显示
 *
 */
const hideMobile = (mobile) => {
	return mobile.replace(/^(\d{3})\d{4}(\d{4})$/, "$1****$2")
}
/**
 * 去除字符串空格
 * @param str 要处理的字符串
 * @param type 1：所有空格 2：前后空格 3：前空格 4：后空格
 */
const strTrim = (str, type) => {
	switch (type) {
		case 1:
			return str.replace(/\s+/g, "");
		case 2:
			return str.replace(/(^\s*)|(\s*$)/g, "");
		case 3:
			return str.replace(/(^\s*)/g, "");
		case 4:
			return str.replace(/(\s*$)/g, "");
		default:
			return str;
	}
}
/**
 * 字母大小写切换
 * @param str 要处理的字符串
 * @param type 1:首字母大写 2：首页母小写 3：大小写转换 4：全部大写 5：全部小写
 */
const strChangeCase = (str, type) => {
	function ToggleCase(str) {
		var itemText = ""
		str.split("").forEach(
			function(item) {
				if (/^([a-z]+)/.test(item)) {
					itemText += item.toUpperCase();
				} else if (/^([A-Z]+)/.test(item)) {
					itemText += item.toLowerCase();
				} else {
					itemText += item;
				}
			});
		return itemText;
	}

	switch (type) {
		case 1:
			return str.replace(/^(\w)(\w+)/, function(v, v1, v2) {
				return v1.toUpperCase() + v2.toLowerCase();
			});
		case 2:
			return str.replace(/^(\w)(\w+)/, function(v, v1, v2) {
				return v1.toLowerCase() + v2.toUpperCase();
			});
		case 3:
			return ToggleCase(str);
		case 4:
			return str.toUpperCase();
		case 5:
			return str.toLowerCase();
		default:
			return str;
	}
}
/**
 * 检测密码强度
 * @param str 字符串
 * @returns 1：密码弱 2：密码中等 3：密码强 4：密码很强
 */
const checkPwd = (str) => {
	var nowLv = 0;
	if (str.length < 6) {
		return nowLv
	};
	if (/[0-9]/.test(str)) {
		nowLv++
	};
	if (/[a-z]/.test(str)) {
		nowLv++
	};
	if (/[A-Z]/.test(str)) {
		nowLv++
	};
	return nowLv;
}
/**
 * 返回指定某个区间的一个数字（可以不传参，不传就返回0-255之间的数；可以只传一个，返回0到传入的这个数字之间的某个值）
 * @param n1 开始区间 例：5
 * @param n2 结束区间 例：10
 * @returns 返回这个区间的某个随机值
 */
const randomNumber = (n1, n2) => {
	if (arguments.length === 2) {
		return Math.round(n1 + Math.random() * (n2 - n1));
	} else if (arguments.length === 1) {
		return Math.round(Math.random() * n1)
	} else {
		return Math.round(Math.random() * 255)
	}
}
/**
 * 随机产生某个颜色
 * @returns {String} 颜色 例：rgb(250,82,49)
 */
//randomNumber是上面定义的函数
const randomColor = () => {
	return 'rgb(' + this.randomNumber(255) + ','
	this.randomNumber(255) + ',' + this.randomNumber(255) + ')';
}
/**
 * 简单数组排序，针对数字数组
 * @param type 1：降序，0：升序, 3，4:数组对象排序，通过key值用对象中指定的数值进行排序
 */
const sortArr = (arr, type, key) => {
	if (type == 1) {
		//降序
		arr.sort(function(a, b) {
			return b - a;
		});
	} else if(type == 0) {
		arr.sort(function(a, b) {
			return a - b;
		});
	} else if(type == 3) {
		arr.sort(function(a, b) {
			return a[key] - b[key];
		});
	} else if(type == 4) {
		arr.sort(function(a, b) {
			return b[key] - a[key];
		});
	}
	return arr;
}
/**
* 浏览器全屏
*/
const reqFullScreen = () => {
	if (document.documentElement.requestFullScreen) {
		document.documentElement.requestFullScreen();
	} else if (document.documentElement.webkitRequestFullScreen) {
		document.documentElement.webkitRequestFullScreen();
	} else if (document.documentElement.mozRequestFullScreen) {
		document.documentElement.mozRequestFullScreen();
	}
}
/**
* 浏览器退出全屏
*/
const exitFullScreen = () => {
	if (document.documentElement.requestFullScreen) {
		document.exitFullScreen();
	} else if (document.documentElement.webkitRequestFullScreen) {
		document.webkitCancelFullScreen();
	} else if (document.documentElement.mozRequestFullScreen) {
		document.mozCancelFullScreen();
	}
}
/** 加密 */
const encrypt = (word) => {
	let encrypted = CryptoJS.AES.encrypt(word.toString(), key, //  AES加密
		{
			iv: iv,
			mode: CryptoJS.mode.CBC,
			padding: CryptoJS.pad.Pkcs7 // 后台用的是pad.Pkcs5,前台对应为Pkcs7
		})
	return encrypted.toString()
}
/** 解密 */
const decrypt = (word) => {
	let decrypted = CryptoJS.AES.decrypt(word, key, //  AES解密
		{
			iv: iv,
			mode: CryptoJS.mode.CBC,
			padding: CryptoJS.pad.Pkcs7
		})
	return CryptoJS.enc.Utf8.stringify(decrypted)
}
/** 参数加密 */
const paramsEncrypt = (params = {}) => {
	for (let prop in params) {
		if (params[prop] != null) {
			params[prop] = this.encrypt(params[prop])
		}
	}
}
/** 文件下载*/
const downLoad = (way, url, name, type) => {
	var token = sessionStorage.getItem("account.token") || "";
	var xhr = new XMLHttpRequest();
	xhr.open(way, url, true);
	xhr.responseType = "blob";
	xhr.setRequestHeader("Authorization", "Bearer " + token);
	xhr.onload = function() {
		if (this.status === 200) {
			var blob = this.response;
			var reader = new FileReader();
			reader.readAsDataURL(blob); // 转换为base64，可以直接放入a标签href
			reader.onload = function(e) {
				var a = document.createElement("a"); // 转换完成，创建一个a标签用于下载
				a.download = name + type;
				a.href = e.target.result;
				$("body").append(a); // 修复firefox中无法触发click
				a.click();
				$(a).remove();
			};
		}
	};
	xhr.send(); // 发送ajax请求
}
//id转名称
const findOrgIdToName = (arr, orgid, _name) => {
	arr.forEach(item => {
		if (item.orgid == orgid) {
			_name = item.orgname;
		} else {
			if (item.children && item.children.length) {
				const p = this.findOrgIdToName(item.children, orgid);
				if (p) _name = p;
			}
		}
	});
	return _name;
}
// 小程序判断当前操作系统
const isAndroidOrIOS = (type) => {
	let status = ''
	if(type == 'h5') {
		let u = navigator.userAgent;
		let isAndroid = u.indexOf('Android') > -1 || u.indexOf('Adr') > -1; //android终端
		let isiOS = !!u.match(/\(i[^;]+;( U;)? CPU.+Mac OS X/); //ios终端
		if (isAndroid) {
			status = "android"
		}
		if (isiOS) {
			status = "ios"
		}
	} else {
		let state = ''
		switch(uni.getSystemInfoSync().platform){
		    case 'android':
		       console.log('运行Android上')
			   state = 'android';
		       break;
		    case 'ios':
		       console.log('运行iOS上')
			   state = 'ios'
		       break;
			default:
			    console.log('运行在开发者工具上')
				state = 'devtools'
			    break;
		}
		status = state
	}
	return status
}
// 根据不同的系统添加不同的字体样式 // 本项目专属需求
const getFontFamily = () => {
	let fontFamily = ''
	if(isAndroidOrIOS() == 'ios') {
		fontFamily = 'sfpro'
	} else {
		fontFamily = 'HelveticaNeue'
	}
	return fontFamily
}
/*
	将价格拆分成整数和小数点
	price: 接受需要处理的价格
	num: 保留小数点后几位数，默认为2位
*/
const splitPrice = (price, num = 2) => {
	if(price.toString().indexOf('.' === 0)) price = '0' + price
	let money = parseFloat(price).toFixed(num)
	let obj = {
		showPrice: money.slice(0, money.indexOf('.')),
		mantissa: money.slice(money.indexOf('.'))
	}
	return obj
}


/*
	图片文件缓存本地
	key: 唯一标识名称
	url: 图片文件服务器访问地址
*/
const imageFileStorage = (key, url, index = 1) => {
	let keyName = key
	let imageLink = {
		link: url,
		status: false
	}
	if(typeof keyName == 'string') {
		if(keyName.indexOf('.') != -1) {
			keyName = keyName.split('.')
		}
		let fileObject = uni.getStorageSync('imageStorageFile') || {}
		if(fileObject[`img_${keyName[0]}`]) { // 判断当前图片是否已被缓存
			imageLink = {
				link: fileObject[`img_${keyName[0]}`],
				status: true,
				name: `img_${keyName[0]}`
			}
		} else {
			imageLink.name = `img_${keyName[0]}`
			setTimeout(() => {
				uni.downloadFile({
					url,
					success: (res) => {
						if (res.statusCode === 200) {
							const fs = uni.getFileSystemManager() // 获取全局唯一的文件管理器
							fs.saveFile({
								tempFilePath: res.tempFilePath, // 传入一个临时文件路径
								success(val) {
									fileObject = uni.getStorageSync('imageStorageFile') || {}
									fileObject[`img_${keyName[0]}`] = val.savedFilePath
									uni.setStorageSync('imageStorageFile', fileObject)
								}
							})
						}else {
							console.log('响应失败', res.statusCode)
						}
					},
				})
			}, index * 300)
		}
	}
	return imageLink
}

/*
	将条码商品数据重复的合并，被合并的商品写入规格里面，充当规格使用
	@param {array} 需要处理的数据数组  
	@param {isScreen} 是否需要对处理好的数据进行去重
	@param {prop} 需要对比匹配的字段
	@param {childProp}对比后需要合成的对象名称
*/
const handleDataMerge = (array = [], isScreen = false, prop = 'id', childProp = 'goods') => {
	if(!Array.isArray(array)) return console.error('this.&utils.handleDataMerge() parame is not Array')
	let divideList = [] // 将相同的数据进行划分成 一个对象 并且并入space当中
	array.forEach(key => {
		let obj = deepCopy(key)
		let goods = deepCopy(obj)
		let state = true
		divideList.forEach(item => {
			if(key[prop] == item[prop]) {
				state = false
				item[childProp].push(goods)
			}
		})
		if(state) {
			obj[childProp] = [goods]
			divideList.push(obj)
		}
	})
	if(isScreen) {
		// 将重复的规格去重
		divideList = divideList.map(key => {
			let arr = []
			key[childProp].forEach(item => {
				let state = true
				arr.forEach(j => {
					if(item[prop] == j[prop]) {
						state = false
					}
				})
				if(state) arr.push(item)
			})
			key[childProp] = arr
			return key
		})
	}
	return divideList
}

/*
	获取指定日期属于今年的第几周
	y: 年
	m：月
	d：日
*/
const getWeek = (y,m,d) => {
    let day1 = new Date(y, parseInt(m) - 1, d);
    let day2 = new Date(y, 0, 1);
    let day = Math.round((day1.valueOf() - day2.valueOf()) / 86400000);
    return Math.ceil((day + ((day2.getDay() + 1) - 1)) / 7)
}

/*
	获取日期
	type： 需要获取的时间类型 默认获取 年月日-时分秒
	需要获取什么类型的数据就传入对应的字段  如需要获取全部数据可传入  'value' 查看所有
*/
const getTime = (type = 'dateTime') => {
	const date = new Date()
	const y = date.getFullYear()
	const mm = date.getMonth() + 1
	const d = date.getDate()
	const h = date.getHours()
	const m = date.getMinutes()
	const s = date.getSeconds()
	let obj = {
		value: {
			year: y,
			month: mm > 9 ? mm : '0' + mm,
			date: d > 9 ? d : '0' + d,
			h: h > 9 ? h : '0' + h,
			m: m > 9 ? m : '0' + m,
			s: s > 9 ? s : '0' + s
		},
		date: `${y}-${mm > 9 ? mm : '0' + mm}-${d > 9 ? d : '0' + d}`,
		time: `${h > 9 ? h : '0' + h}:${m > 9 ? m : '0' + m}:${s > 9 ? s : '0' + s}`,
		dateTime: `${y}-${mm > 9 ? mm : '0' + mm}-${d > 9 ? d : '0' + d} ${h > 9 ? h : '0' + h}:${m > 9 ? m : '0' + m}:${s > 9 ? s : '0' + s}`
	}
	return type == 'all' ? obj : obj[type]
}

/*
	将开始时间和结束时间进行计算判断出中间的差值相差几天，可用于做倒计时使用
	endTime: 结束日期 示例：2022-05-20 00:00:00
	startTime: 开始日期 示例：2022-05-12 00:00:00
	type: 是否使用当前时间判断倒计时
*/
const computeTime = (startTime, endTime, type = true) => {
	if(!startTime || !endTime) return console.error('请传入开始时间和结束时间')
	let sTime = new Date(startTime.replace(/-/g, '/')).getTime() // 开始时间
	let eTime = new Date(endTime.replace(/-/g, '/')).getTime() // 结束时间
	let current = new Date().getTime() // 当前时间
	if(!type) current = sTime
	let time = 0 // 当条件都不满足的情况下默认为0 或时间已超过结束时间
	if(current >= sTime && current < eTime) { // 判断当前时间是否处于开始和结束之间
		time = eTime - current
	} else if(current < sTime) { // 判断当前时间是否还未开始，小于当前时间
		time = sTime - current
	}
	const second = Math.floor(time / 1000) // 将格式除1000
	const day = Math.floor(second / 3600 / 24) // 将时间戳计算 总数 除 一个小时 再除一天二十四小时 算出天
	const hr = Math.floor(second / 3600 % 24) // 将时间戳计算 总数 除 1个小时的时间戳 再取余 过滤24小时
	const min = Math.floor(second / 60 % 60) // 算出分钟 将小时进行取余
	const sec = Math.floor(second % 60) // 算出秒数 将分钟进行取余 只留存剩下的秒数
	return {day, hr, min, sec}
}
const handleCutZero = (num) => {
        //拷贝一份 返回去掉零的新串
        let newstr = num;
        //循环变量 小数部分长度
        let leng = num.length - num.indexOf('.') - 1;
        //判断是否有效数
        if (num.indexOf('.') > -1) {
          //循环小数部分
          for (let i = leng; i > 0; i--) {
            //如果newstr末尾有0
            if (
              newstr.lastIndexOf('0') > -1 &&
              newstr.substr(newstr.length - 1, 1) == 0
            ) {
              let k = newstr.lastIndexOf('0');
              //如果小数点后只有一个0 去掉小数点
              if (newstr.charAt(k - 1) == '.') {
                return newstr.substring(0, k - 1);
              } else {
                //否则 去掉一个0
                newstr = newstr.substring(0, k);
              }
            } else {
              //如果末尾没有0
              return newstr;
            }
          }
        }
        return num;
      }

/* 
	生成UUID
	len: 生成的长度 默认为 32位
 */
const createUUID = (len = 32) => {
	let radix = 16;    //16进制
	const chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('');
	let uuid = [], i;
	radix = radix || chars.length;
	if (len) {
		for (i = 0; i < len; i++) {
			uuid[i] = chars[0 | Math.random() * radix];
		}
	} else {
		let r;
		uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-';
		uuid[14] = '4';
		for (i = 0; i < 36; i++) {
			if (!uuid[i]) {
				r = 0 | Math.random() * 16;
				uuid[i] = chars[(i == 19) ? (r & 0x3) | 0x8 : r];
			}
		}
	}
	return uuid.join('');
}

Date.prototype.Format = function(fmt){ //需要JS格式化时间，后期做的时候方便使用   
  var o = {   
    "M+" : this.getMonth()+1,                 //月份   
    "d+" : this.getDate(),                    //日   
    "h+" : this.getHours(),                   //小时   
    "m+" : this.getMinutes(),                 //分   
    "s+" : this.getSeconds(),                 //秒   
    "q+" : Math.floor((this.getMonth()+3)/3), //季度   
    "S"  : this.getMilliseconds()             //毫秒   
  };   
  if(/(y+)/.test(fmt))   
    fmt=fmt.replace(RegExp.$1, (this.getFullYear()+"").substr(4 - RegExp.$1.length));   
  for(var k in o)   
    if(new RegExp("("+ k +")").test(fmt))   
  fmt = fmt.replace(RegExp.$1, (RegExp.$1.length==1) ? (o[k]) : (("00"+ o[k]).substr((""+ o[k]).length)));   
  return fmt;   
};
 
//通过周取日期范围   year 年   weeks 周
const weekGetDate = (year,weeks) => {
    var date = new Date(year,"0","1"); 
    // 获取当前星期几,0:星期一 
    var time = date.getTime(); 
     //当这一年的1月1日为周日时则本年有54周,否则没有54周,没有则去除第54周的提示       
    var _week = date.getDay();   
	console.log(_week)
    if(_week!=0){//一年53周情况 
        if(weeks==54){    
            return '今年没有54周';    
        }    
        var cnt=0;// 获取距离周末的天数    
        if(_week==0){    
            cnt = 7;    
        }else if(_week==1){    
            cnt = 6;    
        }else if(_week==2){    
            cnt = 5;    
        }else if(_week==3){    
            cnt = 4;    
        }else if(_week==4){    
            cnt = 3;    
        }else if(_week==5){    
            cnt = 2;    
        }else if(_week==6){    
            cnt = 1;    
        }    
        cnt += 1;//加1表示以星期一为一周的第一天    // 将这个长整形时间加上第N周的时间偏移    
        time += cnt*24*3600000; //第2周开始时间 
        var nextYear = new Date(parseInt(year,10)+1,"0","1");    
        var nextWeek = nextYear.getDay();    
        var lastcnt = 0;//获取最后一周开始时间到周末的天数    
        if(nextWeek==0){    
            lastcnt = 6;    
        }else if(nextWeek==1){    
            lastcnt = 0;    
        }else if(nextWeek==2){    
            lastcnt = 1;    
        }else if(nextWeek==3){ 
            lastcnt = 2;    
        }else if(nextWeek==4){    
            lastcnt = 3;    
        }else if(nextWeek==5){    
            lastcnt = 4;    
        }else if(nextWeek==6){    
            lastcnt = 5;    
        }    
        if(weeks==1){//第1周特殊处理    // 为日期对象 date 重新设置成时间 time
            var start = new Date(time-7*24*3600000).Format("yyyy-MM-dd");
            date.setTime(time-24*3600000)
            return start + "---" + date.Format("yyyy-MM-dd");
        }else if(weeks==53){//第53周特殊处理  
            //第53周开始时间      
            var start = time+(weeks-2)*7*24*3600000; 
            //第53周结束时间
            var end = time+(weeks-2)*7*24*3600000 + lastcnt*24*3600000 - 24*3600000;
            date.setTime(start);    
            var _start = date.Format("yyyy-MM-dd"); 
            date.setTime(end);    
            var _end = date.Format("yyyy-MM-dd"); 
           return _start + "---"  + _end;
        }else{    
            var start = time+(weeks-2)*7*24*3600000; //第n周开始时间    
            var end = time+(weeks-1)*7*24*3600000 - 24*3600000; //第n周结束时间
            date.setTime(start);    
            var _start = date.Format("yyyy-MM-dd");     
            date.setTime(end);    
            var _end = date.Format("yyyy-MM-dd");
            return _start + "---"  + _end;
        } 
    }else{//一年54周情况    
        var cnt=0;// 获取距离周末的天数    
        if(_week==0 && weeks==1){//第一周    
            cnt = 0;    
        }else if(_week==0){    
            cnt = 7;    
        }else if(_week==1){    
            cnt = 6;    
        }else if(_week==2){    
            cnt = 5;    
        }else if(_week==3){    
            cnt = 4;    
        }else if(_week==4){    
            cnt = 3;    
        }else if(_week==5){    
            cnt = 2;    
        }else if(_week==6){    
            cnt = 1;    
        }    
        cnt += 1;//加1表示以星期一为一周的第一天    
        // 将这个长整形时间加上第N周的时间偏移    
        time += 24*3600000; //第2周开始时间    
        var nextYear = new Date(parseInt(year,10)+1,"0","1");    
        var nextWeek = nextYear.getDay();    
        var lastcnt = 0;//获取最后一周开始时间到周末的天数    
        if(nextWeek==0){    
            lastcnt = 6;    
        }else if(nextWeek==1){    
            lastcnt = 0;    
        }else if(nextWeek==2){ 
            lastcnt = 1;    
        }else if(nextWeek==3){    
            lastcnt = 2;    
        }else if(nextWeek==4){    
            lastcnt = 3;    
        }else if(nextWeek==5){    
            lastcnt = 4;    
        }else if(nextWeek==6){    
            lastcnt = 5;    
        }    
        if(weeks==1){//第1周特殊处理
            var start = date.Format("yyyy-MM-dd"); 
            date.setTime(time-24*3600000);
            console.log(start +'--'+ date);
            return _start + "---"  + date;
        }else if(weeks==54){//第54周特殊处理   
            //第54周开始时间    
            var start = time+(weeks-2)*7*24*3600000; 
            //第53周结束时间 
            var end = time+(weeks-2)*7*24*3600000 + lastcnt*24*3600000 - 24*3600000; 
            date.setTime(start);    
            var _start = date.Format("yyyy-MM-dd"); 
            date.setTime(end);    
            var _end = date.Format("yyyy-MM-dd");
            return _start + "---"  + _end;
        }else{    
            var start = time+(weeks-2)*7*24*3600000; //第n周开始时间    
            var end = time+(weeks-1)*7*24*3600000 - 24*3600000; //第n周结束时间
            date.setTime(start);    
            var _start = date.Format("yyyy-MM-dd"); 
            date.setTime(end);    
            var _end = date.Format("yyyy-MM-dd");
            return _start + "---"  + _end;
        }    
    }    
}
//贪心算法--平摊
function distribute(amount, number, precision = 2) {
  // 控制精确度
  const multiplier = Math.pow(10, precision);
  
  amount = Math.floor(amount * multiplier) / multiplier;
  const result = [];
  while (number > 0) {
    const avg = Math.floor((amount / number) * multiplier) / multiplier;
    result.push(avg);
    amount = Math.round((amount - avg) * multiplier) / multiplier; // 更新剩余金额
    number--; // 更新剩余人数
  }
  // 处理余数，余数按照与每个人差额最小的原则递增平摊
  let remainder = Math.floor(amount * multiplier) / multiplier;
  let i = 0;
  while (remainder > 0) {
    result[i] = (result[i] + (1 / multiplier));
    remainder = Math.round((remainder - (1 / multiplier)) * multiplier) / multiplier;
    i = (i + 1) % result.length;
  }
  // 按从小到大排序
  result.sort((a, b) => a - b);
  
  return result;
}

/**每个4位打印空格*/
	formattedValue(item) {
				// 将每隔4位添加一个空格
				let val = JSON.parse(JSON.stringify(item))
				console.log(val);
				val = val.replace(/\s/g, '').replace(/(\d{4})(?=\d)/g, '$1 ');
				console.log(val);
				return val;
			},
//当前时间戳转日期
getTimer() {
				let timer = new Date().getTime()
				var date = new Date(timer); //时间戳为10位需*1000，时间戳为13位的话不需乘1000
				var Y = date.getFullYear() + '-';
				var M = (date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1) + '-';
				var D = date.getDate() + ' ';
				var h = (date.getHours() < 10 ? '0' + date.getHours() : date.getHours()) + ':';
				var m = (date.getMinutes() < 10 ? '0' + date.getMinutes() : date.getMinutes()) + ':';
				var s = (date.getSeconds() < 10 ? '0' + date.getSeconds() : date.getSeconds());
				return Y + M + D + h + m + s;
			},
//获取当天的最后时间戳
let etimer = new Date('2023-07-16');
etimer.setHours(24, 0, 0, 0).getTime() / 1000