常用的数据验证封装 返回promise可扩展

// 常用正则
const isPhone = /^1[3|4|5|6|7|8|9][0-9]\d{8}$/; // 手机号验证
const isEmial = /\w[-\w.+]*@([A-Za-z0-9][-A-Za-z0-9]+\.)+[A-Za-z]{2,14}/; // 邮箱
const isChinese = /^[\u4E00-\u9FA5\uf900-\ufa2d]$/; // 汉字
const isBanking = /^[1-9]\d{9,29}$/; // 银行卡号
const isCar = /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领][A-HJ-NP-Z][A-HJ-NP-Z0-9]{4,5}[A-HJ-NP-Z0-9挂学警港澳]$/; // 车牌号
const isIdentity = /(^\d{8}(0\d|10|11|12)([0-2]\d|30|31)\d{3}$)|(^\d{6}(18|19|20)\d{2}(0[1-9]|10|11|12)([0-2]\d|30|31)\d{3}(\d|X|x)$)/; // 身份证
const isPass = /^(?=.*[0-9])(?=.*[a-zA-Z])(.{8,20})$/; // 密码验证 包含数字和字母 长度8到20

// 错误消息的记录
var MESSAGE = null;

// 默认消息
const defaultMessage = {
	phone: '请输入正确的手机号',
	chinese: '请输入汉字',
	emial: '请输入正确的邮箱',
	banking: '请输入正确的银行卡',
	car: '请输入正确的车牌号',
	identity: '请输入正确的身份证号',
	password: '请输入合格的密码',
	min: '最小值为',
	max: '最大值为',
	required: '必填项不可为空',
	int: '必须为整数',
	float: '必须为小数',
};

// 验证方法
const checkFun = {
	// 是否为手机号
	phone(val) {
		return isPhone.test(val);
	},
	// 是否为汉字
	chinese(val) {
		return isChinese.test(val);
	},
	// 是否为邮箱
	emial(val) {
		return isEmial.test(val);
	},
	// 是否为银行卡
	banking(val) {
		return isBanking.test(val);
	},
	// 是否为车牌号
	car(val) {
		return isCar.test(val);
	},
	// 是否为身份证号
	identity(val) {
		return isIdentity.test(val);
	},
	// 是否为密码
	password(val) {
		return isPass.test(val);
	},
	// 是否为整数
	int(val) {
		if (!checkDataType.isNumber(val)) return false;
		return Number.isInteger(val);
	},
	// 是否为小数
	float(val) {
		if (!checkDataType.isNumber(val)) return false;
		return val % 1 !== 0;
		// return val + '.0' === val;
	},
	// 必填项验证
	required(val) {
		return !checkDataType.isEmpty(val);
	},
	// 最大值 rule.isContain 是否包含最大值
	max(val, rule) {
		if (!checkDataType.isNumber(val)) {
			throw Error('请传入number类型');
		}
		return rule.isContain ? (rule.value > val) : (rule.value >= val);
	},
	// 最小值 rule.isContain 是否包含最小值
	min(val, rule) {
		if (!checkDataType.isNumber(val)) {
			throw Error('请传入number类型');
		}
		return rule.isContain ? (rule.value < val) : (rule.value <= val);
	},
};

// 修改数据类型
const changeType = {
	number(val) {
		return Number(val);
	},
	string(val) {
		return val.toString();
	},
	boolean(val) {
		return Boolean(val);
	},
};

// 验证数据类型
const checkDataType = {
	// 验证是否为数字
	isNumber(val) {
		val = changeType.number(val); // 处理字符串数字
		return this.dataType(val) === '[object Number]';
	},
	// 验证是否为字符串
	isString(val) {
		return this.dataType(val) === '[object String]';
	},
	// 验证是否为Boolean
	isBoolean(val) {
		return this.dataType(val) === '[object Boolean]';
	},
	// 验证是否为Symbol
	isSymbol(val) {
		return this.dataType(val) === '[object Symbol]';
	},
	// 验证是否为数组
	isArray(val) {
		return this.dataType(val) === '[object Array]';
	},
	// 是否为正则
	isRegExp(val) {
		return this.dataType(val) === '[object RegExp]';
	},
	// 是否为对象
	isObject(val) {
		return this.dataType(val) === '[object Object]';
	},
	// 是否为空 目前验证 null undefined array string object
	isEmpty(val) {
		let flag = false;
		if (this.isArray(val)) {
			flag = val.length <= 0;
		}
		if (this.isString(val)) {
			flag = val.trim().length <= 0;
		}
		if (this.isObject(val)) {
			flag = JSON.stringify(val) === '{}';
		}
		if (val === null || val === undefined) flag = true;
		return flag;
	},
	// 验证数据类型
	dataType(val) {
		return Object.prototype.toString.call(val);
	},
};

// 获取默认消息
const getMessage = (rule, value) => {
	let message = rule.message;
	let isEmpty = checkDataType.isEmpty(rule.message);
	isEmpty && (message = defaultMessage[rule.type]);

	// 处理特殊的默认消息
	const arr = ['min', 'max'];
	if (arr.includes(rule.type)) {
		isEmpty && (message += value);
	}
	return message;
};

// 验证单项数据
const cheakData = (rule, value) => {
	let message = '';

	try {
		for (let i = 0; i < rule.length; i++) {
			if (checkFun[rule[i].type](value, rule)) continue;
			
			message = getMessage(rule[i], value);
			break;
		}
	}
	catch (error) {
		throw Error(error);
	}
	if (!MESSAGE) MESSAGE = message;
};
/**
 * @param {object} rulue 规则
 * @param {object} data 数据对象
 * @returns promise
 */
const validate = (rulue, data) => {
	MESSAGE = null;
	if (!checkDataType.isObject(rulue) || !checkDataType.isObject(data)) {
		throw Error('规则和数据的格式为对象');
	}

	let resolve;
	let reject;
	// eslint-disable-next-line promise/param-names
	const v = new Promise((res, rej) => {
		resolve = res;
		reject = rej;
	});

	try {
		for (const key in rulue) {
			if (Object.hasOwnProperty.call(rulue, key)) {
				if (MESSAGE) break;
				cheakData(rulue[key], data[key]);
			}
		}
		resolve({result: !changeType.boolean(MESSAGE), message: MESSAGE});
	}
	catch (error) {
		reject(error);
	}

	return v;
};

/** eg:
 * isContain 是否包含最大值或最小值
 * type: required phone min max car password identity emial chinese banking int float
 * rule = {
			a: [
				{type: 'required', message: '必填'},
				{type: 'phone', message: '请输入正确的手机号'},
				{type: 'min', value: 1000, isContain: false},
				{type: 'max', value: 1000, isContain: false},
			],
		};
	data = { a:100 }
	validate(rule,data).then(res=>{}).catch(err=>{})
 */

export {validate};