// import Crypto from "crypto-js"
import CryptoJS from "crypto-js"
import {Message} from 'element-ui'
import store from "@/vuex/index.js"
const debounce=(func, wait)=>{
let timer;
return function() {
let context = this; // 注意 this 指向
let args = arguments; // arguments中存着e
if (timer) clearTimeout(timer);
timer = setTimeout(() => {
func.apply(this, args)
}, wait)
}
}
const regNum= num=>{
let reg=/^[0-9]+$/
if(reg.test(num)){
return true
}else{
return false
}
}
// 判断是否为邮箱地址
const isEmail = str => {
return /\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*/.test(str);
}
// 判断是否为邮箱地址
const isPhoneNum = str => {
return /^(0|86|17951)?(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$/.test(str)
}
const getVal =(source, path, defaultValue = undefined)=>{
const paths = path.replace(/\[(\d+)\]/g, '.$1').split('.')
let result = source
for (const p of paths) {
result = Object(result)[p]
if (result === undefined) {
return defaultValue
}
}
return result
}
// json数组根据key去重
const uniqueArray = (array, key) => {
var result = [array[0]]
for (var i = 1; i < array.length; i++) {
var item = array[i]
var repeat = false
for (var j = 0; j < result.length; j++) {
if (item[key] == result[j][key]) {
repeat = true
break
}
}
if (!repeat) {
result.push(item)
}
return result
}
}
// 获取链接参数
function urlParams() {
var str = location.search.length > 0 ? location.search.substring(1) : ''
var items = str.length ? str.split('&') : []
var args = {}
var item = null
var name = null
var value = null
for (let i = 0, len = items.length; i < len; i++) {
item = items[i].split('=')
name = decodeURIComponent(item[0])
value = decodeURIComponent(item[1])
if (name.length) {
args[name] = value
}
};
return args
}
function parseParams(url) {
url = decodeURIComponent(url)
var params = {}
var idx = url.indexOf('?')
if (idx > 0) {
var queryStr = url.substring(idx + 1)
if (queryStr.length > 0) {
var arr = queryStr.split('&')
for (let i = 0; i < arr.length; i++) {
var pair = arr[i].split('=')
if (pair.length == 2 && pair[0].length > 0) {
params[pair[0]] = pair[1]
}
}
}
}
return params
}
//本地存储
const ls = {
set(key, value) {
localStorage.setItem(key, JSON.stringify(value));
},
get(key) {
try {
const value = localStorage.getItem(key);
if (value === null || value === undefined || value === "") {
return null;
}
return JSON.parse(localStorage.getItem(key));
} catch (err) {
return null
}
},
remove(key) {
localStorage.removeItem(key);
},
clear() {
localStorage.clear()
}
}
const key = CryptoJS.enc.Utf8.parse("1234123412ABCDEF"); //十六位十六进制数作为密钥
const iv = CryptoJS.enc.Utf8.parse('ABCDEF1234123412'); //十六位十六进制数作为密钥偏移量
//解密方法
function Decrypt(word) {
let encryptedHexStr = CryptoJS.enc.Hex.parse(word);
let srcs = CryptoJS.enc.Base64.stringify(encryptedHexStr);
let decrypt = CryptoJS.AES.decrypt(srcs, key, { iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 });
let decryptedStr = decrypt.toString(CryptoJS.enc.Utf8);
return decryptedStr.toString();
}
//加密方法
function Encrypt(word) {
let srcs = CryptoJS.enc.Utf8.parse(word);
let encrypted = CryptoJS.AES.encrypt(srcs, key, { iv: iv, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7 });
return encrypted.ciphertext.toString().toUpperCase();
}
//cooike处理
const Cookie={
set(name,value,exdays){
var exdata=new Date()
exdata.setTime(exdata.getTime()+24*60*60*1000*exdays)
if(name=="password"){
document.cookie = name+'='+Encrypt(value)+';expires='+exdata.toGMTString();
}else{
document.cookie = name+'='+escape(value)+';expires='+exdata.toGMTString();
}
},
get(name){
if(document.cookie.length>0){
let passVal=""
let arr=document.cookie.split(";")
for(var i=0;i<arr.length;i++){
let arr2 = arr[i].split("=")
arr2[0]=arr2[0].replace(/\s/g,"")
if(arr2[0]==name){
if(name=='password'){
return Decrypt(arr2[1])
}else{
return unescape(arr2[1])
}
}
}
}
},
clear(name){
this.set(name,'',-1)
}
}
const errorMessage=(message)=>{
Message({
message:message,
type:'error',
offset:220,
duration:1000
})
}
export function checkPhone (val){
return (/^1[3456789]\d{9}$/).test(val)
}
export function checkEmail (val){
return (/^[_a-z0-9-\.]+@([-a-z0-9]+\.)+[a-z]{2,}$/i).test(val)
}
const isWeixin=()=>{
var ua = navigator.userAgent.toLowerCase();
if (ua.match(/MicroMessenger/i) == "micromessenger") {
return true;
} else {
return false;
}
}
const getComponents =(name,title)=>{
if(!title){
return () =>import(`@v/${name}/index.vue`)
}else{
return () =>import(`@v/${name}/${title}.vue`)
}
}
const getUrlParam=(name)=>{
var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)");
var r = window.location.search.substr(1).match(reg);
if (r != null) return unescape(r[2]);
return null;
}
const getStyle =(dom,attr)=>{
if (window.document.currentStyle) {
return dom.currentStyle[attr]
} else {
return getComputedStyle(dom, false)[attr]
}
}
export {
parseParams,
urlAfterParams,
urlParams,
uniqueArray,
isPhoneNum,
isEmail,
debounce,
db,
filterAssetIconData,
initThemeBgColor,
setThemeBgColor,
filterGettersData,
Decrypt,
Encrypt,
errorMessage,
Cookie,
getSupplierCode,
isWeixin,
getComponents,
getUrlParam,
regNum,
hideAddreddPup,
loginChecked,
setOriginDBdata,
getVal,
getStyle,
fixBar
}
-------------------------------------------------------------------------------------
记录一些常见的正则：
1 ：只能输入中英文和数字
规则：/^[A-Za-z0-9\u4e00-\u9fa5]+$/
2 对于多层嵌套数据结构，现在如何递归查找，直到找到id为某个具体指的对象？
实现一：
function digui(data, id) {
let value = null;
for (const item of data) {
if (item.id === id) {
value = item;
break;
}
if (item.children) {
const _value = digui(item.children, id);
if (_value) {
return _value;
}
}
}
return value;
}
console.log(digui(arr,999));
方法二：
let result = null
function handleDFS (arr, tid) {
let i = 0;
while (arr[i]) {
if (arr[i].id === tid) {
result = arr[i]
return
}
if (arr[i].children) handleDFS(arr[i].children, tid)
i++
}
return result
}
-------------------------------------------------------------------------------------
形如这样一个数组。要求改造该数组，形如以下arr2:
arr=["spaceImages": ["https://1.jpg","https://2.jpg"， "https://3.jpg","https://4.jpg" ],"spaceName": ["户型图", "客厅", "餐厅", "厨房", "卧室","卫生间" ],]
arr2=[
"spaceImages": ["https://1.jpg","https://2.jpg"， "https://3.jpg","https://4.jpg" ],"spaceName": ["户型图", "客厅", "餐厅", "厨房", "卧室","卫生间" ],
list:[
{name:"户型图"",,src:"https://1.jpg",},
{name:"客厅"",,src:"https://2.jpg",}
xxx...
]
注：这两个数组的数据一一对应的
解决方案：
let arr2=arr.map(({spaceImages,spaceName})=>({spaceImages,spaceName}))
let arr3=arr2.map(item=>{
return {...item,
arr:[
item.spaceName.map((k,i)=>{
return {
name:k,
src:item.spaceImages[i]
}
})
]
}
})
手机号码验证
export function valiatePhone(phone) {
let reg=/^[1][3,4,5,6,7,8,9][0-9]{9}$/
return reg.test(phone)?true:false
}
//只能输入中文
let reg = /^[\u4e00-\u9fa5]*$/g
//数字千分位实现
function comdify(n){
var re=/\d{1,3}(?=(\d{3})+$)/g;
var n1=n.replace(/^(\d+)((\.\d+)?)$/,function(s,s1,s2){return s1.replace(re,"$&,")+s2;});
return n1;
}
//实现xx分钟（xx天）前效果
export const parseTimeToChinese=(time)=>{
let timeStap=new Date(time).getTime()
// let timeStap=Date.parse(time)也可以通过Date的静态方法获取时间戳和上面的结果一样，注意获取的是毫秒数
let now=new Date().getTime()
let diff=now-timeStap;
let PrevMin=diff/1000; //（这里是毫秒数要转换成秒）
let res="";
//以下根据实际需求来
if(PrevMin<60){
res= "刚刚"
}else if(PrevMin>=60&&PrevMin<300){
res= "1分钟前"
}else if(PrevMin>=300&&PrevMin<900){
res= "5分钟前"
}else if(PrevMin>=900&&PrevMin<1800){
res= "15分钟前"
}else if(PrevMin>=1800&&PrevMin<3600){
res= "30分钟前"
}else if(PrevMin>=3600&&PrevMin<7200){
res= "1小时前"
}else if(PrevMin>=7200&&PrevMin<86400){
res= "2小时前"
}else {
res= time
}
return res
}
给定两个数组，arr和menu，在menu中过滤出在含有某个字段而且该字段必须被包含在arr中。如下：
let arr=["a","b","c","d","e"]
let menu=[
{
//一级数据无code，但是children有code，保留有code并且code为arr里的选项
name:"项目一",
children:[
{name:"项目一（1）",code:"a" },
{name:"项目一（2）",code:"b" },
{name:"项目一（3）",code:"kkk" },
]
},
{
name:"项目二",
children:[
{name:"项目一（1）",code:"yyy" },
{name:"项目一（2）",code:"d" },
{name:"项目一（3）",code:"" },
]
},
{
//一级数据有code，保留
name:"项目三",
code:"c"
},
{
name:"项目四",
code:"d"
},
//一级数据无code，剔除
{
name:"项目五",
},
]
注意：menu中的children可能无限极。请用递归实现：
解法：
let processUnit=(item)=>{
const {code}=item;
let result=null;
if(arr.includes(code)){
result=item
}
return result
}
let getMenu=(menu)=>{
let res=[];
menu.forEach(item=>{
const {children}=item;
if(Array.isArray(children)){
let data=getMenu(children);
res=[...res,...data]
}else{
let result=processUnit(item);
result&&(res.push(result))
}
})
return res
}
//给定两个数组。如下图，过滤含有code字段并且code必须为arr中存在的选项。如下图。必须得到如下结果：
{
//一级数据无code，但是children有code，保留有code并且code为arr里的选项
name:"项目一",
children:[
{name:"项目一（1）",code:"a" },
{name:"项目一（2）",code:"b" },
]
},
{
name:"项目二",
children:[
{name:"项目一（2）",code:"d" },
]
},
{
//一级数据有code，保留
name:"项目三",
code:"c"
},
{
name:"项目四",
code:"d"
},arr和menu，在menu中过滤出在含有某个字段而且该字段必须被包含在arr中。如下：
let arr=["a","b","c","d","e"]
let menu=[
{
//一级数据无code，但是children有code，保留有code并且code为arr里的选项
name:"项目一",
children:[
{name:"项目一（1）",code:"a" },
{name:"项目一（2）",code:"b" },
{name:"项目一（3）",code:"kkk" },
]
},
{
name:"项目二",
children:[
{name:"项目一（1）",code:"yyy" },
{name:"项目一（2）",code:"d" },
{name:"项目一（3）",code:"" },
]
},
{
//一级数据有code，保留
name:"项目三",
code:"c"
},
{
name:"项目四",
code:"d"
},
//一级数据无code，剔除
{
name:"项目五",
},
]
注意：menu中的children可能无限极。请用递归实现：解法：
let getMenu=(menu)=>{
let res=[];
menu.forEach(item=>{
const {children}=item;
if(Array.isArray(children)){
let temp={...item,children:item.children.filter(k=>arr.includes(k.code))}
res=[...res,temp]
}else{
let result=processUnit(item);
result&&(res.push(result))
}
})
return res
}
let processUnit=(item)=>{
const {code}=item;
let result=null;
if(arr.includes(code)){
result=item
}
return result
}18：实现一个函数。类似flat功能，如果有子项，则抽出来平铺。最后返回一个平铺的数组
let arr=[
{
catalogCode: "0"
catalogName: "首页"
refImgNum: 131
},
{
catalogCode: "001"
catalogName: "卧室",
childCatalogs:
[
catalogCode: "015"
catalogName: "主卧"
refImgNum: 0
]
},
{
catalogCode: "014"
catalogName: "餐厅"
refImgNum: 1
}
]
//最后的结果为
arr=[
{
catalogCode: "0"
catalogName: "首页"
refImgNum: 131
},
{
catalogCode: "001"
catalogName: "卧室",
},
{
catalogCode: "015"
catalogName: "主卧"
refImgNum: 0
},
{
catalogCode: "014"
catalogName: "餐厅"
refImgNum: 1
}
]解法：
const flatArr=(ary)=>{
let result = [];
for(let i = 0; i < ary.length; i++){
let item = ary[i];
result.push(item);
if (item.childCatalogs){
result.push(...flatArr(item.childCatalogs));
}
}
return result
}
export {flatArr}快速得到json数组中的id
常规作法：
let a=[]
let arr=[{id:1,name:"aaa"},{id:2,name:"bbb"}]
arr.forEach(item=>{
a.push(ite.id)
})快速作法：
let arr=[{id:1,name:"aaa"},{id:2,name:"bbb"}]
let res=arr.map(item=>item.id) //[1,2]//在tree中获取特定id的元素
const getItemById = (data, id) => {
for (let item of data) {
if (item.id === id) {
return item
}else{
if (item.childList) {
let _value = getItemById(item.childList, id);
if (_value) {
return _value;
}
}
}
}
return null;
};一维数组根据pid转化为树结构
const list = [
{id:"2b",pid:"",name:"人事部"},
{id:"2c",pid:"",name:"财务部"},
{id:"2d",pid:"2c",name:"财务核算部"},
{id:"2e",pid:"2c",name:"税务管理部"},
{id:"2f",pid:"2c",name:"薪资管理部"},
]
const parse=(data)=>{
let treeList=[]
let map={}
data.forEach(item => {
if(!item.children) item.children=[]
map[item.id]=item
});
data.forEach(item=>{
let parent=map[item.pid];
// 如果存在则表示item不是最顶层的数据
if(parent){
parent.children.push(item)
}else{
// 如果不存在 则是顶层数据
treeList.push(item)
}
})
return treeList
}
console.log(parse(list))
275
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
