vue表单验证你真的会了吗？组件之表单验证（form）validate

前言

好久没有写文章了，学习了一下webpack，基础的一些组件，今天带来form表单验证组件（element.iviewui）的一期教程（做为一个菜鸡毕竟经历众多项目能够给一些新手一点提示 （QQ群技术讨论）838293023备注（github进来的

游泳健身了解一下：github 技术文档 技术文档会持续更新

---

内容总结

1. 原理解释
2. 派发和广播 // 父子级交互
3. 引入 async-validator // 表单验证插件
4. form/以及api设计
5. form-item
6. input

---

效果图

1.原理解释

考虑

咱们看一下咱们能够用form去总体触发校验也能够单个input来触发form-item 进行校验 童鞋们如今可能感受仍是没懂，不要紧继续往下看。

2.派发和广播

为何要用广播和派发呢。一般咱们和业务没有关系的组件尽可能不要使用vuex和bus(事件总线)。 下面我送上广播和派发的代码。咱们在须要调用组件绑上this.$on('event',res=>())，经过派发和广播进行调用$emit。

1. 派发是向上查找且只调用1个
2. 广播是向下查找调用多个
3. 注意⚠️全部的组件都要写上name
4. 经过混合器 mixins 来使用

emitter.js
/**
 * 递归使用 call 方式this指向
 * @param componentName // 须要找的组件的名称
 * @param eventName // 事件名称
 * @param params // 须要传递的参数
 */
function broadcast(componentName, eventName, params) {
    // 循环子节点找到名称同样的子节点 不然 递归 当前子节点
    this.$children.map(child=>{
        if (componentName===child.$options.name) {
            child.$emit.apply(child,[eventName].concat(params))
        }else {
            broadcast.apply(child,[componentName,eventName].concat(params))
        }
    })
}
export default {
    methods: {
        /**
         * 派发 (向上查找) (一个)
         * @param componentName // 须要找的组件的名称
         * @param eventName // 事件名称
         * @param params // 须要传递的参数
         */
        dispatch(componentName, eventName, params) {
            let parent = this.$parent || this.$root;//$parent 找到最近的父节点 $root 根节点
            let name = parent.$options.name; // 获取当前组件实例的name
            // 若是当前有节点 && 当前没名称 且 当前名称等于须要传进来的名称的时候就去查找当前的节点
            // 循环出当前名称的同样的组件实例
            while (parent && (!name||name!==componentName)) {
                parent = parent.$parent;
                if (parent) {
                    name = parent.$options.name;
                }
            }
            // 有节点表示当前找到了name同样的实例
            if (parent) {
                parent.$emit.apply(parent,[eventName].concat(params))
            }
        },
        /**
         * 广播 (向下查找) (广播多个)
         * @param componentName // 须要找的组件的名称
         * @param eventName // 事件名称
         * @param params // 须要传递的参数
         */
        broadcast(componentName, eventName, params) {
            broadcast.call(this,componentName, eventName, params)
        }
    }
}
复制代码

3.async-validator

不懂async-validator 能够去官网看看 github

yarn add async-validator // 由于当前这个插件是须要打包到项目里的因此不能加-D
复制代码

4.api设计

咱们看一下下面element官网的图`

1. form有2个注入的字段:rules规则，和:model当前form的值会经过model的值和rules进行匹配来进行校验.
2. form-item有2个注入的字段lable和prop(prop)是来和form进行匹配来获取当前的form-item的值的
3. input 其实有当前的@input的方法。v-model就不解释了

form

1. 咱们在form先开始注入当前全部的form-item实例（获取）
2. created 会在生命周期开始的时候绑定和删除当前实例的方法。一般绑定都在页面dom开始前调用须要在dom加载完
3. provide配合inject 使用让子组件能够调用当前父组件的方法以及data
4. 下面都写了备注能够放心食用（通过测试当前是能够进行校验的）

form.vue
<template>
    <form>
        <slot></slot>
    </form>
</template>

<script>
    export default {
        name: "aiForm",
        provide(){ //  [不懂的能够看看](https://cn.vuejs.org/v2/api/#provide-inject)
            return {
                form: this
            }
        },
        props: {
            // 当前 form 的model
            model: {
                type: Object
            },
            // 验证
            rules: {
                type: Object
            }
        },
        data(){
            return{
                fields: [] // 储存当前的 form-item的实例
            }
        },
        created(){
            // 存当前实例
            let that =this;
            this.$on('on-form-item-add',item=>{
                if (item) {
                    that.fields.push(item)
                }
            });
            // 删除当前有的实例
            this.$on('on-form-item-remove',item=>{
                if (item.prop) {// 若是当前没有prop的话表示当前不要进行删除（由于没有注入）
                    that.fields.splice(that.fields.indexOf(item),1)
                }
            })
        },
        methods:{
            /**
             * 清空
             */
            resetFields(){//添加resetFields方法使用的时候调用便可
                /**
                 * 当前全部当form-item 进行赋值
                 */
                this.fields.forEach(field => {
                    field.resetField();
                });
            },
            /**
             * 校验 公开方法：所有校验数据，支持 Promise
             */
            validate(callback){
                return new Promise(resolve=>{
                    /**
                     * 当前全部当form-item 进行校验
                     */
                    let valid = true; // 默认是经过
                    let count = 0; // 来匹配当前是不是所有检查完
                    this.fields.forEach(field => {
                        // 每一个实例都会有 validation 的校验的方法
                        field.validation('',error=>{
                            // 只要有一个不符合那么当前的校验就是未经过的
                            if (error) { 
                                valid = false;
                            }
                            // 经过当前检查完全部的form-item的时候才会调用
                            if (++count === this.fields.length) {
                                resolve(valid);// 方法使用then
                                if (typeof callback === 'function') {
                                    callback(valid);// 直接调用注入的回调方法
                                }
                            }
                        });
                    });
                })
            }
        }
    }
</script>

复制代码

5.form-item

1. form-item比较复杂咱们一个一个讲
2. isRequired来判断当前是否须要必填
3. validateState来判断当前校验的状态
4. validateMessage当前的错误的值
5. inject: ['form'] 咱们就能够经过this.from.xxx来调用父组件的事件以及值了
6. computed下的fieldValue可能在不停的变化因此咱们经过计算属性来使用
7. initialValue 默认的值咱们在mounted的时候且当前须要进行校验的时候（prop有的时候）会赋值
8. mixins: [Emitter]混合器就是里面的方法以及date均可以在当前调用使用频繁的均可以放在混合器里面
9. 咱们form-item 会传入input的两个方法blur和change(input原生使用的@input)经过form传入的校验rules里面的trigger来判断

form-item.vue
<template>
    <div>
        <label :class="isRequired?'ai-form-item-label-required':''">{{label}}</label>
        <div>
            <slot></slot>
            <div class="ai-form-item-message" v-if="validateState==='error'">{{validateMessage}}</div>
        </div>
    </div>
</template>

<script>
    import Emitter from '../../mixins/emitter';
    import schema from 'async-validator';
    export default {
        name: "aiFormItem",
        mixins: [Emitter],
        inject: ['form'],
        props: {
            label: {
                type: String,
                default: ''
            },
            prop:{
                type: String
            },
        },
        computed:{
            fieldValue () {
                return this.form.model[this.prop];
            },
        },
        data(){
            return {
                initialValue: '', // 储存默认值
                isRequired: false, // 当前的是否有问题
                validateState: '', // 是否校验成功
                validateMessage: '', // 校验失败文案
            }
        },
        methods:{
            /**
             * 绑定事件 进行是否 required 校验
             */
            setRules(){
                let that = this;
                let rules = this.getRules();//拿到父组件过滤后当前须要使用的规则
                if (rules.length) {
                    // every 方法用于检测数组全部元素是否都符合指定条件（经过函数提供）
                    // some 只要有一个符合就返回true
                    this.isRequired = rules.some(rule=>{
                        // 若是当前校验规则中有必填项，则标记出来
                        return rule.required;
                    })
                }
                /**
                 * blur 事件
                 */
                this.$on('on-form-blur',that.onFieldBlur);
                /**
                 * change 事件
                 */
                this.$on('on-form-change',that.onFieldChange)
            },
            /**
             * 从 Form 的 rules 属性中，获取当前 FormItem 的校验规则
             */
            getRules () {
                let that = this;
                let rules = that.form.rules;
                rules = rules?rules[that.prop]:[];
                return [].concat(rules||[])//这种写法可让规则确定是一个数组的形式
            },
            /**
             * Blur 进行表单验证
             */
            onFieldBlur(){
                this.validation('blur')
            },
            /**
             * change 进行表单验证
             */
            onFieldChange(){
                this.validation('change')
            },
            /**
             * 只支持 blur 和 change，因此过滤出符合要求的 rule 规则
             */
            getFilteredRule (trigger) {
                let rules = this.getRules();
                // !res.trigger 没有调用方式的时候默认就校验的
                // filter 过滤出当前须要的规则
                return rules.filter(res=>!res.trigger || res.trigger.indexOf(trigger)!==-1)
            },
            /**
             * 校验数据
             * @param trigger 校验类型
             * @param callback 回调函数
             */
            validation(trigger,callback=function () {}){
                // blur 和 change 是否有当前方式的规则
                let rules = this.getFilteredRule(trigger);
                // 判断当前是否有规则
                if (!rules || rules.length === 0) {
                    return
                }
                // 设置状态为校验中
                // async-validator的使用形式
                this.validateState = 'validating';
                var validator = new schema({[this.prop]: rules});
                // firstFields: true 只会校验一个
                validator.validate({[this.prop]: this.fieldValue}, { firstFields: true },(errors, fields) => {
                    this.validateState = !errors ? 'success' : 'error';
                    this.validateMessage = errors ? errors[0].message : '';
                    callback(this.validateMessage);
                });
            },
            /**
             * 清空当前的 form-item
             */
            resetField(){
                this.form.model[this.prop] = this.initialValue;
            }
        },
        // 组件渲染时，将实例缓存在 Form 中
        mounted(){
            // 若是没有传入 prop，则无需校验，也就无需缓存
            if (this.prop) {
                this.dispatch('aiForm','on-form-item-add', this);
                // 设置初始值，以便在重置时恢复默认值
                this.initialValue = this.fieldValue;
                // 添加表单校验
                this.setRules()
            }
        },
        // 组件销毁前，将实例从 Form 的缓存中移除
        beforeDestroy(){
            this.dispatch('iForm', 'on-form-item-remove', this);
        },
    }
</script>

<style scoped>
    <!--当前css-->
    .ai-form-item-label-required:before{
        content: '*';
        color: red;
    }
    .ai-form-item-message {
        color: red;
    }
</style>
复制代码

5.input

1. value 支持一个入参
2. 由于当前是一个input注入的参数是不能直接放到input里面使用的因此先赋值给了defaultValue而后用watch来不停给defaultValue赋值达到一个父组件修改后的一个绑定

<template>
   <input type="text"
          @input="handleInput" // change
          @blur="handleBlur"
          :value="defaultValue"
   >
</template>

<script>
   import Emitter from '../../mixins/emitter.js'
   export default {
       name: "aiInput",
       mixins: [Emitter],
       props: {
           value: {
               type: String,
               default: ''
           }
       },
       data(){
           return {
               defaultValue: this.value
           }  
       },
       watch:{
           value (val) {
               this.defaultValue = val;
           }
       },
       methods:{
           /**
            * change 事件
            * @param event
            */
           handleInput(event){
               // 当前model 赋值
               this.defaultValue = event.target.value;
               // vue 原生的方法 return 出去
               this.$emit('input',event.target.value);
               // 将当前的值发送到 aiFormItem 进行校验
               this.dispatch('aiFormItem','on-form-change',event.target.value)
           },
           /**
            * blur 事件
            * @param event
            */
           handleBlur(event){
               // vue 原生的方法 return 出去
               this.$emit('blur',event.target.value);
               // 将当前的值发送到 aiFormItem 进行校验
               this.dispatch('aiFormItem','on-form-blur',event.target.value)
           }
       }
   }
</script>

复制代码

最后

最后给上一个当前能够的使用方式

<template>
 <div class="home">
   <button @click="changeButton">测试</button>
   <ai-form ref="formItems" :model="formValidate" :rules="ruleValidate">
     <ai-form-item label="用户名" prop="name">
       <ai-input  v-model="formValidate.name"/>
     </ai-form-item>
   </ai-form>
 </div>
</template>

<script>
 import AiForm from "../components/form/form";
 import AiFormItem from "../components/form/form-item";
 import AiInput from "../components/input/ai-input";
export default {
   name: 'home',
   components: {AiInput, AiFormItem, AiForm},],
   data(){
       return{
           formValidate: {
               name: '123z',
               mail: ''
           },
           ruleValidate: {
               name: [
                   { required: true, message: '用户名不能为空', trigger: 'blur' },
               ],
           }
       }
   },
   methods:{
       changeButton(){
           this.$refs.formItems.resetFields() // 清空方法
           this.$refs.formItems.validate() // 验证方法
               .then(res=>{
                   console.log(res)
               })
       }
   },
}
</script>

复制代码

小结

可能如今小伙伴仍是不懂。。俗话说;师傅领进门,修行在我的。代码上的备注写的也够多了。仍是不懂的能够加群问问小伙伴们，

求靠谱内推（北京地区）能够留言我 +。=