# 重构 - 用各种方式优化自己的函数库

2018.06.11 08:46 2181浏览

1.前言

2.单一职责原则

### 2-1.getCount

``````/**
* @description 降序返回数组（字符串）每个元素的出现次数
* @param arr 待处理数组
* @param rank 长度 （默认数组长度）
* @param ranktype 排序方式（默认降序）
*/
getCount(arr, rank, ranktype) {
let obj = {}, k, arr1 = []
//记录每一元素出现的次数
for (let i = 0, len = arr.length; i < len; i++) {
k = arr[i];
if (obj[k]) {
obj[k]++;
} else {
obj[k] = 1;
}
}
//保存结果{el-'元素'，count-出现次数}
for (let o in obj) {
arr1.push({el: o, count: obj[o]});
}
//排序（降序）
arr1.sort(function (n1, n2) {
return n2.count - n1.count
});
//如果ranktype为1，则为升序，反转数组
if (ranktype === 1) {
arr1 = arr1.reverse();
}
let rank1 = rank || arr1.length;
return arr1.slice(0, rank1);
},``````

``````//返回值：el->元素，count->次数
ecDo.getCount([1,2,3,1,2,5,2,4,1,2,6,2,1,3,2])
//默认情况，返回所有元素出现的次数
//result：[{"el":"2","count":6},{"el":"1","count":4},{"el":"3","count":2},{"el":"4","count":1},{"el":"5","count":1},{"el":"6","count":1}]

ecDo.getCount([1,2,3,1,2,5,2,4,1,2,6,2,1,3,2],3)
//传参（rank=3），只返回出现次数排序前三的
//result：[{"el":"2","count":6},{"el":"1","count":4},{"el":"3","count":2}]

ecDo.getCount([1,2,3,1,2,5,2,4,1,2,6,2,1,3,2],null,1)
//传参（ranktype=1,rank=null），升序返回所有元素出现次数
//result：[{"el":"6","count":1},{"el":"5","count":1},{"el":"4","count":1},{"el":"3","count":2},{"el":"1","count":4},{"el":"2","count":6}]

ecDo.getCount([1,2,3,1,2,5,2,4,1,2,6,2,1,3,2],3,1)
//传参（rank=3，ranktype=1），只返回出现次数排序（升序）前三的
//result：[{"el":"6","count":1},{"el":"5","count":1},{"el":"4","count":1}]``````

``````/**
* @description 降序返回数组（字符串）每个元素的出现次数
* @param arr
* @return {Array}
*/
getCount(arr) {
let obj = {}, k, arr1 = []
//记录每一元素出现的次数
for (let i = 0, len = arr.length; i < len; i++) {
k = arr[i];
if (obj[k]) {
obj[k]++;
} else {
obj[k] = 1;
}
}
//保存结果{el-'元素'，count-出现次数}
for (let o in obj) {
arr1.push({el: o, count: obj[o]});
}
//排序（降序）
arr1.sort(function (n1, n2) {
return n2.count - n1.count
});
return arr1;
},``````
3.开放-封闭原则

### 3-1.checkType

checkType 检测字符串类型。以前的实现方式是。

``````/**
* @description 检测字符串
* @param str 待处理字符串
* @param type 待检测的类型
*/
checkType(str, type) {
switch (type) {
case 'email':
return /^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+\$/.test(str);
case 'mobile':
return /^1[3|4|5|7|8][0-9]{9}\$/.test(str);
case 'tel':
return /^(0\d{2,3}-\d{7,8})(-\d{1,4})?\$/.test(str);
case 'number':
return /^[0-9]\$/.test(str);
case 'english':
return /^[a-zA-Z]+\$/.test(str);
case 'text':
return /^\w+\$/.test(str);
case 'chinese':
return /^[\u4E00-\u9FA5]+\$/.test(str);
case 'lower':
return /^[a-z]+\$/.test(str);
case 'upper':
return /^[A-Z]+\$/.test(str);
default:
return true;
}
},``````

``````ecDo.checkType('165226226326','mobile');
//result:false``````

``````/**
* @description 检测字符串
*/
checkType:(function(){
let rules={
email(str){
return /^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+\$/.test(str);
},
mobile(str){
return /^1[3|4|5|7|8][0-9]{9}\$/.test(str);
},
tel(str){
return /^(0\d{2,3}-\d{7,8})(-\d{1,4})?\$/.test(str);
},
number(str){
return /^[0-9]\$/.test(str);
},
english(str){
return /^[a-zA-Z]+\$/.test(str);
},
text(str){
return /^\w+\$/.test(str);
},
chinese(str){
return /^[\u4E00-\u9FA5]+\$/.test(str);
},
lower(str){
return /^[a-z]+\$/.test(str);
},
upper(str){
return /^[A-Z]+\$/.test(str);
}
};
return {
/**
* @description 检测接口
* @param str 待处理字符串
* @param type 待检测的类型
*/
check(str, type){
return rules[type]?rules[type](str):false;
},
/**
* @description 添加规则扩展接口
* @param type 规则名称
* @param fn 处理函数
*/
rules[type]=fn;
}
}
})(),``````

``````console.log(ecDo.checkType.check('165226226326','mobile'));//false
return /^[-a-zA-Z0-9._]+\$/.test(str);
})

4.最少知识原则

### 4-1.trim

``````/**
* @description 大小写切换
* @param str 待处理字符串
* @param type 去除类型（1-所有空格  2-左右空格  3-左空格 4-右空格）
*/
trim(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;
}
}``````

``````//去除所有空格
ecDo.trim('  1235asd',1);
//去除左空格
ecDo.trim('  1235 asd ',3);``````

``````/**
* @description 清除左右空格
*/
trim(str) {
return str.replace(/(^\s*)|(\s*\$)/g, "");
},
/**
* @description 清除所有空格
*/
trimAll(str){
return str.replace(/\s+/g, "");
},
/**
* @description 清除左空格
*/
trimLeft(str){
return str.replace(/(^\s*)/g, "");
},
/**
* @description 清除右空格
*/
trimRight(str){
return str.replace(/(\s*\$)/g, "");
}``````

``````//去除所有空格
ecDo.trim('  123 5asd');
//去除左空格
ecDo.trimLeft('  1235 asd ');``````

### 4-2.encryptStr

``````/**
* @description 加密字符串
* @param str 字符串
* @param regArr 字符格式
* @param type 替换方式
* @param ARepText 替换的字符（默认*）
*/
encryptStr(str, regArr, type = 0, ARepText = '*') {
let regtext = '',
Reg = null,
replaceText = ARepText;
//repeatStr是在上面定义过的（字符串循环复制），大家注意哦
if (regArr.length === 3 && type === 0) {
regtext = '(\\w{' + regArr[0] + '})\\w{' + regArr[1] + '}(\\w{' + regArr[2] + '})'
Reg = new RegExp(regtext);
let replaceCount = this.repeatStr(replaceText, regArr[1]);
return str.replace(Reg, '\$1' + replaceCount + '\$2')
}
else if (regArr.length === 3 && type === 1) {
regtext = '\\w{' + regArr[0] + '}(\\w{' + regArr[1] + '})\\w{' + regArr[2] + '}'
Reg = new RegExp(regtext);
let replaceCount1 = this.repeatStr(replaceText, regArr[0]);
let replaceCount2 = this.repeatStr(replaceText, regArr[2]);
return str.replace(Reg, replaceCount1 + '\$1' + replaceCount2)
}
else if (regArr.length === 1 && type === 0) {
regtext = '(^\\w{' + regArr[0] + '})'
Reg = new RegExp(regtext);
let replaceCount = this.repeatStr(replaceText, regArr[0]);
return str.replace(Reg, replaceCount)
}
else if (regArr.length === 1 && type === 1) {
regtext = '(\\w{' + regArr[0] + '}\$)'
Reg = new RegExp(regtext);
let replaceCount = this.repeatStr(replaceText, regArr[0]);
return str.replace(Reg, replaceCount)
}
},``````

``````ecDo.encryptStr('18819322663',[3,5,3],0,'+')
//result：188+++++663
ecDo.encryptStr('18819233362',[3,5,3],1,'+')
//result：+++19233+++
ecDo.encryptStr('18819233362',[5],0)
//result：*****233362
ecDo.encryptStr('18819233362',[5],1)
//result："188192*****"``````

``````/**
* @description 加密字符串
* @param regIndex 加密位置  （开始加密的索引，结束加密的索引）
* @param ARepText 加密的字符 （默认*）
*/
encryptStr(str, regIndex, ARepText = '*') {
let regtext = '',
Reg = null,
_regIndex=regIndex.split(','),
replaceText = ARepText;
//repeatStr是在上面定义过的（字符串循环复制），大家注意哦
_regIndex=_regIndex.map(item=>+item);
regtext = '(\\w{' + _regIndex[0] + '})\\w{' + (1+_regIndex[1]-_regIndex[0]) + '}';
Reg = new RegExp(regtext);
let replaceCount = this.repeatStr(replaceText, (1+_regIndex[1]-_regIndex[0]));
return str.replace(Reg, '\$1' + replaceCount);
},
/**
* @description 不加密字符串
* @param regIndex 不加密位置  （开始加密的索引，结束加密的索引）
* @param ARepText 不加密的字符 （默认*）
*/
encryptUnStr(str, regIndex, ARepText = '*') {
let regtext = '',
Reg = null,
_regIndex=regIndex.split(','),
replaceText = ARepText;
_regIndex=_regIndex.map(item=>+item);
regtext = '(\\w{' + _regIndex[0] + '})(\\w{' + (1+_regIndex[1]-_regIndex[0]) + '})(\\w{' + (str.length-_regIndex[1]-1) + '})';
Reg = new RegExp(regtext);
let replaceCount1 = this.repeatStr(replaceText, _regIndex[0]);
let replaceCount2 = this.repeatStr(replaceText, str.length-_regIndex[1]-1);
return str.replace(Reg, replaceCount1 + '\$2' + replaceCount2);
},
/**
* @description 字符串开始位置加密
* @param regIndex 加密长度
* @param ARepText 加密的字符 （默认*）
*/
encryptStartStr(str,length,replaceText = '*'){
let regtext = '(\\w{' + length + '})';
let Reg = new RegExp(regtext);
let replaceCount = this.repeatStr(replaceText, length);
return str.replace(Reg, replaceCount);
},
/**
* @description 字符串结束位置加密
* @param regIndex 加密长度
* @param ARepText 加密的字符 （默认*）
*/
encryptEndStr(str,length,replaceText = '*'){
return this.encryptStartStr(str.split('').reverse().join(''),length,replaceText).split('').reverse().join('');
},``````

``````console.log(`加密字符 \${ecDo.encryptStr('18819233362','3,7','+')}`)
//result:188+++++362
console.log(`不加密字符 \${ecDo.encryptUnStr('18819233362','3,7','+')}`)
//result:+++19233+++
console.log(`字符串开始位置加密 \${ecDo.encryptStartStr('18819233362','4')}`)
//result:****9233362
console.log(`字符串结束位置加密 \${ecDo.encryptEndStr('18819233362','4')}`)
//result:1881923****``````

``````/**
* @param value 值
* @param iDay 有效时间（天数）
*/
let oDate = new Date();
oDate.setDate(oDate.getDate() + iDay);
document.cookie = name + '=' + value + ';expires=' + oDate;
},
/**
*/
for (let i = 0; i < arr.length; i++) {
arr2 = arr[i].split('=');
if (arr2[0] == name) {
return arr2[1];
}
}
return '';
},
/**
*/
},``````

``````ecDo.setCookie(cookieName,'守候',1)//设置（有效时间为1天）

``````/**
* @param value 值
* @param iDay 有效时间（天数）
*/
if(arguments.length===1){
}
else{
}
},``````

``````ecDo.cookie(cookieName,'守候',1)//设置

5.代码优化

### 5-1.checkPwdLevel

``````/**
* @description 检测密码强度
*/
checkPwdLevel(str) {
let 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++
}
if (/[\.|-|_]/.test(str)) {
nowLv++
}
return nowLv;
},``````

``````console.log(ecDo.checkPwdLevel('asd188AS19663362_.'));
//4``````

``````/**
* @description 检测密码强度
*/
checkPwdLevel(str) {
let nowLv = 0;
if (str.length < 6) {
return nowLv
}
//把规则整理成数组，再进行循环判断
let rules=[/[0-9]/,/[a-z]/,/[A-Z]/,/[\.|-|_]/];
for(let i=0;i<rules.length;i++){
if(rules[i].test(str)){
nowLv++;
}
}
return nowLv;
},``````

### 5-2.upsetArr

``````/**
* @description 数组顺序打乱
* @param arr
*/
upsetArr(arr) {
return arr.sort(() => {
return Math.random() - 0.5
});
},``````

``ecDo.upsetArr([1,2,3,4,5,6,7,8,9]);``

``````/**
* @description 数组顺序打乱
* @param arr
* @return {Array.<T>}
*/
upsetArr(arr) {
let j,_item;
for (let i=0; i<arr.length; i++) {
j = Math.floor(Math.random() * i);
_item = arr[i];
arr[i] = arr[j];
arr[j] = _item;
}
return arr;
},``````

6.小结

6人点赞

• 6
• 4
• 收藏
• 共同学习，写下你的评论

0/150