vue项目中必备的export函数

1、验证篇

//校验手机号码或者固定电话
export function validTel(str) {
  const phone = /^1[3465789]\d{9}$/
  const tel = /^0\d{2,3}-?\d{7,8}$/
  return phone.test(str) || tel.test(str)
}

//校验a-z全是小写字母的字符串
export function validLowerCase(str) {
  const reg = /^[a-z]+$/
  return reg.test(str)
}

//校验A-Z全是大写字母的字符串
export function validUpperCase(str) {
  const reg = /^[A-Z]+$/
  return reg.test(str)
}

//校验A-Za-z字母构成的字符串
export function validAlphabets(str) {
  const reg = /^[A-Za-z]+$/
  return reg.test(str)
}

//校验全是数字
export function validNumber(str) {
  const reg = /^[0-9]*$/
  return reg.test(str)
}

//校验汉字0个以上
export function validChinese(str) {
  const reg = /^([\u4e00-\u9fa5]){0,}$/
  return reg.test(str)
}

//验证姓名
export function verifyFullName(val: string) {
	// false: 姓名不正确
	if (!/^[\u4e00-\u9fa5]{1,6}(·[\u4e00-\u9fa5]{1,6}){0,2}$/.test(val)) return false;
	// true: 姓名正确
	else return true;
}

//校验用户名6到21位
export function validUsername(str) {
  const reg = /^[a-zA-Z0-9]{6,21}$/
  return reg.test(str)
}

//校验身份证,可X或x结尾
export function validIdentity(str) {
  const reg = /^\d{6}(18|19|20)?\d{2}(0[1-9]|1[12])(0[1-9]|[12]\d|3[01])\d{3}(\d|X|x)$/
  return reg.test(str)
}

//校验邮箱
export function validEmail(email) {
  const reg = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
  return reg.test(email)
}

//校验是否是字符串
export function isString(str) {
  if (typeof str === 'string' || str instanceof String) {
    return true
  }
  return false
}

//校验是否为空或者null或者undefined
export function isCheck(value) {
  value = value.trim();
  if (value === null || value === '' || value === 'undefined') {
      return true;
  }
      return false;
  }

//验证密码 (以字母开头，长度在6~16之间，只能包含字母、数字和下划线)
export function verifyPassword(val: string) {
	// false: 密码不正确
	if (!/^[a-zA-Z]\w{5,15}$/.test(val)) return false;
	// true: 密码正确
	else return true;
}

//验证强密码 (字母+数字+特殊字符，长度在6-16之间)
export function verifyPasswordPowerful(val: string) {
	// false: 强密码不正确
	if (!/^(?![a-zA-z]+$)(?!\d+$)(?![!@#$%^&\.*]+$)(?![a-zA-z\d]+$)(?![a-zA-z!@#$%^&\.*]+$)(?![\d!@#$%^&\.*]+$)[a-zA-Z\d!@#$%^&\.*]{6,16}$/.test(val))
		return false;
	// true: 强密码正确
	else return true;
}

//密码强度
export function verifyPasswordStrength(val: string) {
	let v = '';
	// 弱：纯数字，纯字母，纯特殊字符
	if (/^(?:\d+|[a-zA-Z]+|[!@#$%^&\.*]+){6,16}$/.test(val)) v = '弱';
	// 中：字母+数字，字母+特殊字符，数字+特殊字符
	if (/^(?![a-zA-z]+$)(?!\d+$)(?![!@#$%^&\.*]+$)[a-zA-Z\d!@#$%^&\.*]{6,16}$/.test(val)) v = '中';
	// 强：字母+数字+特殊字符
	if (/^(?![a-zA-z]+$)(?!\d+$)(?![!@#$%^&\.*]+$)(?![a-zA-z\d]+$)(?![a-zA-z!@#$%^&\.*]+$)(?![\d!@#$%^&\.*]+$)[a-zA-Z\d!@#$%^&\.*]{6,16}$/.test(val))
		v = '强';
	// 返回结果
	return v;
}

//验证IP地址
export function verifyIPAddress(val: string) {
	// false: IP地址不正确
	if (
		!/^(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])$/.test(
			val
		)
	)
		return false;
	// true: IP地址正确
	else return true;
}

//验证邮政编码
export function verifyPostalCode(val: string) {
	// false: 邮政编码不正确
	if (!/^[1-9][0-9]{5}$/.test(val)) return false;
	// true: 邮政编码正确
	else return true;
}

//验证url
export function verifyUrl(val: string) {
	// false: url不正确
	if (
		!/^(?:(?:(?:https?|ftp):)?\/\/)(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)(?:\.(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)*(?:\.(?:[a-z\u00a1-\uffff]{2,})).?)(?::\d{2,5})?(?:[/?#]\S*)?$/i.test(
			val
		)
	)
		return false;
	// true: url正确
	else return true;
}

//验证车牌号
export function verifyCarNum(val: string) {
	// false: 车牌号不正确
	if (
		!/^(([京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领][A-Z](([0-9]{5}[DF])|([DF]([A-HJ-NP-Z0-9])[0-9]{4})))|([京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领][A-Z][A-HJ-NP-Z0-9]{4}[A-HJ-NP-Z0-9挂学警港澳使领]))$/.test(
			val
		)
	)
		return false;
	// true：车牌号正确
	else return true;
}

2、函数篇

// 从sessionStorage中取出一项数据 名字叫name
export const getItem = name => {
  return JSON.parse(sessionStorage.getItem(name))
}

// 向sessionStorage中设置一项数据 名字为name里面设置值为obj
export const setItem = (name, obj) => {
  sessionStorage.setItem(name, JSON.stringify(obj))
}

// 删除sessionStorage中数据
export const removeitem = name => {
  sessionStorage.removeItem(name)
}

//删除对象中value为空的数据
export function filterEmptyData(obj){
  for (let prop in obj) {
    obj[prop] === '' ? delete obj[prop] : obj[prop]
  }
  return obj;
}

// 防抖函数，在事件被触发n秒后再执行
export function _debounce(fn, delay) {
    var delay = delay || 200;
    var timer;
    var th = this;
    var args = arguments;
    if (timer) {
       clearTimeout(timer);
    }
    timer = setTimeout(function () {
        timer = null;
        fn.apply(th, args);
    }, delay);
}

// 节流，规定在一个单位时间内，只能触发一次函数。
export function _throttle(fn, interval) {
    var last;
    var timer;
    var interval = interval || 200;
    var th = this;
    var args = arguments;
    var now = +new Date();
    if (last && now - last < interval) {
            clearTimeout(timer);
            timer = setTimeout(function () {
                last = now;
                fn.apply(th, args);
            }, interval);
     } else {
            last = now;
            fn.apply(th, args);
     }
}

3、工具篇

//随机数
export function randomNumber(min, max) {
  return Math.floor(Math.random() * (max - min + 1) + min)
}

//将对象用&拼接成字符串{a:1,b:2}=>a=1&b=2
export function objToString(params) {
        let paramStr = '';
        Object.keys(params)
            .forEach((item) => {
                if (paramStr === '') {
                    paramStr = `${item}=${params[item]}`;
                } else {
                    paramStr = `${paramStr}&${item}=${params[item]}`;
                }
            });
        console.log(paramStr);
        return paramStr;
    }

//将用&拼接的字符串转为对象"qwe?a=1&b=2"=>{a: "1", b: "2"}
export function getParams(url) {
      var obj = {};
      if (url.indexOf('?') != -1) {
        var temp1 = url.split('?');
        var pram = temp1[1];
        var keyValue = pram.split('&');
        for (var i = 0; i < keyValue.length; i++) {
          var item = keyValue[i].split('=');
          var key = item[0];
          var value = item[1];
          obj[key] = value;
        }
      }
      return obj;
    }

/**
 * 判断两数组是否相同
 * @param news 新数据
 * @param old 源数据
 * @returns 两数组相同返回 `true`，反之则反
 */
export function judementSameArr(news: Array<string>, old: Array<string>): boolean {
	let count = 0;
	const leng = old.length;
	for (let i in old) {
		for (let j in news) {
			if (old[i] === news[j]) count++;
		}
	}
	return count === leng ? true : false;
}


/**
 * 判断两个对象是否相同
 * @param a 要比较的对象一
 * @param b 要比较的对象二
 * @returns 相同返回 true，反之则反
 */
export function isObjectValueEqual(a: { [key: string]: any }, b: { [key: string]: any }) {
	if (!a || !b) return false;
	let aProps = Object.getOwnPropertyNames(a);
	let bProps = Object.getOwnPropertyNames(b);
	if (aProps.length != bProps.length) return false;
	for (let i = 0; i < aProps.length; i++) {
		let propName = aProps[i];
		let propA = a[propName];
		let propB = b[propName];
		if (!b.hasOwnProperty(propName)) return false;
		if (propA instanceof Object) {
			if (!isObjectValueEqual(propA, propB)) return false;
		} else if (propA !== propB) {
			return false;
		}
	}
	return true;
}

//下载excel or mat文件
export function excelFile(data, filename){
var blob = new Blob([data], {
    type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=utf-8",
  });
  var url = window.URL.createObjectURL(blob);
  var aLink = document.createElement("a");
  aLink.style.display = "none";
  aLink.href = url;
  aLink.setAttribute("download", filename);
  document.body.appendChild(aLink);
  aLink.click();
  document.body.removeChild(aLink); //下载完成移除元素
  window.URL.revokeObjectURL(url); //释放掉blob对象
}

/**
 * 时间戳转换，包括年月日时分秒
 * @param {*} data  日期时间戳
 * @returns
 */
 export function formatDateAll(data,flag=true) {
  function add0(num) {
    return num < 10 ? "0" + num : num;
  } // 个位数的值在前面补0
  const date = new Date(data);
  const Y = date.getFullYear();
  const M = date.getMonth() + 1;
  const D = date.getDate();
  const h = date.getHours();
  const m = date.getMinutes();
  const s = date.getSeconds();
  const dateString =
    Y +
    "-" +
    add0(M) +
    "-" +
    add0(D) +
    "  " +
    add0(h) +
    ":" +
    add0(m) +
    ":" +
    add0(s);
   const yearString =
    Y +
    "-" +
    add0(M) +
    "-" +
    add0(D)
  flag?return dateString:return yearString 
};

// 判断数组中某个数是否只出现一次,一次没出现返回undefined
 export function isOnly(list, which) {
  if (list.indexOf(which) !== -1) {
    if (list.indexOf(which) === list.lastIndexOf(which)) {
      return true;
    } else {
      return false;
    }
  }else{
	return undefined
	}
};

//姓名改为*怡
 export function nameFormat (str) {
   let newStr = "";
      if (str && str.length) {
        for (let i = 0; i < str.length - 1; i++) {
          newStr += "*";
        }
        newStr += str.substr(str.length - 1, 1);
      }
      return newStr;
};

// 去所有空格
export function trim(str) {
  return str.replace(/\s*/g, "");
};

//Array结构转tree结构
/** 数组结构数据 */
/**
const arrayData = [
  { id: 2, title: '中国', parent_id: 0 },
  { id: 3, title: '广东省', parent_id: 2 },
  { id: 4, title: '广州市', parent_id: 3 },
  { id: 5, title: '天河区', parent_id: 4 },
  { id: 6, title: '湖南省', parent_id: 2 },
  { id: 1, title: '俄罗斯', parent_id: 0 }
]
console.log(arrayToTree(arrayData, 0));
*/

/**
 * 递归查找添加children
 * @param {数组数据} data 
 * @param {存放返回结果} result 
 * @param {父id} pid 
 */
function getChildren(data, result, pid) {
  for (const item of data) {
    if (item.parent_id === pid) {
      const newItem = { children: [], ...item }
      result.push(newItem)
      getChildren(data, newItem.children, item.id)
    }
  }
}

/**
 * 转化方法
 * @param {数组数据} data 
 * @param {父id} pid 
 * @returns 
 */
export function arrayToTree(data, pid) {
  let result = []
  getChildren(data, result, pid)
  return result
}

//tree结构转Array结构
export function treeToArray(data) {
  return data.reduce((pre, cur) => {
    const { children = [], ...item } = cur;  
    return pre.concat([{ ...item }], treeToArray(children)) 
  }, []);
}