zoukankan      html  css  js  c++  java
  • vue组件知识总结

    vue组件化开发

    • 将一个页面分割成若干个组件,一个页面js+css+html,将自己类容分割出来,方便开发,更好了维护我们的代码,每个组件封装自己的js+html+css,样式命名冲突

    组件分类

    • 页面级组件( 例如详情页页面)

    • 基础组件(页面的一部分,例如轮播图)

    • 组件的目的为了实现复用

    指令和组件

    • 在标签内增加的行内属性,实现功能指令

    • 组件就是一个自定义(扩展)的标签<hello></hello>,封装代码的,组件的标签名不能破坏原有的html标签

    组件:全局组件(不需要引用),局部组件(需要引用)

    • 在vue中一个对象就是一个组件

    • 在组件中data是一个函数,目的是不受别人干扰,因为组件是独立的

    • 使用组件的步骤,

      • 1.声明组件,并且引入到当前页面

      • 2.在组件的父级模板中调用这个组件

      • 组件名称不能和标签相同

    • 全局组件

    •  Vue.component('my-handsone',{
             //template只会有一个根元素,而且不能直接放置文本节点
              template:'<h1>{{msg}}</a></h1>', 
              data(){  
                  return { //可以用来定义数据
                      msg:"帅吗",
                      types:[1,2,3]
                  }
              }
          });
          let vm=new Vue({
              el:"#app",
              data:{}
          })
    • 局部组件
    • //一个对象就是一个组件
       let webeautiful={
              template:'<h1>{{msg}}</h1>',
              data(){
                  return {
                      msg:"很帅呀"
                  }
              }
          };
          let vm=new Vue({
              el:"#app",
              //挂载在vue实例中components
              components:{
                  webeautiful
              }
          })

      组件的数据传递

      • 父传子属性传递 子组件通过props接收

      • props的api

        • type 接收数据的类型

        • default 默认数据的值

        • required 必须传递数据 不能和default同时引用

        • validator 自定义验证

      • 子传父组件,事件触发 $emit->@方法="父组件的方法"

      • 平级交互 eventBus 但是不用 -vuex

      • 父组件调用子类的方法 ref=>this.$ref.xxx.子类方法

      • slot 插槽 (设置一些空闲的位置等等使用)

      父亲传递给儿子数据

      • 先在儿子组件上绑定一个属性名,然后赋值给这个属性 :m="msg",

      • 儿子接受父亲传递的数据,用props接收传递的属性名字,例如 props:{m:{type:Array}}

      • // 父亲到儿子,默认组件是独立的,相互不能引用数据,可以通过属性方式传递给儿子
             let vm=new Vue({
                 el:"#app",
                 //根实例上的data都是对象,组件中的都是函数
                 data:{
                     money:100
                 },
                 //父级传递给子集数据通过绑定属性,如果传递多个可以数组中写多个
                 template:'<div><child :m="money" o="美女"></child></div>',
                 components:{
                     child:{
                         //子集接收给父级给的数据,通过props属性接收
                         props:['m','o'],
                         computed:{
                             b(){
                                 //这里的this指向子集child
                                 //父亲的数据儿子不能更改 错误写法 this.o="丑呀"
                                 return "大大"+this.o;
                             }
                         },
                         template:"<div>儿子 {{m}} {{b}}</div>"
                     }
             }
             })

        父亲接收儿子传递的参数

        • 儿子通过自定义事件方法中给父亲发射自己的数据

        • 先在儿子组件实例中created中发射一个数据

          • 例如 created(){//传递自己的数据

          this.$emit('childs',this.msg);

          }

        • 在儿子组件上要绑定这个自定义事件方法,然后里面赋值父亲接收的函数

          • 例如儿子组件 <child @childs="父亲接收的函数"></child>

        • 最后父亲接收的函数很简单,参数就是儿子传递的数据

          • 例如父亲接收的函数 fn(data){//这里面的data就是儿子发射给父亲的参数}

          • //实例化一个Vue函数
                let vm=new Vue({
                    //child 是儿子 触发了自己的一个方法,绑定了父亲的一个函数方法
                    template:'<div><child @childs="say"></child></div>',
                    //方法挂载
                    methods:{
                        //父亲的一个方法
                        say(data){
                           console.log(data);
                        }
                    },
                    //定义一个儿子组件
                    components:{
                        //儿子名字
                        child:{
                            //事件和数据初始化之后
                            created(){
                                //儿子发射一个方法 传递自己的数据
                                this.$emit('childs',this.msg);
                            },
                            template:'<div>子</div>',
                            data(){
                                return {
                                    msg:"我饿了"
                                }
                            },
            
                        }
                    },
                }).$mount("#app"); //手动将vue挂载在#app标签上

        父亲和儿子实现双向数据绑定

        父亲传递给儿子数据,儿子触发一个父亲方法,将最新的值传递给父亲,父亲更改后,属性会重新传递儿子,儿子会刷新

        • 父亲先在儿子组件上通过绑定一个属性,然后给这个属性赋值,给儿子传递数据

          • 例如<child :m="msg"></child>

        • 儿子接收父亲的传递的数据props

          • props:{m:{type=Array}}

        • 儿子拿到数据后,要修改数据,(儿子无法把父亲传递的参数重新赋值)

        • 然后儿子重新发射一个自定义事件方法,后面跟要修改的值

          • this.$emit("ee",1000);

        • 此时儿子组件上要绑定发射的自定义方法,赋值父亲的接收的函数fn

          • <child :m="msg" @ee="fn"></child>

        • 父亲接收函数,参数就是儿子发射过来的数据

          • fn(data){//此时把儿子发射过来的数据data,重新赋值给第一次传递过去的msgreturn this.msg=data;}

        • 这样就成功了实现父与子之间的数据双向绑定

        • let vm = new Vue({
                   el:'#app',
                   //通过在儿子组件上绑定一个属性向儿子传递数据
                   // @ee="fn" 接收儿子传递过来数据,ee是儿子那边自定义的事件方法,必须绑定在儿子组件上
                   template:'<div>父亲+{{money}}<child :m="money" @ee="fn"></child></div>',
                   data:{
                       money:100
                   },
                   methods:{
                       fn(data){
                        //父亲接收儿子的数据函数
                           return this.money=data;
                       }
                   },
                   components:{
                       child:{
                          //接收父亲传递过来的属性值
                           props:{m:{}},
                           template:'<div>{{m}}<button @click="more"></button></div>',
                           methods:{
                               more(){
                               //向父亲发射一个自定义方法,并传递过去自己的值
                                   this.$emit('ee',1000)
                               }
                           }
                       }
                   }
               })

          实现父亲月儿子之间的数据双向数据绑定 在高版本中有sync修饰符

          • 父亲先通过在儿子身上绑定一个属性,向儿子传递数据

          • 这时候,属性后面我们跟一个sync修饰符

          • 例如 <child :m.sync="msg"></child>

        • 这时候,儿子要通过props接受父亲传递的参数

          • props:{

            m:{
            type:Array //规定是数据类型
            }

            }

        • 儿子接受到数据,发现不满意,发射一个自定义事件方法给父亲

          • this.$emit('update:m',1000);

        • 此时我们发现父亲的数据m自动更改了,变成1000

     let vm = new Vue({
             el:'#app',
             template:'<div>父{{msg}}<child :a.sync="msg"/></div>',
             data:{
                 msg:'美女'
             },
             components:{
                 child:{
                     props:['a'], //<comp :foo="bar" @update:foo="val => bar = val"></comp>
                     template:'<div>child {{a}} <button @click="change">换</button></div>',
                     methods:{
                         change(){ //固定的写法
                             //2.3.0版本以后才会用
                             //用了sync,下面必须用update
                             this.$emit('update:a','丑女');
                         }
                     }
                 }
             }
         })

    父亲调用子组件的一些方法

    第一步先定义儿子有一个fn方法

    methods:{fn(){ console.log("王阿姨好漂亮"); }}

    第二步在儿子身上标记一个表示ref

    <child ref="msg"></child>

    第三步父亲在视图加载完成后,调用儿子的fn方法

    mounted(){this.$refs.msg.fn();}

    this.$refs.msg 调用儿子身上的msg表示,这时候this.$refs.msg指向的就是儿子的实例

    实例.fn() 这就调用到了儿子的fn方法

    • // ref如果写在dom上,表示获取dom,如果写在组件上,表示当前组件的实例
           let vm=new Vue({
               el:"#app",
               template:'<child ref="c"></child>',
               //一定要放在mounted下面,因为mounted方法表示数据和视图渲染完成,
               mounted(){
                   //当前的ref指向的是child组件的实例,通过实例调用下面的fn方法
                   this.$refs.c.fn();
               },
               components:{
                   child:{
                       template:'<div>child</div>',
                       methods:{
                           fn(){
                               alert("王阿姨好漂亮")
                           }
                       }
                   }
               }
           })

      兄弟组件之间的数据通讯(就是平级组件之间的数据通讯)

      • 兄弟组件之间数据互通,要借助第三个vue实例

      • eventBus使用起来不好管理,命名冲突,而且复杂,一般不用

        • 我们通常叫这个实例叫eventBus

          • let eventBus=new Vue;

        • 将兄弟发射的自定义事件方法,挂载到eventBus实例上

          • eventBus.$emit('aa',''c');

        • 然后通过$on方法,将兄弟发射的自定义事件方法绑定里面去

        • 后面的回调函数一定要是箭头函数,不改变实例的this,方便赋值

          • 例如 eventBus.$on('aa',(data)=>{console.log(data) }

           let eventBus=new Vue;
              //eventBus使用起来不好管理,命名冲突,而且复杂,一般不用
              let C={
                  template:'<div>{{val}}<button @click="ss">变C</button></div>',
                  data(){
                      return {
                          val:"C"
                      }
                  },
                  methods:{
                      ss(){
          
                      eventBus.$emit('bb','C');
                      }
                  },
                  created(){
                      //
                      eventBus.$on('aa',(data)=>{
                          this.val=data;
                      })
                  }
              };
              let D={
                  template:'<div>{{val}}<button @click="ee">变D</button></div>',
                  data(){
                      return {
                          val:"D"
                      }
                  },
                  created(){
                      //
                      eventBus.$on("bb",(data)=>{
                          this.val=data;
                      })
                  },
                  methods:{
                      ee(){
          //
                              eventBus.$emit('aa','D');
                          }
                      }
              }
              let vm = new Vue({
                  el:'#app',
                  //1,找共同父级,时间交互,非常复杂,不采用
                  template:'<div><C></C><D></D></div>',
                  data:{
          
                  },
                  components:{
                      C,
                      D
                  }
              })

          使用 slot 分发内容

          slot 可以将不同的标签分开发送到指定的节点中

          slot 有一个name属性

          slot上的name属性,有一个默认值default

          没有指定slot名字的都叫default 会塞到name=default的组件内

          <div id="app">
                <hello>
                    123
                    <ul slot="bottom">
                        <li>我很帅</li>
                    </ul>
                    <ul slot="top">
                        <li>你丑</li>
                    </ul>
                    456
                </hello>
            </div>
            <template id="hello">
                <div>
                    <!--slot是vue提供的内置插件,具名slot 在写内容时第一预留出来slot插口,如果没有使用则使用默认内容,没有指定slot名字的都叫default 会塞到name=default的组件内-->
                    <slot name="default">nihao </slot>
                    <slot name="top">这是上</slot>
                    <slot name="bottom">这是下</slot>
                </div>
            </template>
            <script>
                let vm = new Vue({
                    el:'#app',
                    components:{
                        hello:{
                            template:'#hello'
                        }
                    }
                })
            </script>

          vue动画组件 transition

          • transition有一个name属性

            • 假设我们name="fade"

          • transition动画组件对应三个css样式

          • 进入开始 .fade-enter 的样式

          • 开始过渡阶段 .fade-enter-active

          • 出去终点 .fade-leave-active

          • 这三个样式里面,我们可以任意写样式

          如果文章有帮助到您,请点右侧的推荐关注哈,O(∩_∩)O谢谢~ >>>>


  • 相关阅读:
    Kth element of Two Sorted Arrays
    Populating Next Right Pointers in Each Node I && II
    Average waiting time of SJF and Round Robin scheduling
    LRU Cache
    Calculate H-index
    Get Level of a node in a Binary Tree
    Two Sum
    Intersection of Two Linked Lists
    Symmetric Tree
    Lowest Common Ancestor of Binary (Search) Tree
  • 原文地址:https://www.cnblogs.com/null11/p/7481837.html
Copyright © 2011-2022 走看看