debounce - 防抖函数
如果用户多次频繁操作以最后一次为准，当然也可以以第一次为准，进行数据更新或者网络资源请求，以消除冗余的操作，或者减少一定的请求资源浪费。
/**
* 防抖函数
* @param {*} fn
* @param {*} delay
*/
const debounce = (fn, delay == 300) => {
let timer = null;
return (...args) => {
if (timer) {
clearTimeout(timer);
}
timer = setTimeout(() => {
fn(...args);
timer = null;
}, delay);
};
};
// 模拟点击事件处理函数
const handleClick = () => {
console.log('按钮被点击了');
};
// 创建防抖后的点击处理函数
const debouncedClick = debounce(handleClick, 500);
throttle - 节流函数
在一定时间范围内，用户触发多次只会执行一次以达到防止用户频繁操作的目的。
/**
* 节流函数
* @param {*} fn
* @param {*} delay
*/
const throttle = (fn, delay == 300) => {
let timer = null;
return (...args) => {
if (!timer) {
fn(...args);
timer = setTimeout(() => {
timer = null;
}, delay);
}
};
};
// 模拟点击事件处理函数
const handleClick = () => {
console.log('按钮被点击了');
};
// 创建节流后的点击处理函数
const throttledClick = throttle(handleClick, 1000);
Desensitization - 前端数据脱敏化
/**
* @description 前端数据脱敏化
* @param {*} str 需要脱敏的数据
* @param {*} beginLen 开始脱敏的位置
* @param {*} endLen 结束脱敏的位置
* @returns
*/
export function Desensitization(str, beginLen, endLen) {
let len = str.length;
let firstStr = str.substr(0, beginLen);
let lastStr = str.substr(endLen);
let middleStr = str.substring(beginLen, len - Math.abs(endLen)).replace(/[\s\S]/ig, '*');
let tempStr = firstStr + middleStr + lastStr;
return tempStr;
}
deepCopy - 深度复制
/**
* @description 深度复制
* @param source 任意类型
* @return
*/
export function deepCopy(source) {
if (typeof source != "object") {
return source
}
if (source == null) {
return source
}
let newObj = source.constructor === Array ? [] : {} //开辟一块新的内存空间
for (let i in source) {
newObj[i] = deepCopy(source[i])
}
return newObj
}
fillMath - 精确计算
/**
* 精确计算
* @param num1被加数/被减数/被乘数/被除数(num2不为0时)
* @param num2加数/减数/乘数/除数
* @param type算法类型
* @return
*/
export function fillMath(num1, num2, type) {
type = type || "plus";
let tmpNum1 = String(num1);
let tmpNum2 = String(num2);
tmpNum1 = tmpNum1.split(".");
tmpNum2 = tmpNum2.split(".");
let len1 = tmpNum1.length == 2 ? tmpNum1[1].length : 0;
let len2 = tmpNum2.length == 2 ? tmpNum2[1].length : 0;
let maxLen = len1 > len2 ? len1 : len2;
let powNum = 1;
if (maxLen) {
powNum = Math.pow(10, maxLen);
}
let result = 0;
switch (type) {
// 除法
case "division":
result = num2 ? (num1 * powNum) / (num2 * powNum) : 0;
break;
// 乘法
case "multiply":
result = (num1 * powNum * num2 * powNum) / (powNum * powNum);
break;
// 减法
case "minus":
result = (num1 * powNum - num2 * powNum) / powNum;
break;
// 加法
default:
result = (num1 * powNum + num2 * powNum) / powNum;
break;
}
return result;
}
transNum - 阿拉伯数字转汉字
/**
* 数字转汉字
* @param Number num 数字
* @param Boolean issup 是否大写，默认是小写
* @param Boolean replace 是否需要转译：二十变成廿，三十变成卅，默认不需要
* @param Boolean cutFirst 当第一个数字为1时，是否需要剪掉，默认不需要
* @param Boolean ignore 是否忽略进制，默认是不忽略
* @return String 数字对应的汉字
*/
export function transNum(num, issup, replace, cutFirst, ignore) {
issup = issup || false;
replace = replace || false;
cutFirst = cutFirst || false;
ignore = ignore || false;
function divisionTen(tmpNum, ignore, issup, countDivision) {
countDivision = countDivision || 0;
var str = "",
tmpStr = "",
unitStr = "";
var tenStr, unitStr1;
if (issup) {
tenStr = ["零", "壹", "貳", "叁", "肆", "伍", "陸", "柒", "捌", "玖"];
unitStr1 = ["拾", "佰", "仟", "萬", "亿", "兆"];
} else {
tenStr = ["〇", "一", "二", "三", "四", "五", "六", "七", "八", "九"];
unitStr1 = ["十", "百", "千", "万", "亿", "兆"];
}
var intNum = parseInt(tmpNum / 10);
var slotNum = tmpNum % 10;
countDivision++;
tmpStr = tenStr[slotNum];
if (intNum > 10) {
tmpStr = ignore ? tmpStr : unitStr1[countDivision - 1] + tmpStr;
str = divisionTen(intNum, ignore, issup, countDivision) + tmpStr;
} else {
if (intNum) {
unitStr = ignore ? tenStr[intNum] : tenStr[intNum] + unitStr1[countDivision - 1];
}
str = unitStr + tmpStr;
}
return str;
}
var numChars = divisionTen(num, ignore, issup);
// 去掉第一个字符为一/壹的
var firstChar = numChars.substr(0, 1);
if (ignore) cutFirst = false;
if (cutFirst && (firstChar == "一" || firstChar == "壹") && numChars != "一" && numChars != "壹") {
numChars = numChars.substr(1);
}
var replaceNum = num % 100;
if (replaceNum > 20 && replaceNum < 30 && replace) {
numChars = numChars.replace("二十", "廿");
numChars = numChars.replace("貳拾", "廿");
}
if (replaceNum > 30 && replaceNum < 40 && replace) {
numChars = numChars.replace("三十", "卅");
numChars = numChars.replace("叁拾", "卅");
}
numChars = numChars.replace("十〇", "十");
numChars = numChars.replace("拾零", "拾");
return numChars;
}
long2Omit - 字符串过长截取掉并用...代替结尾
/**
* 字符过长以点代替
* @param {String} str 字符串
* @param {Number} start 截取开始index
* @param {Number} end 截取结束index
* @param {Number} length str的长度大于多少才开始执行截取
*/
export function long2Omit(str, start, end, leng) {
str = str || "";
return str.length>leng ? str.slice(start || 0, end || 10) + '···' : str
}
titleCase - 首字母大写
/**
* 首字母大写
* @param {String} str 字符串
*/
export function titleCase(str) {
str = str || ""
return str.replace(/( |^)[a-z]/g, L => L.toUpperCase())
}
setStorage - 本地缓存---存储数据
/**
* 从localStorage/sessionStorage里存储缓存数据
* @param {String} key 存储name
* @param {String} value 存储值
* @param {Number} storageType 缓存类型 1:sessionStorage 2:localStorage
*/
export function setStorage(key, value, storageType) {
storageType = storageType ?? 1
value = value ?? ""
if (typeof value == "object") { value = JSON.stringify(value) }
storageType == 2 ? localStorage.setItem(key, value) : sessionStorage.setItem(key, value)
}
getStorage - 本地缓存---获取数据
/**
* 从localStorage/sessionStorage里获取缓存数据
* @param {Object} key 缓存的key
* @param {Object} isobj 待取数据是否为对象类型
* @param {Object} storageType 缓存类型，1:sessionStorage 2:localStorage
*/
export function getStorage(key, isobj, storageType) {
storageType = storageType || 1
isobj = isobj == undefined ? true : isobj
let arg = storageType == 2 ? localStorage.getItem(key) : sessionStorage.getItem(key)
if (isobj) {
arg = JSON.parse(arg || "{}")
} else {
arg = arg || ""
}
return arg
}
