├── readme.md
└── common
    └── validate.js


/readme.md:
--------------------------------------------------------------------------------
 1 | ## 表单验证/数据验证/强大灵活验证
 2 | 
 3 | ### 家族成员
 4 | 
 5 | [【actionSheet弹窗/底部菜单/底部弹出/底部弹出层】](https://ext.dcloud.net.cn/plugin?id=2304)
 6 | <br>
 7 | [【全局modal弹窗/可覆盖原生/弹出层/alert】](https://ext.dcloud.net.cn/plugin?id=2280)
 8 | <br>
 9 | 欢迎下载匹配使用，统一度更强
10 | 
11 | ### 插件亮点
12 | 
13 | 1、支持批量方法检查<br>
14 | 2、支持单一方法检查<br>
15 | 3、支持每个字段自由设置检查规则<br>
16 | 4、可单独某个字段下某个规则自定义错误信息<br>
17 | 
18 | ### 在你的项目中使用
19 | 
20 | 1、将common复制到你的common下<br>
21 | 2、在需要使用的页面<script>中加入：
22 | ```
23 | var validate = require("../../common/validate.js");
24 | ```
25 | 3、开始验证：
26 | ```
27 | formSubmit(e) {
28 | 	let formData = e.detail.value;
29 | 	var rule = [
30 | 		{
31 | 			// 字段名
32 | 			name: 'formName',
33 | 			
34 | 			// 用于出现错误信息替换英文字段名（不设置此参数则使用英文name）
35 | 			nameChn: '字段的中文名',
36 | 			
37 | 			/*
38 | 			验证规则（详细规则请在下方【验证规则说明】中查看）
39 | 			格式：['require', 'min:3', ['min', 3]]
40 | 			别名格式： ['>', 10] 等同于 ['gt', 10]
41 | 			*/
42 | 			rules: ['require', ['min', 3]],
43 | 			
44 | 			/*
45 | 			自定义错误信息（如不设置此参数则使用默认信息）
46 | 			格式：{
47 | 				验证规则的名称(支持别名): '自定错误信息的文本',
48 | 				…… …… ……
49 | 			}
50 | 			*/
51 | 			errorMsg: {
52 | 				require: '必填项不能为空', 
53 | 				min: '公司名称格式：xxxxxxx有限公司'
54 | 			},
55 | 			*/
56 | 		},
57 | 		
58 | 		…… …… ……
59 | 	];
60 | 	
61 | 	// 是否全部通过，返回Boolean
62 | 	validate.check(formData, rule);
63 | 	// 获取错误信息
64 | 	validate.getError();
65 | 	
66 | 	// 除了以上批量用法，还支持单一用法
67 | 	validate.checkResult('require', formData.formName);
68 | }
69 | ```
70 | 
71 | ### 验证规则说明
72 | 
73 | 规则名称  |  用法  |  描述  
74 | -|-|-|
75 | require | ['require'] | 必填项<br>（如不设置此项，则数据不为空时才进行其他规则验证）
76 | number | ['number'] | 是否为数值
77 | chn | ['chn'] | 是否为汉字
78 | chnNum | ['chnNum'] | 是否为汉字和数值
79 | chnOrNum | ['chnOrNum'] | 是否为汉字或数值
80 | alphaLine | ['alphaLine'] | 只能包含英文和下划线，首尾不能是下划线、且不能只是下划线
81 | mobile | ['mobile'] | 手机号码格式验证
82 | alphaNum | ['alphaNum'] | 只能是字母的数字
83 | email | ['email'] | 电子邮箱格式验证
84 | zipCode | ['zipCode'] | 邮政编码格式验证
85 | min | ['min:5' 或 ['min', 5]] | 长度不能小于某值
86 | max | ['max:5' 或 ['max', 5]] | 长度不能大于某值
87 | length | ['length:1,10' 或 ['length', '1,10']] | 在某长度范围内
88 | notbetween | ['notbetween:1,10' 或 ['length', '1,10']] | 不再某长度范围内
89 | in | ['in:1,2,3,5,6,8' 或 ['in', '1,2,3,6,5,89,9']] | 在指定的字符内
90 | notIn | ['notIn:1,2,3,5,6,8' 或 ['notIn', '1,2,3,6,5,89,9']] | 不在指定的字符内
91 | different | ['different:formName' 或 ['different', 'formName']] | 对比两个字段的值是否相同
92 | gt (>) | ['gt:100' 或 ['gt', 100]] | 必须大于某个数值
93 | egt (>=) | ['egt:100' 或 ['egt', 100]] | 必须大于等于某个数值
94 | elt (<=) | ['elt:100' 或 ['elt', 100]] | 必须小于或等于某个数值
95 | lt (<) | ['lt:100' 或 ['lt', 100]] | 必须小于某个数值
96 | eq (= 或 same) | ['eq:100' 或 ['eq', 100]] | 必须等于某个数值
97 | notEq (<> 或 !=) | ['notEq:100' 或 ['notEq', 100]] | 不等于某个数值
98 | regex | ['regex', /(^[1-9]\d*$)/] | 支持使用正则验证


--------------------------------------------------------------------------------
/common/validate.js:
--------------------------------------------------------------------------------
  1 | module.exports = {
  2 | 	/**
  3 | 	 * 数据集合
  4 | 	 */
  5 | 	data: [],
  6 | 	/**
  7 | 	 * 错误信息
  8 | 	 */
  9 | 	error: [],
 10 | 	/**
 11 | 	 * 默认错误信息
 12 | 	 */
 13 | 	defaultErrorMsg: {
 14 | 		regex: ':attribute不符合验证规则',
 15 | 		require: ':attribute为必填项',
 16 | 		number: ':attribute只能为数字整数',
 17 | 		chn: ':attribute只能为中文汉字',
 18 | 		chnNum: ':attribute只能为中文汉字和数字',
 19 | 		chnOrNum: ':attribute只能为中文汉字或者数字',
 20 | 		alphaLine: ':attribute只能包含英文和下划线，首尾不能是下划线、且不能只是下划线',
 21 | 		landline: ':attribute格式不正确',
 22 | 		mobile: ':attribute格式不正确',
 23 | 		alphaNum: ':attribute只能是字母和数字',
 24 | 		email: ':attribute格式不正确',
 25 | 		zipCode: ':attribute格式不正确',
 26 | 		min: ':attribute长度不能小于:rule位',
 27 | 		max: ':attribute长度不能大于:rule位',
 28 | 		length: ':attribute长度只能在:rule之间',
 29 | 		notbetween: ':attribute 不在 :1 - :2 范围之间',
 30 | 		in: ':attribute只能在:rule范围内',
 31 | 		notIn: ':attribute不能能在:rule范围内',
 32 | 		different: ':attribute不能与:rule相同',
 33 | 		gt: ':attribute必须大于:rule',
 34 | 		egt: ':attribute必须大于或等于:rule',
 35 | 		elt: ':attribute必须小于或等于:rule',
 36 | 		lt: ':attribute必须小于:rule',
 37 | 		eq: ':attribute必须等于:rule',
 38 | 		notEq: ':attribute不能与:rule相同'
 39 | 	},
 40 | 	/**
 41 | 	 * 验证类型别名
 42 | 	 */
 43 | 	alias: {
 44 | 		'>': 'gt',
 45 | 		'>=': 'egt',
 46 | 		'<': 'lt',
 47 | 		'<=': 'elt',
 48 | 		'=': 'eq', 'same': 'eq',
 49 | 		'!=': 'notEq', '<>': 'notEq'
 50 | 	},
 51 | 	/**
 52 | 	 * 查找别名
 53 | 	 */
 54 | 	getAlias(value, compare = (a, b) => a === b) {
 55 | 		var result = Object.keys(this.alias).find(k => compare(this.alias[k], value))
 56 | 		if (typeof result == 'undefined') {
 57 | 			var result = this.alias[value];
 58 | 		}
 59 | 		return result;
 60 | 	},
 61 | 	
 62 | 	/**
 63 | 	 * 开始验证
 64 | 	 * @param {Object} data
 65 | 	 * @param {Object} param
 66 | 	 */
 67 | 	check(data, param) {
 68 | 		// 避免再次验证后出现重复错误信息
 69 | 		this.error = [];
 70 | 		this.data = data;
 71 | 		
 72 | 		for (var i = 0; i < param.length; i++) {
 73 | 			// 字段name
 74 | 			var name = param[i].name;
 75 | 			// 字段中文名称
 76 | 			var nameChn = param[i].nameChn;
 77 | 			// 字段数据
 78 | 			var value = data[name];
 79 | 			// 规则列表
 80 | 			var rules = param[i].rules;
 81 | 			// 自定义错误信息
 82 | 			var errorMsg = param[i].errorMsg;
 83 | 
 84 | 			for (let index in rules) {
 85 | 				if (rules.indexOf('require') < 0) {
 86 | 					// 必填项
 87 | 					if (!this.checkResult('require', value)) {
 88 | 						continue;
 89 | 					}
 90 | 				}
 91 | 				
 92 | 				if (!this.checkResult(rules[index], value)) {
 93 | 					// 验证未通过返回错误信息
 94 | 					this.buildError(name, nameChn, rules[index], errorMsg);
 95 | 				}
 96 | 			}
 97 | 		}
 98 | 		
 99 | 		// 验证结果
100 | 		return JSON.stringify(this.error) == '[]' ? true : false;
101 | 	},
102 | 	
103 | 	/**
104 | 	 * 构建错误信息
105 | 	 */
106 | 	buildError(name, nameChn = '', rule, errorMsg = '') {
107 | 		// 获取rule中 名称、范围
108 | 		if (typeof rule == 'object') {
109 | 			// 数组格式
110 | 			var ruleName = rule[0];
111 | 			if (rule[1]) {
112 | 				var ruleValue = rule[1];
113 | 			} else {
114 | 				var ruleValue = '';
115 | 			}
116 | 		} else {
117 | 			// 字符串格式
118 | 			if (rule.indexOf(':') > -1) {
119 | 				var ruleArray = rule.split(':');
120 | 				var ruleName = ruleArray[0];
121 | 				var ruleValue = ruleArray[1];
122 | 			} else {
123 | 				var ruleName = rule;
124 | 				var ruleValue = '';
125 | 			}
126 | 		}
127 | 		
128 | 		if (errorMsg !== '') {
129 | 			// 使用自定义错误信息
130 | 			if (!errorMsg[ruleName]) {
131 | 				// 规则中有不存在的自定义信息
132 | 				if (typeof this.getAlias(ruleName) != 'undefined') {
133 | 					// 别名
134 | 					this.error.push(errorMsg[this.getAlias(ruleName)]);
135 | 					return;
136 | 				}
137 | 			} else {
138 | 				// 所有规则自定义信息都存在
139 | 				this.error.push(errorMsg[ruleName]);
140 | 				return;
141 | 			}
142 | 		}
143 | 		
144 | 		// 组合替换需要的数组格式
145 | 		if (String(ruleValue).indexOf(',') > -1) {
146 | 			// 范围内的数组格式
147 | 			var ruleValueArray = ruleValue.split(',');
148 | 			ruleValueArray.push('');
149 | 		} else {
150 | 			var ruleValueArray = ['', '', ''];
151 | 		}
152 | 		
153 | 		// 替换开始
154 | 		var defaultErrorMsg = this.defaultErrorMsg[ruleName];
155 | 		defaultErrorMsg = defaultErrorMsg.replace(/(:attribute|:rule|:1|:2)/g, ($0, $1) => {
156 | 			return {
157 | 				// 可自定义字段中文名称
158 | 				':attribute': nameChn != '' ? nameChn : name,
159 | 				':rule': ruleValue,
160 | 				':1': ruleValueArray[0],
161 | 				':2': ruleValueArray[1],
162 | 			}[$1];
163 | 		});
164 | 		
165 | 		// 替换完成
166 | 		// this.error[name] = [defaultErrorMsg];
167 | 		this.error.push(defaultErrorMsg);
168 | 	},
169 | 	
170 | 	getError() {
171 | 		return this.error;
172 | 	},
173 | 	
174 | 	/**
175 | 	 * 验证结果
176 | 	 * @param {Object} rule
177 | 	 * @param {Object} value
178 | 	 */
179 | 	checkResult(rule, value) {
180 | 		switch (rule) {
181 | 			case 'require':
182 | 				// 必须项
183 | 				return !(!value || String(value).length < 1);
184 | 				break;
185 | 			case 'number':
186 | 				// 数值
187 | 				return this.regex(/^-?[1-9][0-9]?.?[0-9]*$/, String(value));
188 | 				break;
189 | 			case 'integer':
190 | 				// 整数
191 | 				return this.regex(/(^[1-9]\d*$)/, String(value));
192 | 				break;
193 | 			case 'float':
194 | 				// 浮点数
195 | 				return this.regex(/^(-?\\d+)(\\.\\d+)?$/, String(value));
196 | 				break;
197 | 			case 'chn':
198 | 				// 中文
199 | 				return this.regex(/^[\u4e00-\u9fa5]+$/u, decodeURI(value));
200 | 				break;
201 | 			case 'chnNum':
202 | 				// 同时包含数字和汉字
203 | 				return this.regex(/^[0-9\u4e00-\u9fa5]+$/u, decodeURI(value));
204 | 				break;
205 | 			case 'chnOrNum':
206 | 				// 包含汉字或者数字
207 | 				return this.regex(/^[\u4e00}-\u9fa5]+|[0-9]+$/u, decodeURI(value));
208 | 				break;
209 | 			case 'alphaLine':
210 | 				// 英文和下划线，首尾不能是下划线、且不能只是下划线
211 | 				return (value.slice(0, 1) != '_' && value.slice(-1) != '_' && this.regex(/^[A-Za-z\_]+$/, value));
212 | 				break;
213 | 			case 'landline':
214 | 				// 固定电话号
215 | 				return this.regex(/^(\+\d{2}-)?0\d{2,3}-\d{7,8}|(\+\d{2}-)?\(0\d{2,3}\)\d{7,8}$/, decodeURI(value));
216 | 				break;
217 | 			case 'mobile':
218 | 				// 手机号
219 | 				return this.regex(/^1[345789]\d{9}$/, parseInt(decodeURI(value)));
220 | 				break;
221 | 			case 'alphaNum':
222 | 				// 字母和数字
223 | 				return this.regex(/^[a-zA-Z]+|[0-9]+$/, value);
224 | 				break;
225 | 			case 'email':
226 | 				// 电子邮箱
227 | 				return this.regex(/^\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/, value);
228 | 				break;
229 | 			case 'zipCode':
230 | 				// 邮政编码
231 | 				return this.regex(/^[0-9]{6}$/, value);
232 | 				break;
233 | 			default:
234 | 				// 带范围验证
235 | 				if (typeof rule == 'string' && rule.indexOf(':') > -1) {
236 | 					// 字符串格式
237 | 					var ruleArr = rule.split(':');
238 | 				}
239 | 				if (typeof rule == 'object') {
240 | 					// 数组格式
241 | 					var ruleArr = rule;
242 | 				}
243 | 				if (typeof this[ruleArr[0]] != 'function') {
244 | 					// 别名转换
245 | 					ruleArr[0] = this.getAlias(ruleArr[0]);
246 | 				}
247 | 				return this[ruleArr[0]](ruleArr[1], value);
248 | 		}
249 | 	},
250 | 	
251 | 	/**
252 | 	 * 正则
253 | 	 * @param {Object} rule
254 | 	 * @param {Object} value
255 | 	 */
256 | 	regex(rule, value) {
257 | 		var pattern = new RegExp(rule);
258 | 		return pattern.test(value);
259 | 	},
260 | 	
261 | 	/**
262 | 	 * 长度不能小于
263 | 	 * @param {Object} rule
264 | 	 * @param {Object} value
265 | 	 */
266 | 	min(rule, value) {
267 | 		return String(value).length >= rule;
268 | 	},
269 | 	
270 | 	/**
271 | 	 * 长度不能大于
272 | 	 * @param {Object} rule
273 | 	 * @param {Object} value
274 | 	 */
275 | 	max(rule, value) {
276 | 		return String(value).length <= rule;
277 | 	},
278 | 	
279 | 	/**
280 | 	 * 长度范围内
281 | 	 * @param {Object} rule
282 | 	 * @param {Object} value
283 | 	 */
284 | 	length(rule, value) {
285 | 		var length = String(value).length;
286 | 		if (String(rule).indexOf(',') > -1) {
287 | 			// 区间
288 | 			[min, max] = rule.split(',');
289 | 			return length >= min && length <= max;
290 | 		} else {
291 | 			// 固定
292 | 			return length == rule;
293 | 		}
294 | 	},
295 | 	
296 | 	/**
297 | 	 * 不在范围之间
298 | 	 * @param {Object} rule
299 | 	 * @param {Object} value
300 | 	 */
301 | 	notbetween(rule, value) {
302 | 		if (String(rule).indexOf(',') > -1) {
303 | 			[min, max] = rule.split(',');
304 | 			return value < min || value > max;
305 | 		}
306 | 		return false;
307 | 	},
308 | 	
309 | 	/**
310 | 	 * 数据范围内
311 | 	 * @param {Object} rule a,b,c多个包含
312 | 	 * @param {Object} value
313 | 	 */
314 | 	in(rule, value) {
315 | 		return rule.split(',').includes(value);
316 | 	},
317 | 	
318 | 	/**
319 | 	 * 数组不在范围内
320 | 	 * @param {Object} rule
321 | 	 * @param {Object} value
322 | 	 */
323 | 	notIn(rule, value) {
324 | 		return !rule.split(',').includes(value);
325 | 	},
326 | 	
327 | 	/**
328 | 	 * 字段相同
329 | 	 * @param {Object} rule
330 | 	 * @param {Object} value
331 | 	 */
332 | 	identical(rule, value) {
333 | 		return this.data[rule] === value;
334 | 	},
335 | 	
336 | 	/**
337 | 	 * 字段不相同
338 | 	 * @param {Object} rule
339 | 	 * @param {Object} value
340 | 	 */
341 | 	different(rule, value) {
342 | 		return this.data[rule] != value;
343 | 	},
344 | 	
345 | 	/**
346 | 	 * 大于某值
347 | 	 * @param {Object} rule
348 | 	 * @param {Object} value
349 | 	 */
350 | 	gt(rule, value) {
351 | 		return Number(value) > rule;
352 | 	},
353 | 	
354 | 	/**
355 | 	 * 大于或等于某值
356 | 	 * @param {Object} rule
357 | 	 * @param {Object} value
358 | 	 */
359 | 	egt(rule, value) {
360 | 		return Number(value) >= rule;
361 | 	},
362 | 	
363 | 	/**
364 | 	 * 小于或等于某值
365 | 	 * @param {Object} rule
366 | 	 * @param {Object} value
367 | 	 */
368 | 	elt(rule, value) {
369 | 		return Number(value) <= rule;
370 | 	},
371 | 	
372 | 	/**
373 | 	 * 小于某值
374 | 	 * @param {Object} rule
375 | 	 * @param {Object} value
376 | 	 */
377 | 	lt(rule, value) {
378 | 		return Number(value) < rule;
379 | 	},
380 | 	
381 | 	/**
382 | 	 * 等于某值
383 | 	 * @param {Object} rule
384 | 	 * @param {Object} value
385 | 	 */
386 | 	eq(rule, value) {
387 | 		return Number(value) == rule;
388 | 	},
389 | 	
390 | 	/**
391 | 	 * 不等于某值
392 | 	 * @param {Object} rule
393 | 	 * @param {Object} value
394 | 	 */
395 | 	notEq(rule, value) {
396 | 		return Number(value) != rule;
397 | 	}
398 | };
399 | 


--------------------------------------------------------------------------------