js 方法工具
1、在网址中提取需要的参数值
1 //获取url中的参数 path->地址url name->想要拿取的地址中的参数
2 const getUrlParam = (path, name) => {
3 var reg = new RegExp("(^|\\?|&)" + name + "=([^&]*)(\\s|&|$)", "i");
4 if (reg.test(path))
5 return unescape(RegExp.$2.replace(/\+/g, " "));
6 return "";
7 }
2、开始时间到结束时间，根据传入的间隔时间，分割成数组
1 /*
2 * @aaaaaass引入monent.js
3 * @param {*} startDate 开始时间
4 * @param {*} endDate 结束时间
5 * @param {*} space 间隔
6 */
7 getDateArray: (startT = "09:00", endT = "14:00", interval = 10) => {
8 let starTime = monent(startT, "HH:mm");
9 let endTime = monent(endT, "HH:mm");
10 let diff = endTime.diff(starTime, "minutes");
11 let num = Math.ceil(diff / interval);
12 var segs = []
13 for (let i = 1; i <= num; i++) {
14 let timeFrom = starTime.clone().add((i - 1) * interval, "minutes")
15 let timeTo = starTime.clone().add(i * interval, "minutes");
16 let minutes = timeFrom.minutes();
17 let hour = timeFrom.hour()
18 segs.push({
19 text: timeFrom.format("HH:mm") + '-' + timeTo.format("HH:mm"),
20 value: timeFrom.format("HH:mm") + '-' + timeTo.format("HH:mm"),
21
22 });
23 }
24 return segs
25 },
3、两个数组，对比相同的
1 let oldList = [1,2,3,4,5,6,7] //已经选择的活动id集
2 let rejectIds = [7,8,9,0,11,12] //新的id集
3
4 if(oldList.length < 1) return
5
6 let deleteOldIds = [] //两个id集的交集
7
8 deleteOldIds = oldList.filter(item=>{
9 return rejectIds.includes(item)
10 })
4、计算
1 export const CalcObj = {
2 /*
3 函数，加法函数，用来得到精确的加法结果
4 说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。
5 参数：arg1：第一个加数；arg2第二个加数；d要保留的小数位数（可以不传此参数，如果不传则不处理小数位数）
6 调用：Calc.Add(arg1,arg2,d)
7 返回值：两数相加的结果
8 */
9 Add : function (arg1='', arg2='') {
10 arg1 = arg1.toString(), arg2 = arg2.toString();
11 var arg1Arr = arg1.split("."), arg2Arr = arg2.split("."), d1 = arg1Arr.length == 2 ? arg1Arr[1] : "", d2 = arg2Arr.length == 2 ? arg2Arr[1] : "";
12 var maxLen = Math.max(d1.length, d2.length);
13 var m = Math.pow(10, maxLen);
14 var result = Number(((arg1 * m + arg2 * m) / m).toFixed(maxLen));
15 var d = arguments[2];
16 return typeof d === "number" ? Number((result).toFixed(d)) : result;
17 },
18 /*
19 函数：减法函数，用来得到精确的减法结果
20 说明：函数返回较为精确的减法结果。
21 参数：arg1：第一个加数；arg2第二个加数；d要保留的小数位数（可以不传此参数，如果不传则不处理小数位数
22 调用：Calc.Sub(arg1,arg2)
23 返回值：两数相减的结果
24 */
25 Sub : function (arg1='', arg2='') {
26 return CalcObj.Add(arg1, -Number(arg2), arguments[2]);
27 },
28 /*
29 函数：乘法函数，用来得到精确的乘法结果
30 说明：函数返回较为精确的乘法结果。
31 参数：arg1：第一个乘数；arg2第二个乘数；d要保留的小数位数（可以不传此参数，如果不传则不处理小数位数)
32 调用：Calc.Mul(arg1,arg2)
33 返回值：两数相乘的结果
34 */
35 Mul : function (arg1='', arg2='') {
36 var r1 = arg1.toString(), r2 = arg2.toString(), m, resultVal, d = arguments[2];
37 m = (r1.split(".")[1] ? r1.split(".")[1].length : 0) + (r2.split(".")[1] ? r2.split(".")[1].length : 0);
38 resultVal = Number(r1.replace(".", "")) * Number(r2.replace(".", "")) / Math.pow(10, m);
39 return typeof d !== "number" ? Number(resultVal) : Number(resultVal.toFixed(parseInt(d)));
40 },
41 /*
42 函数：除法函数，用来得到精确的除法结果
43 说明：函数返回较为精确的除法结果。
44 参数：arg1：除数；arg2被除数；d要保留的小数位数（可以不传此参数，如果不传则不处理小数位数)
45 调用：Calc.Div(arg1,arg2)
46 返回值：arg1除于arg2的结果
47 */
48 Div : function (arg1='', arg2='') {
49 var r1 = arg1.toString(), r2 = arg2.toString(), m, resultVal, d = arguments[2];
50 m = (r2.split(".")[1] ? r2.split(".")[1].length : 0) - (r1.split(".")[1] ? r1.split(".")[1].length : 0);
51 resultVal = Number(r1.replace(".", "")) / Number(r2.replace(".", "")) * Math.pow(10, m);
52 return typeof d !== "number" ? Number(resultVal) : Number(resultVal.toFixed(parseInt(d)));
53 }
54 }
5、千分逗号
1 // 千分位逗号
2 export function thousandSeparator(n) {
3 // return (num.toString().indexOf ('.') !== -1) ? num.toLocaleString() : num.toString().replace(/(\d)(?=(?:\d{3})+$)/g, '$1,')
4 // return (num+ '').replace(/(\d{1,3})(?=(\d{3})+(?:$|\.))/g,'$1,')
5
6 let num = n.toString()
7 let split = num.split('.')
8
9 num = split[0]
10 let len = num.length
11 if (len <= 3) {
12 return n
13 } else {
14 let temp = ''
15 let remainder = len % 3
16 // 判断是否有小数
17 split[1] != undefined ? temp = '.' + split[1] : temp
18 if (remainder > 0) { // 不是3的整数倍
19 return num.slice(0, remainder) + ',' + num.slice(remainder, len).match(/\d{3}/g).join(',') + temp
20 } else { // 是3的整数倍
21 return num.slice(0, len).match(/\d{3}/g).join(',') + temp
22 }
23 }
24 }
6、数字大写转换
1 /**
2 * 大数字转换，将大额数字转换为万、千万、亿等
3 * @param value 数字值
4 */
5 export function bigNumberTransform(value) {
6 const newValue = ['', '', '']
7 let fr = 1000
8 let num = 3
9 let text1 = ''
10 let fm = 1
11 value = String(value)
12 let strStart = value.substring(0, 1) == '-' ? '-' : ''
13 if (strStart) {
14 value = value.substring(1, value.length)
15 }
16 while (value / fr >= 1) {
17 fr *= 10
18 num += 1
19 // console.log('数字', value / fr, 'num:', num)
20 }
21 if (num <= 4) { // 千
22 newValue[0] = parseInt(value / 1000) + ''
23 newValue[1] = '千'
24 } else if (num <= 8) { // 万
25 text1 = parseInt(num - 4) / 3 > 1 ? '千万' : '万'
26 // tslint:disable-next-line:no-shadowed-variable
27 fm = text1 === '万' ? 10000 : 10000000
28 if (value % fm === 0) {
29 newValue[0] = parseInt(value / fm) + ''
30 } else {
31 newValue[0] = parseFloat(value / fm).toFixed(2) + ''
32 }
33 newValue[1] = text1
34 } else if (num <= 16) { // 亿
35 text1 = (num - 8) / 3 > 1 ? '千亿' : '亿'
36 text1 = (num - 8) / 4 > 1 ? '万亿' : text1
37 text1 = (num - 8) / 7 > 1 ? '千万亿' : text1
38 // tslint:disable-next-line:no-shadowed-variable
39 fm = 1
40 if (text1 === '亿') {
41 fm = 100000000
42 } else if (text1 === '千亿') {
43 fm = 100000000000
44 } else if (text1 === '万亿') {
45 fm = 1000000000000
46 } else if (text1 === '千万亿') {
47 fm = 1000000000000000
48 }
49 if (value % fm === 0) {
50 newValue[0] = parseInt(value / fm) + ''
51 } else {
52 newValue[0] = parseFloat(value / fm).toFixed(2) + ''
53 }
54 newValue[1] = text1
55 }
56 if (value < 1000) {
57 newValue[0] = value + ''
58 newValue[1] = ''
59 }
60 return strStart + newValue.join('')
61 }
-----------
/**
* 大数字转换，将大额数字转换为万、千万、亿等
* @paramvalue 数字值
*/
export function bigNumberTransform(value) {
const newValue = ['', '', '']
let fr = 1000
let num = 3
let text1 = ''
let fm = 1
value = String(value)
let strStart = value.substring(0, 1) == '-' ? '-' : ''
if (strStart) {
value = value.substring(1, value.length)
}
while (value / fr >= 1) {
fr *= 10
num += 1
// console.log('数字', value / fr, 'num:', num)
}
if (num <= 4) { // 千
newValue[0] = parseInt(value / 1000) + ''
newValue[1] = '千'
} else if (num <= 8) { // 万
text1 = parseInt(num - 4) / 3 > 1 ? '千万' : '万'
// tslint:disable-next-line:no-shadowed-variable
fm = text1 === '万' ? 10000 : 10000000
if (value % fm === 0) {
newValue[0] = parseInt(value / fm) + ''
} else {
newValue[0] = parseFloat(value / fm).toFixed(2) + ''
}
newValue[1] = text1
} else if (num <= 16) { // 亿
text1 = (num - 8) / 3 > 1 ? '千亿' : '亿'
text1 = (num - 8) / 4 > 1 ? '万亿' : text1
text1 = (num - 8) / 7 > 1 ? '千万亿' : text1
// tslint:disable-next-line:no-shadowed-variable
fm = 1
if (text1 === '亿') {
fm = 100000000
} else if (text1 === '千亿') {
fm = 100000000000
} else if (text1 === '万亿') {
fm = 1000000000000
} else if (text1 === '千万亿') {
fm = 1000000000000000
}
if (value % fm === 0) {
newValue[0] = parseInt(value / fm) + ''
} else {
newValue[0] = parseFloat(value / fm).toFixed(2) + ''
}
newValue[1] = text1
}
if (value < 1000) {
newValue[0] = value + ''
newValue[1] = ''
}
return strStart + newValue.join('')
}
忍一时，越想越气；
退一步，哎呦我去！
