60分钟组件神速入门,分分钟玩转Vue

Vue.js 组件

  • 模块化:是从代码逻辑的角度张开剪切的;
  • 组件化:是从UI分界面包车型地铁角度展开分割的。

组件(Component)是 Vue.js 最精锐的法力之一,组件能够扩充 HTML
成分,封装可选用的代码。

组件系统让大家得以用独立可复用的小组件来创设大型应用,大约任意档次的采用的分界面都足以抽象为2个零部件树,如下图所示:

澳门葡京 1

组件简要介绍

怎样是组件呢?

零件简要介绍

使用Vue.extend来创建全局vue组件:

var com1 = Vue.extend({
template: '<h3>这是使用 Vue.extend 创建的组件</h3>' // 通过template属性,指定了组件要展示的HTML结构
})

零件系统是Vue.js个中二个至关心珍视要的定义,它提供了1种浮泛,让大家得以动用独立可复用的小组件来创设大型应用,任意档次的选拔分界面都足以抽象为3个零件树:

澳门葡京 2

零件系统是Vue.js个中叁个根本的概念,它提供了壹种浮泛,让大家能够动用独立可复用的小组件来营造大型应用,任意档次的使用界面都足以抽象为三个零件树:

60分钟组件神速入门,分分钟玩转Vue。那时候只是评释了3个叫com一的组件,假使要在vue实例中使用组件,还要求经过以下形式来注册组件:

   Vue.component('myCom1', com1)

澳门葡京 3

组件能够扩大HTML元素,封装可选择的HTML代码,我们能够将零件看作自定义的HTML成分。

澳门葡京 4 

组件的调用: 

  <div id="app">
    <!-- 如果要使用组件,直接把组件的名称以HTML标签的形式,引入到页面中即可 -->
    <my-com1></my-com1>
  </div>

那正是说如何是组件呢?

本文的德姆o和源代码已停放GitHub,倘诺您以为本篇内容科学,请点个赞,或在GitHub上加个轻易!

那便是说怎么样是组件呢?
组件能够扩充HTML成分,封装可选拔的HTML代码,大家得以将零件看作自定义的HTML成分。

 注意事项:

  1. 假诺选取 Vue.component
    注册组件的时候,组件名称使用了驼峰命名,则在引用组件的时候,须要把大写的驼峰改为小写的假名,同时,多少个单词之间使用
    “-” 连接
  2. 要是不使用驼峰,则向来拿名称来接纳就能够;

零件能够扩充HTML成分,封装可选用的HTML代码,大家得以将零件看作自定义的HTML成分。

(全部示例都坐落GitHub
Pages上了,请访问https://github.com/keepfool/vue-tutorials翻开示例汇总)

零件的创始和挂号

其它二种创立组件的主意:

    Vue.component('myCom1', Vue.extend({
      template: '<h3>这是使用Vue.extend创建的组件</h3>'
    }))

    Vue.component('mycom2', {
      template: '<div><h3>这是直接使用Vue.component创建出来的组件</h3>123</div>'
    })

鉴于组件的篇幅较大,我将会把组件的入门知识分为两篇来讲学,那样也有利各位看官们快快消化。

组件单向绑定组件双向绑定组件单次绑定Page
DemoGitHub
Source

着力步骤

只顾:不论是哪一种方法开创出来的机件,组件的 template 属性指向的模板内容,必须有且只可以有唯一的3个根成分

组件的始建和注册

由于组件的字数较大,小编将会把组件的入门知识分为两篇来教学,那样也造福各位看官们极快消化。

Vue.js的零件的运用有2个步骤:创制组件构造器、注册组件和使用组件。

在被决定的#app外面,使用template成分,定义组件的HTML模板结构:

  <template id="tmpl">
    <div>
      <h1>这是通过 template 元素,在外部定义的组件结构,这个方式,有代码的智能提示和语法高亮</h1>
    </div>
  </template>

   Vue.component('mycom3', {
      template: '#tmpl' //引用template的id属性
    })

骨干步骤

组件的创立和注册

澳门葡京 5 

 私有组件:

  <template id="tmpl2">
    <h1>这是私有的 login 组件</h1>
  </template>

    var vm2 = new Vue({
      el: '#app2',
      components: { // 定义实例内部私有组件的
        login: {
          template: '#tmpl2'
        }
      },
    })

Vue.js的组件的行使有二个步骤:创制组件构造器、注册组件和选取组件。

主导步骤

下边包车型地铁代码演示了那二个步骤:

零件中的data和methods:

  1. 零件能够有协调的data数据;
  2. 组件的data和实例的data有点不等同,实例中的data可感到二个指标,可是组件中的data必须是3个方法;
  3. 组件中的data除了必须为三个艺术之外,那么些点子内部还非得回到一个指标;
  4. 零件中的data数据,使用方法和实例中的data使用方法完全一样

    Vue.component('mycom1', {
      template: '<h1>这是全局组件 --- {{msg}}</h1>',
      data: function () {
        return {
          msg: '这是组件的中data定义的数据'
        }
      }
    })
    

澳门葡京 6

Vue.js的组件的利用有一个步骤:创建组件构造器、注册组件和行使组件。

<!DOCTYPE html>
<html>
 <body>
 <div id="app">
 <!-- 3. #app是Vue实例挂载的元素,应该在挂载元素范围内使用组件-->
 <my-component></my-component>
 </div>
 </body>
 <script src="js/vue.js"></script>
 <script>

 // 1.创建一个组件构造器
 var myComponent = Vue.extend({
 template: '<div>This is my first component!</div>'
 })

 // 2.注册组件,并指定组件的标签,组件的HTML标签为<my-component>
 Vue.component('my-component', myComponent)

 new Vue({
 el: '#app'
 });

 </script>
</html>

 为啥组件中的data必须若是二个方法,演示如下:

Html代码:

  <div id="app">
    <counter></counter>
    <hr>
    <counter></counter>
    <hr>
    <counter></counter>
  </div>
  <template id="tmpl">
    <div>
      <input type="button" value="+1" @click="increment">
      <h3>{{count}}</h3>
    </div>
  </template>

javascript代码:

    var dataObj = { count: 0 }
    //这是一个计数器的组件, 身上有个按钮,每当点击按钮,让data中的count值+1
    Vue.component('counter', {
      template: '#tmpl',
      data: function () {
        // return dataObj
        return { count: 0 }
      },
      methods: {
        increment() {
          this.count++
        }
      }
    })
    // 创建 Vue 实例,得到 ViewModel
    var vm = new Vue({
      el: '#app',
      data: {},
      methods: {}
    });

调用测试结果如下 :

澳门葡京 7

每一种计数器的count是独立的,如将将再次回到的值改为:

        return dataObj
        //return { count: 0 }

结果为:

澳门葡京 8

各类组件的count是共享的,组件的data必须是2个格局,且务必回到3个对象。要化解的主题材料正是压实组件的复用性,幸免组件与组件之间成员干扰。

上边包车型客车代码演示了那二个步骤:

澳门葡京 9

运行结果如下:

组件的切换:

<body>
  <div id="app">
    <a href="" @click.prevent="flag=true">登录</a>
    <a href="" @click.prevent="flag=false">注册</a>
    <login v-if="flag"></login>
    <register v-else="flag"></register>
  </div>
  <script>
    Vue.component('login', {
      template: '<h3>登录组件</h3>'
    })
    Vue.component('register', {
      template: '<h3>注册组件</h3>'
    })
    var vm = new Vue({
      el: '#app',
      data: {
        flag: true
      },
      methods: {}
    });
  </script>
</body>

演示结果如下,私下认可呈现登陆组件,点击注册切换成注册组件,点击登陆切换的记名组件。

澳门葡京 10

 

 

 

症结分析:借使在三个须要中必要切换更多的组件,那种格局不便于扩大。

    <!– Vue提供了component ,来展现对应名称的机件 –>

    <!– component 是3个占位符,
“:is”是性质,能够用来钦赐要展现的机件的称呼 –>

  <div id="app">
    <a href="" @click.prevent="comName='login'">登录</a>
    <a href="" @click.prevent="comName='register'">注册</a>
    <component :is="comName"></component>
  </div>
  <script>
    // 组件名称是字符串
    Vue.component('login', {
      template: '<h3>登录组件</h3>'
    })
    Vue.component('register', {
      template: '<h3>注册组件</h3>'
    })
    // 创建 Vue 实例,得到 ViewModel
    var vm = new Vue({
      el: '#app',
      data: {
        comName: 'login' //当前component中的 :is 绑定的组件的名称
      },
    });
  </script>
<!DOCTYPE html>
<html>
  <body>
    <div id="app">
      <!-- 3. #app是Vue实例挂载的元素,应该在挂载元素范围内使用组件-->
      <my-component></my-component>
    </div>
  </body>
  <script src="js/vue.js"></script>
  <script>

    // 1.创建一个组件构造器
    var myComponent = Vue.extend({
      template: '<div>This is my first component!</div>'
    })

    // 2.注册组件,并指定组件的标签,组件的HTML标签为<my-component>
    Vue.component('my-component', myComponent)

    new Vue({
      el: '#app'
    });

  </script>
</html>

上面包车型客车代码演示了那三个步骤:

澳门葡京 11 

组件切换动画:

html代码:

  <div id="app">
    <a href="" @click.prevent="comName='login'">登录</a>
    <a href="" @click.prevent="comName='register'">注册</a>

    <!-- 通过 mode 属性,设置组件切换时候的模式为先出后进-->
    <transition mode="out-in">
      <component :is="comName"></component>
    </transition>

  </div>

  <script>
    // 组件名称是 字符串
    Vue.component('login', {
      template: '<h3>登录组件</h3>'
    })

    Vue.component('register', {
      template: '<h3>注册组件</h3>'
    })
    var vm = new Vue({
      el: '#app',
      data: {
        comName: 'login' // 当前 component 中的 :is 绑定的组件的名称
      },
    });
  </script>

css代码:

  <style>
    .v-enter,
    .v-leave-to {
      opacity: 0;
      transform: translateX(150px);
    }

    .v-enter-active,
    .v-leave-active {
      transition: all 0.5s ease;
    }
  </style>

运作结果如下:

运转结果如下:

能够见见,使用组件和行使普通的HTML成分没什么差距。

子组件引用父组件的值:

 1     <div id="app">
 2         <com1></com1>
 3     </div>
 4     <script>
 5 
 6             Vue.component
 7             var vm = new Vue({
 8                 el:'#app',
 9                 data:{
10                     msg:"heelo !"
11                 },
12                 methods:{
13                 },
14                 components:{
15                     com1:{
16                         template:'<h1>这是子组件---{{msg}}</h1>'
17                     }
18                 }
19             })
20         </script>

施行结果:

澳门葡京 12

暗中认可情形下子组件是不可能引用父组件的习性和对象的,大家可以在引用子组件的时候,通过品质绑定的款式(v-bind)的款型,把必要传递给子组件的数量,以属性绑定的情势传递到子组件内部,供子组件使用,并且在props中宣示该属性(props中的数据都以透过父组传递过来的,那里的多少是只读的),代码如下:

 1     <div id="app">
 2         <com1 v-bind:parentmsg="msg"></com1>
 3     </div>
 4     <script>
 5         Vue.component
 6         var vm = new Vue({
 7             el: '#app',
 8             data: {
 9                 msg: "heelo !"
10             },
11             methods: {
12             },
13             components: {
14                 data() {
15                     return {
16                         title: '123',
17                         content: 'pppp'
18                     }
19                 },
20                 com1: {
21                     props: ['parentmsg'],
22                     template: '<h1>这是子组件---{{parentmsg}}</h1>'
23                 }
24             }
25         })
26     </script>

澳门葡京 13

澳门葡京 14

知道组件的始建和注册

子组件调用父组件的法子:

请详细看下边代码中的注释

 1  <div id="app">
 2      
 3     <com2 @func="show"></com2>
 4     </div>
 5     <template id="tmpl">
 6         <div>
 7             <h1>这是子组件</h1>
 8             <input type="button" value="这是子组件中的点击按钮" @click="myclick">
 9         </div>
10     </template>
11     <script>
12         //定义了一个字面量类型的组件模板对象
13         var com2 = {
14             template: '#tmpl',
15             data() {
16                 return {
17                     sonmsg: { name: 'wjl', age: 16 }
18                 }
19             },
20             methods: {
21                 myclick() {
22                     //当点击子组件的按钮时,通过$emit拿到父组件传递过来的func
23                     //emit的英文愿意为触发、调用、发射的意思
24                     this.$emit('func', this.sonmsg, 123, 456)
25                 }
26             }
27         }
28         var vm = new Vue({
29             el: '#app',
30             data: {
31                 datamsg: null
32             },
33             methods: {
34                 show(data, data1, data2) {
35                     console.log('调用了父组件的show方法:' + data.name + data1 + data2);
36                 }
37             },
38             components: {
39                 com2
40             }
41         })
42     </script>

能够看出,使用组件和运用普通的HTML成分没什么不一致。

能够见见,使用组件和采用普通的HTML成分没什么分裂。

小编们用以下多少个步骤来精通组件的创设和挂号:
1.
Vue.extend()是Vue构造器的扩张,调用Vue.extend()成立的是多少个零件构造器,而不是一个现实的零件实例。
二.
Vue.extend()构造器有三个取舍对象,选项对象的template属性用于定义组件要渲染的HTML。
3.
使用Vue.component()注册组件时,必要提供二个参数,第3个参数时组件的竹签,第贰个参数是组件构造器。

执行结果:

澳门葡京 15

自己的博客将要搬运一只至腾讯云+社区,特邀大家一起入驻:

接头组件的创始和挂号

知晓组件的创设和挂号

  1. Vue.component()方法内部会调用组件构造器,创造二个零部件实例。
  2. 零件应该挂载到有个别Vue实例下,不然它不会一蹴而就。

咱俩用以下多少个步骤来了解组件的创办和挂号:

笔者们用以下多少个步骤来驾驭组件的创设和登记:

请留意第四点,以下代码在一个地点使用了my-component标签,但只有#app1和#app二下的my-component标签才起到效用。

一.
Vue.extend()是Vue构造器的强大,调用Vue.extend()创建的是叁个组件构造器,而不是贰个现实的组件实例。

一.Vue.extend()是Vue构造器的增加,调用Vue.extend()创制的是多个组件构造器。

<!DOCTYPE html>
<html>
 <body>
 <div id="app1">
 <my-component></my-component>
 </div>

 <div id="app2">
 <my-component></my-component>
 </div>

 <!--该组件不会被渲染-->
 <my-component></my-component>
 </body>
 <script src="js/vue.js"></script>
 <script>
 var myComponent = Vue.extend({
 template: '<div>This is a component!</div>'
 })

 Vue.component('my-component', myComponent)

 var app1 = new Vue({
 el: '#app1'
 });

 var app2 = new Vue({
 el: '#app2'
 })
 </script>
</html>

2.
Vue.extend()构造器有三个抉择对象,选项对象的template属性用于定义组件要渲染的HTML。

二.Vue.extend()构造器有一个挑选对象,选项对象的template属性用于定义组件要渲染的HTML。

澳门葡京 16

3.
行使Vue.component()注册组件时,供给提供1个参数,第二个参数时组件的竹签,第3个参数是组件构造器。

叁.
选取Vue.component()注册组件时,要求提供二个参数,第三个参数时组件的竹签,第一个参数是组件构造器。

全局注册和有个别注册

  1. Vue.component()方法内部会调用组件构造器,创制1个零件实例。

  2. 组件应该挂载到有个别Vue实例下,不然它不会一蹴而就。

  1. 零件应该挂载到有个别Vue实例下,不然它不会收效。

调用Vue.component()注册组件时,组件的挂号是大局的,这象征该器件能够在任意Vue示例下使用。
只要不需求全局注册,恐怕是让组件使用在任何组件内,能够用选项对象的components属性实现部分注册。

请小心第伍点,以下代码在三个地方采用了<my-component>标签,但唯有#app1和#app2下的<my-component>标签才起到功能。

请留意第陆点,以下代码在3个地点使用了标签,但唯有#app1和#app二下的竹签才起到作用。

上边的演示能够改为一些注册的措施:

<!DOCTYPE html>
<html>
  <body>
    <div id="app1">
      <my-component></my-component>
    </div>

    <div id="app2">
      <my-component></my-component>
    </div>

    <!--该组件不会被渲染-->
    <my-component></my-component>
  </body>
  <script src="js/vue.js"></script>
  <script>
    var myComponent = Vue.extend({
      template: '<div>This is a component!</div>'
    })

    Vue.component('my-component', myComponent)

    var app1 = new Vue({
      el: '#app1'
    });

    var app2 = new Vue({
      el: '#app2'
    })
  </script>
</html>

澳门葡京 17

<!DOCTYPE html>
<html>
 <body>
 <div id="app">
 <!-- 3. my-component只能在#app下使用-->
 <my-component></my-component>
 </div>
 </body>
 <script src="js/vue.js"></script>
 <script>
 // 1.创建一个组件构造器
 var myComponent = Vue.extend({
 template: '<div>This is my first component!</div>'
 })

 new Vue({
 el: '#app',
 components: {
 // 2. 将myComponent组件注册到Vue实例下
 'my-component' : myComponent
 }
 });
 </script>
</html>

由于my-component组件是注册在#app元素对应的Vue实例下的,所以它不能在其它Vue实例下使用。

<div id="app2">
 <!-- 不能使用my-component组件,因为my-component是一个局部组件,它属于#app-->
 <my-component></my-component>
</div>

<script>
 new Vue({
 el: '#app2'
 });
</script>

澳门葡京 18

View
Demo

如果你如此做了,浏览器会提醒1个荒唐:

全局注册和一些注册

全局注册和有个别注册

澳门葡京 19

调用Vue.component()注册组件时,组件的登记是全局的,那意味该器件能够在任意Vue示例下使用。

调用Vue.component()注册组件时,组件的挂号是大局的,这意味该零件可以在任意Vue示例下使用。

父组件和子组件

万一不供给全局注册,只怕是让组件使用在别的组件内,能够用选项对象的components属性达成部分注册。

假诺不须要全局注册,也许是让组件使用在别的组件内,能够用接纳对象的components属性完结部分注册

作者们能够在组件中定义并采纳任何零件,这就整合了父亲和儿子组件的涉及。

上边的言传身教能够改为部分注册的点子:

地点的以身作则能够改为部分注册的章程:

<!DOCTYPE html>
<html>
 <body>
 <div id="app">
 <parent-component>
 </parent-component>
 </div>
 </body>
 <script src="js/vue.js"></script>
 <script>

 var Child = Vue.extend({
 template: '<p>This is a child component!</p>'
 })

 var Parent = Vue.extend({
 // 在Parent组件内使用<child-component>标签
 template :'<p>This is a Parent component</p><child-component></child-component>',
 components: {
 // 局部注册Child组件,该组件只能在Parent组件内使用
 'child-component': Child
 }
 })

 // 全局注册Parent组件
 Vue.component('parent-component', Parent)

 new Vue({
 el: '#app'
 })

 </script>
</html>
<!DOCTYPE html>
<html>
  <body>
    <div id="app">
      <!-- 3. my-component只能在#app下使用-->
      <my-component></my-component>
    </div>
  </body>
  <script src="js/vue.js"></script>
  <script>
    // 1.创建一个组件构造器
    var myComponent = Vue.extend({
      template: '<div>This is my first component!</div>'
    })

    new Vue({
      el: '#app',
      components: {
        // 2. 将myComponent组件注册到Vue实例下
        'my-component' : myComponent
      }
    });
  </script>
</html>

由于my-component组件是挂号在#app成分对应的Vue实例下的,所以它无法在其余Vue实例下接纳。

那段代码的运作结果如下:

由于my-component组件是注册在#app元素对应的Vue实例下的,所以它无法在另外Vue实例下选择。

1旦您这么做了,浏览器会提醒二个荒谬:

澳门葡京 20 

<div id="app2">
  <!-- 不能使用my-component组件,因为my-component是一个局部组件,它属于#app-->
  <my-component></my-component>
</div>

<script>
  new Vue({
    el: '#app2'
  });
</script>

澳门葡京 21

大家分多少个步骤来驾驭那段代码:

设若你这么做了,浏览器会提示三个破绽百出:

View
Demo

咱俩分几个步骤来精晓那段代码:

澳门葡京 22

父组件和子组件

var Child =
Vue.extend(…)定义一了个Child组件构造器
var Parent =
Vue.extend(…)定义二个Parent组件构造器
components: { ‘child-component’: Child
},将Child组件注册到Parent组件,并将Child组件的标签设置为child-component。
template :'<p>This is a Parent
component</p><child-component></child-component>’,在Parent组件内以标签的样式利用Child组件。
Vue.component(‘parent-component’, Parent)
全局注册Parent组件
在页面中央银行使标签渲染Parent组件的内容,同时Child组件的剧情也被渲染出来

父组件和子组件

我们能够在组件中定义并运用其余零件,那就构成了父亲和儿子组件的关系。

澳门葡京 23 

大家得以在组件中定义并应用别的零件,那就构成了父子组件的关系。

那段代码的运转结果如下:

Child组件是在Parent组件中注册的,它只辛亏Parent组件中利用,确切地说:子组件只还好父组件的template中采取。

<!DOCTYPE html>
<html>
  <body>
    <div id="app">
      <parent-component>
      </parent-component>
    </div>
  </body>
  <script src="js/vue.js"></script>
  <script>

    var Child = Vue.extend({
      template: '<p>This is a child component!</p>'
    })

    var Parent = Vue.extend({
      // 在Parent组件内使用<child-component>标签
      template :'<p>This is a Parent component</p><child-component></child-component>',
      components: {
        // 局部注册Child组件,该组件只能在Parent组件内使用
        'child-component': Child
      }
    })

    // 全局注册Parent组件
    Vue.component('parent-component', Parent)

    new Vue({
      el: '#app'
    })

  </script>
</html>

澳门葡京 24

请小心下边三种子组件的采纳办法是错误的:

那段代码的周转结果如下:

大家分多少个步骤来驾驭那段代码:

1. 以子标签的款式在父组件中应用

澳门葡京 25

var Child = Vue.extend(…)定义一了个Child组件构造器

<div id="app">
 <parent-component>
 <child-component></child-component>
 </parent-component>
</div>

小编们分多少个步骤来明白那段代码:

var Parent = Vue.extend(…)定义二个Parent组件构造器

缘何那种办法行不通呢?因为当子组件注册到父组件时,Vue.js会编写翻译好父组件的沙盘,模板的始末已经决定了父组件将在渲染的HTML。

一.var Child = Vue.extend(…)定义一了个Child组件构造器

components: { ‘child-component’: Child
},将Child组件注册到Parent组件,并将Child组件的标签设置为child-component。

parent-component相当于运作时,它的部分子标签只会被当做普通的HTML来进行,child-component不是明媒正娶的HTML标签,会被浏览器直接忽略掉。

2.var Parent = Vue.extend(…)定义2个Parent组件构造器

template :’

贰. 在父组件标签外使用子组件

三.components: { ‘child-component’: Child
},将Child组件注册到Parent组件,并将Child组件的价签设置为child-component。

This is a Parent component

<div id="app">
 <parent-component>
 </parent-component>
 <child-component>
 </child-component>
</div>

4.template :'<p>This is a Parent
component</p><child-component></child-component>’,在Parent组件内以标签的样式利用Child组件。

‘,在Parent组件内以标签的样式利用Child组件。

运维那段代码,浏览器会提醒以下错误

5.Vue.component(‘parent-component’, Parent) 全局注册Parent组件

Vue.component(‘parent-component’, Parent)全局注册Parent组件

澳门葡京 26

6.在页面中动用<parent-component>标签渲染Parent组件的内容,同时Child组件的剧情也被渲染出来

在页面中央银行使标签渲染Parent组件的内容,同时Child组件的情节也被渲染出来

零件注册语法糖

澳门葡京 27

澳门葡京 28

以上组件注册的法子有些麻烦,Vue.js为了简化这些进度,提供了注册语法糖。

Child组件是在Parent组件中登记的,它不得不在Parent组件中选拔,确切地说:子组件只幸亏父组件的template中使用。

Child组件是在Parent组件中登记的,它不得不在Parent组件中央银行使,确切地说:子组件只幸而父组件的template中应用。

选取Vue.component()直接创建和注册组件:

请小心下面二种子组件的选取形式是错误的:

请留心上边三种子组件的选择方法是谬误的:

// 全局注册,my-component1是标签名称
Vue.component('my-component1',{
 template: '<div>This is the first component!</div>'
})

var vm1 = new Vue({
 el: '#app1'
})

一. 以子标签的方式在父组件中采用

1. 以子标签的款型在父组件中利用

Vue.component()的第一个参数是标具名称,第一个参数是叁个增选对象,使用采纳对象的template属性定义组件模板。
运用那种方法,Vue在背后会自行地调用Vue.extend()。

<div id="app">
  <parent-component>
    <child-component></child-component>
  </parent-component>
</div>

何以那种办法行不通呢?因为当子组件注册到父组件时,Vue.js会编写翻译好父组件的模版,模板的始末已经调节了父组件就要渲染的HTML。

在增选对象的components属性中贯彻部分注册:

缘何那种方式行不通呢?因为当子组件注册到父组件时,Vue.js会编译好父组件的模版,模板的始末已经决定了父组件将要渲染的HTML。

…约等于运作时,它的有的子标签只会被作为普通的HTML来实践,不是正规的HTML标签,会被浏览器间接忽略掉。

var vm2 = new Vue({
 el: '#app2',
 components: {
 // 局部注册,my-component2是标签名称
 'my-component2': {
 template: '<div>This is the second component!</div>'
 },
 // 局部注册,my-component3是标签名称
 'my-component3': {
 template: '<div>This is the third component!</div>'
 }
 }
})

<parent-component>…</parent-component>也就是运作时,它的局地子标签只会被看成普通的HTML来实行,<child-component></child-component>不是正式的HTML标签,会被浏览器直接忽略掉。

2. 在父组件标签外使用子组件

使用script或template标签

二. 在父组件标签外使用子组件

运维那段代码,浏览器会提醒以下错误

就算语法糖简化了组件注册,但在template选项中拼接HTML成分相比较费心,那也致使了HTML和JavaScript的高耦合性。
庆幸的是,Vue.js提供了三种艺术将概念在JavaScript中的HTML模板分离出来

<div id="app">
  <parent-component>
  </parent-component>
  <child-component>
  </child-component>
</div>

澳门葡京 29

使用script标签

运营那段代码,浏览器会提醒以下错误

View
Demo

<!DOCTYPE html>
<html>
 <body>
 <div id="app">
 <my-component></my-component>
 </div>

 <script type="text/x-template" id="myComponent">
 <div>This is a component!</div>
 </script>
 </body>
 <script src="js/vue.js"></script>
 <script>

 Vue.component('my-component',{
 template: '#myComponent'
 })

 new Vue({
 el: '#app'
 })

 </script>
</html>

澳门葡京 30

组件注册语法糖

template选项现行反革命不再是HTML成分,而是二个id,Vue.js依据这么些id查找对应的要素,然后将以此因素内的HTML作为模板实行编写翻译。

组件注册语法糖

上述组件注册的不二诀窍有个别麻烦,Vue.js为了简化那么些进度,提供了注册语法糖。

澳门葡京 31 

如上组件注册的点子有点麻烦,Vue.js为了简化这么些进度,提供了注册语法糖。

运用Vue.component()直接创立和注册组件:

注意:使用script标签时,type钦点为text/x-template,意在告诉浏览器那不是一段js脚本,浏览器在解析HTML文书档案时会忽略script标签内定义的始末。

接纳Vue.component()间接创立和登记组件:

// 全局注册,my-component1是标具名称Vue.component(‘my-component一’,{   
template:’

澳门葡京 32

// 全局注册,my-component1是标签名称
Vue.component('my-component1',{
  template: '<div>This is the first component!</div>'
})

var vm1 = new Vue({
  el: '#app1'
})

This is the first component!

使用template标签

Vue.component()的第一个参数是标具名称,第1个参数是二个精选对象,使用选拔对象的template属性定义组件模板。
行使那种办法,Vue在私下会自行地调用Vue.extend()。

‘})varvm1 =newVue({    el:’#app1’})

若果选择template>标签,则不必要钦命type属性。

在增选对象的components属性中达成部分注册:

Vue.component()的第二个参数是标具名称,第叁个参数是二个选拔对象,使用选取对象的template属性定义组件模板。

<!DOCTYPE html>
<html>
 <head>
 <meta charset="UTF-8">
 <title></title>
 </head>
 <body>
 <div id="app">
 <my-component></my-component>
 </div>

 <template id="myComponent">
 <div>This is a component!</div>
 </template>
 </body>
 <script src="js/vue.js"></script>
 <script>

 Vue.component('my-component',{
 template: '#myComponent'
 })

 new Vue({
 el: '#app'
 })

 </script>
</html>
var vm2 = new Vue({
  el: '#app2',
  components: {
    // 局部注册,my-component2是标签名称
    'my-component2': {
      template: '<div>This is the second component!</div>'
    },
    // 局部注册,my-component3是标签名称
    'my-component3': {
      template: '<div>This is the third component!</div>'
    }
  }
})

动用那种艺术,Vue在骨子里会活动地调用Vue.extend()。

在知道了组件的创建和挂号进程后,小编建议采用script>或template>标签来定义组件的HTML模板。
这使得HTML代码和JavaScript代码是分其他,便于阅读和维护。
除此以外,在Vue.js中,可制造.vue后缀的文件,在.vue文件中定义组件,这么些剧情小编会在末端的篇章介绍

使用script或template标签

在选取对象的components属性中贯彻部分注册:

组件的el和data选项

纵然语法糖简化了组件注册,但在template选项中拼接HTML成分比较劳碌,那也促成了HTML和JavaScript的高耦合性。
弹冠相庆的是,Vue.js提供了二种情势将定义在JavaScript中的HTML模板分离出来。

varvm2 =newVue({    el:’#app二’,    components: {//
局地注册,my-component2是标具名称’my-component二’: {           
template:’

传播Vue构造器的大多数摘取也能够用在 Vue.extend()
或Vue.component()中,不过有四个特例: data 和el。
Vue.js规定:在概念组件的选项时,data和el选项必须运用函数。

使用<script>标签

This is the second component!

上面包车型地铁代码在施行时,浏览器会建议贰个错误

<!DOCTYPE html>
<html>
  <body>
    <div id="app">
      <my-component></my-component>
    </div>

    <script type="text/x-template" id="myComponent">
      <div>This is a component!</div>
    </script>
  </body>
  <script src="js/vue.js"></script>
  <script>

    Vue.component('my-component',{
      template: '#myComponent'
    })

    new Vue({
      el: '#app'
    })

  </script>
</html>

‘},// 局地注册,my-component三是标具名称’my-component三’: {           
template:’

Vue.component('my-component', {
 data: {
 a: 1
 }
})

template选项现行反革命不再是HTML成分,而是一个id,Vue.js依照那个id查找对应的要素,然后将这些因素内的HTML作为模板进行编译。

This is the third component!

澳门葡京 33 

澳门葡京 34

‘}    }})

除此以外,如若data选项指向有个别对象,那象征全体的组件实例共用三个data。
大家应当接纳叁个函数作为 data 选项,让那一个函数重临二个新目标:

只顾:使用<script>标签时,type钦点为text/x-template,意在报告浏览器这不是1段js脚本,浏览器在解析HTML文书档案时会忽略<script>标签钦命义的剧情。

View
Demo

Vue.component('my-component', {
 data: function(){
 return {a : 1}
 }
})

澳门葡京 35

使用script或template标签

使用props

使用<template>标签

固然语法糖简化了组件注册,但在template选项中拼接HTML成分相比辛勤,那也导致了HTML和JavaScript的高耦合性。

组件实例的成效域是孤立的。那表示无法而且不应有在子组件的模版内一直引用父组件的数目。能够使用
props 把数量传给子组件。

如若采取<template>标签,则不须要内定type属性。

幸甚的是,Vue.js提供了三种情势将定义在JavaScript中的HTML模板分离出来。

props基础示例
上边包车型大巴代码定义了2个子零部件my-component,在Vue实例中定义了data选项。

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title></title>
  </head>
  <body>
    <div id="app">
      <my-component></my-component>
    </div>

    <template id="myComponent">
      <div>This is a component!</div>
    </template>
  </body>
  <script src="js/vue.js"></script>
  <script>

    Vue.component('my-component',{
      template: '#myComponent'
    })

    new Vue({
      el: '#app'
    })

  </script>
</html>

使用

var vm = new Vue({
 el: '#app',
 data: {
 name: 'keepfool',
 age: 28
 },
 components: {
 'my-component': {
 template: '#myComponent',
 props: ['myName', 'myAge']
 }
 }
})

在明亮了组件的创办和注册进度后,作者建议利用<script>或<template>标签来定义组件的HTML模板。

This is a component!

为了便于精通,你能够将以此Vue实例看作my-component的父组件。
倘若大家想选拔父组件的数额,则必须先在子组件中定义props属性,也正是props:
[‘myName’, ‘myAge’]那行代码。

那使得HTML代码和JavaScript代码是分开的,便于阅读和保险。

template选项现行反革命不再是HTML元素,而是三个id,Vue.js依据这几个id查找对应的因素,然后将这么些因素内的HTML作为模板进行编写翻译。

定义子组件的HTML模板:

别的,在Vue.js中,可成立.vue后缀的公文,在.vue文件中定义组件,那么些剧情作者会在前边的文章介绍。

澳门葡京 36

<template id="myComponent">
 <table>
 <tr>
 <th colspan="2">
 子组件数据
 </th>
 </tr>
 <tr>
 <td>my name</td>
 <td>{{ myName }}</td>
 </tr>
 <tr>
 <td>my age</td>
 <td>{{ myAge }}</td>
 </tr>
 </table>
</template>

组件的el和data选项

注意:使用

将父组件数据通过已定义好的props属性传递给子组件:

传播Vue构造器的大部取舍也可以用在 Vue.extend()
或Vue.component()中,但是有八个特例: data 和el。
Vue.js规定:在概念组件的选项时,data和el选项必须采取函数。

澳门葡京 37

<div id="app">
 <my-component v-bind:my-name="name" v-bind:my-age="age"></my-component>
</div>

上边包车型地铁代码在实践时,浏览器会提议叁个荒唐

使用

注意:在子组件中定义prop时,使用了camelCase命名法。由于HTML性子不区分轻重缓急写,camelCase的prop用于性情时,需求转为
kebab-case(短横线隔断)。例如,在prop中定义的myName,在作为本性时索要转移为my-name。

Vue.component('my-component', {
  data: {
    a: 1
  }
})

如若接纳

那段程序的周转结果如下:

澳门葡京 38

This is a component!

澳门葡京 39 

除此以外,假使data选项指向有个别对象,那意味全数的机件实例共用一个data。

在知晓了组件的创导和挂号进程后,作者提出利用

父组件是何等将数据传给子组件的呢?相信看了上边这图,大概你就能很好地驾驭了。

小编们应该选用3个函数作为 data 选项,让那几个函数重返3个新对象:

那使得HTML代码和JavaScript代码是分手的,便于阅读和爱抚。

澳门葡京 40 

Vue.component('my-component', {
  data: function(){
    return {a : 1}
  }
})

其它,在Vue.js中,可创立.vue后缀的文件,在.vue文件中定义组件,那些剧情笔者会在前边的稿子介绍。

在父组件中使用子组件时,通过以下语法将数据传递给子组件:

使用props

组件的el和data选项

<child-component
v-bind:子组件prop=”父组件数据属性”></child-component>

零件实例的功能域是孤立的。那意味着不可能同时不该在子组件的沙盘内直接引用父组件的数据。能够行使
props 把数量传给子组件。

流传Vue构造器的大部分精选也得以用在Vue.extend()或Vue.component()中,可是有三个特例:data和el。

prop的绑定类型

props基础示例

Vue.js规定:在概念组件的选项时,data和el选项必须使用函数。

一边绑定

上边包车型大巴代码定义了1个子零件my-component,在Vue实例中定义了data选项。

上边包车型大巴代码在实践时,浏览器会提出3个不当

既是父组件将数据传递给了子组件,那么假诺实组件修改了数据,对父组件是还是不是会具有影响呢?
咱俩将子组件模板和页面HTML稍作改变:

var vm = new Vue({
  el: '#app',
  data: {
    name: 'keepfool',
    age: 28
  },
  components: {
    'my-component': {
      template: '#myComponent',
      props: ['myName', 'myAge']
    }
  }
})

Vue.component(‘my-component’, {    data: {        a:1}})

<div id="app">

 <table>
 <tr>
 <th colspan="3">父组件数据</td>
 </tr>
 <tr>
 <td>name</td>
 <td>{{ name }}</td>
 <td><input type="text" v-model="name" /></td>
 </tr>
 <tr>
 <td>age</td>
 <td>{{ age }}</td>
 <td><input type="text" v-model="age" /></td>
 </tr>
 </table>

 <my-component v-bind:my-name="name" v-bind:my-age="age"></my-component>
</div>

<template id="myComponent">
 <table>
 <tr>
 <th colspan="3">子组件数据</td>
 </tr>
 <tr>
 <td>my name</td>
 <td>{{ myName }}</td>
 <td><input type="text" v-model="myName" /></td>
 </tr>
 <tr>
 <td>my age</td>
 <td>{{ myAge }}</td>
 <td><input type="text" v-model="myAge" /></td>
 </tr>
 </table>
</template>

为了有利于掌握,你能够将那些Vue实例看作my-component的父组件。

澳门葡京 41

运作这几个页面,我们做五个小规模试制验:

若果我们想使父组件的数量,则必须先在子组件中定义props属性,相当于props:
[‘myName’, ‘myAge’]那行代码。

其它,要是data选项指向有个别对象,那表示全数的零部件实例共用三个data。

  1. 在页面上修改子组件的数额

定义子组件的HTML模板:

大家相应使用多少个函数作为 data 选项,让这几个函数重返一个新对象:

澳门葡京 42 

<template id="myComponent">
  <table>
    <tr>
      <th colspan="2">
        子组件数据
      </th>
    </tr>
    <tr>
      <td>my name</td>
      <td>{{ myName }}</td>
    </tr>
    <tr>
      <td>my age</td>
      <td>{{ myAge }}</td>
    </tr>
  </table>
</template>

澳门葡京 ,Vue.component(‘my-component’, {    data:function(){return{a :1}    }})

修改了子组件的数量,没有影响父组件的数目。

将父组件数据经过已定义好的props属性传递给子组件:

使用props

  1. 在页面上更动父组件的数码
<div id="app">
  <my-component v-bind:my-name="name" v-bind:my-age="age"></my-component>
</div>

零件实例的成效域是孤立的。那象征无法同时不应有在子组件的模版内一贯引用父组件的数码。能够行使props把数量传给子组件。

澳门葡京 43 

留神:在子组件中定义prop时,使用了camelCase命名法。由于HTML性子不区分轻重缓急写,camelCase的prop用于性格时,供给转为
kebab-case(短横线隔绝)。例如,在prop中定义的myName,在作为天性时索要转移为my-name。

props基础示例

修改了父组件的数据,同时影响了子组件。

那段程序的运作结果如下:

上边包车型客车代码定义了叁个子组件my-component,在Vue实例中定义了data选项。

prop默许是单向绑定:当父组件的品质变化时,将传输给子组件,不过转头不会。那是为着幸免子组件无意修改了父组件的场所

澳门葡京 44

varvm =newVue({    el:’#app’,    data: {        name:’keepfool’,       
age:28},    components: {‘my-component’: {           
template:’#myComponent’,            props: [‘myName’,’myAge’]       
}    }})

双向绑定

父组件是何许将数据传给子组件的呢?相信看了上面那图,大概你就能很好地精通了。

为了便于精晓,你能够将以此Vue实例看作my-component的父组件。

能够使用.sync显式地内定双向绑定,那使得子组件的数量修改会回传给父组件。

澳门葡京 45

万一大家想使父组件的多寡,则必须先在子组件中定义props属性,也正是props:
[‘myName’, ‘myAge’]那行代码。

<my-component v-bind:my-name.sync=”name”
v-bind:my-age.sync=”age”></my-component>

在父组件中使用子组件时,通过以下语法将数据传递给子组件:

定义子组件的HTML模板:

澳门葡京 46

<child-component v-bind:子组件prop="父组件数据属性"></child-component>

子组件数据

单次绑定

prop的绑定类型

my name{{ myName }}

能够使用.once显式地内定单次绑定,单次绑定在确立以往不会共同之后的变化,这表示正是父组件修改了数额,也不会传导给子组件。

另一方面绑定

my age{{ myAge }}

<my-component v-bind:my-name.once=”name”
v-bind:my-age.once=”age”></my-component>

既是父组件将数据传递给了子组件,那么假若实组件修改了数量,对父组件是或不是会怀有影响呢?

将父组件数据经过已定义好的props属性传递给子组件:

澳门葡京 47

咱俩将子组件模板和页面HTML稍作更换:

注意:在子组件中定义prop时,使用了camelCase命名法。由于HTML个性不区分轻重缓急写,camelCase的prop用于天性时,须求转为
kebab-case(短横线隔离)。例如,在prop中定义的myName,在作为性狗时索要转移为my-name。

示例

<div id="app">

  <table>
    <tr>
      <th colspan="3">父组件数据</td>
    </tr>
    <tr>
      <td>name</td>
      <td>{{ name }}</td>
      <td><input type="text" v-model="name" /></td>
    </tr>
    <tr>
      <td>age</td>
      <td>{{ age }}</td>
      <td><input type="text" v-model="age" /></td>
    </tr>
  </table>

  <my-component v-bind:my-name="name" v-bind:my-age="age"></my-component>
</div>

<template id="myComponent">
  <table>
    <tr>
      <th colspan="3">子组件数据</td>
    </tr>
    <tr>
      <td>my name</td>
      <td>{{ myName }}</td>
      <td><input type="text" v-model="myName" /></td>
    </tr>
    <tr>
      <td>my age</td>
      <td>{{ myAge }}</td>
      <td><input type="text" v-model="myAge" /></td>
    </tr>
  </table>
</template>

View
Demo

为了尽快消化那么些知识,我们来做贰个小示例吧。

运维这一个页面,大家做五个小规模试制验:

那段程序的运作结果如下:

<!DOCTYPE html>
<html>

 <head>
 <meta charset="UTF-8">
 <title></title>
 <link rel="stylesheet" href="styles/demo.css" />
 </head>

 <body>
 <div id="app">
 <div id="searchBar">
 Search <input type="text" v-model="searchQuery" />
 </div>
 <simple-grid :data="gridData" :columns="gridColumns" :filter-key="searchQuery">
 </simple-grid>
 </div>

 <template id="grid-template">
 <table>
 <thead>
 <tr>
 <th v-for="col in columns">
 {{ col | capitalize}}
 </th>
 </tr>
 </thead>
 <tbody>
 <tr v-for="entry in data | filterBy filterKey">
 <td v-for="col in columns">
 {{entry[col]}}
 </td>
 </tr>
 </tbody>
 </table>
 </template>

 </body>
 <script src="js/vue.js"></script>
 <script>
 Vue.component('simple-grid', {
 template: '#grid-template',
 props: {
 data: Array,
 columns: Array,
 filterKey: String
 }
 })

 var demo = new Vue({
 el: '#app',
 data: {
 searchQuery: '',
 gridColumns: ['name', 'age', 'sex'],
 gridData: [{
 name: 'Jack',
 age: 30,
 sex: 'Male'
 }, {
 name: 'Bill',
 age: 26,
 sex: 'Male'
 }, {
 name: 'Tracy',
 age: 22,
 sex: 'Female'
 }, {
 name: 'Chris',
 age: 36,
 sex: 'Male'
 }]
 }
 })
 </script>

</html>
  1. 在页面上修改子组件的数目

澳门葡京 48

除了那一个之外上述介绍的知识点,这么些示例还用到了五个知识点:

澳门葡京 49

父组件是什么样将数据传给子组件的啊?相信看了上面那图,大概你就能很好地知道了。

1. prop验证

修改了子组件的数据,未有影响父组件的数量。

澳门葡京 50

props: {
 data: Array,
 columns: Array,
 filterKey: String
}
  1. 在页面上改换父组件的数额

在父组件中使用子组件时,通过以下语法将数据传递给子组件:

那段代码表示:父组件传递过来的data和columns必须是Array类型,filterKey必须是字符串类型。
愈来愈多prop验证的介绍,请参见:官方文书档案prop验证

澳门葡京 51

prop的绑定类型

2. filterBy过滤器
能够依照钦赐的字符串过滤数据。

修改了父组件的数码,同时影响了子组件。

另壹方面绑定

澳门葡京 52

prop暗中认可是单向绑定:当父组件的性质变化时,将传输给子组件,可是转头不会。那是为了防止子组件无意修改了父组件的动静

既然父组件将数据传递给了子组件,那么假使实组件修改了数额,对父组件是不是会具有影响吗?

总结

双向绑定

小编们将子组件模板和页面HTML稍作改造:

选拔组件的前提是创办并登记组件,本篇小说详细介绍了组件从创建到利用的步子,并介绍了三种差异的情势去成立和注册组件;然后介绍了组件的props选项,它用于将父组件的数额传递给子组件,最终大家用2个小的言传身教演示了这个知识点。

能够使用.sync显式地钦命双向绑定,那使得子组件的数码修改会回传给父组件。

父组件数据

本文已被整理到了《Vue.js前端组件学习课程》,欢迎大家学习阅读。

<my-component v-bind:my-name.sync="name" v-bind:my-age.sync="age"></my-component>

name{{ name }}

关于vue.js组件的学科,请我们点击专题vue.js组件学习课程进展学习。

澳门葡京 53

age{{ age }}

下一篇文章地址:分秒钟玩转Vue.js组件(二)

单次绑定

子组件数据

如上正是本文的整体内容,希望对我们的就学抱有帮忙,也指望我们多多支持脚本之家。

可以使用.once显式地钦点单次绑定,单次绑定在建立之后不会共同之后的转移,那表示就是父组件修改了数码,也不会传导给子组件。

my name{{ myName }}

你或者感兴趣的稿子:

  • 基于Vue.js的表格分页组件
  • Vue.js每一日必学之组件与组件间的通讯
  • Vue.js
    老爹和儿子组件通信支出实例
  • Vue.js动态组件解析
  • 强硬Vue.js组件浅析
  • 行使vue.js制作分页组件
  • 深切研商Vue.js组件和零部件通讯
  • 有关vue.js弹窗组件的知识点总括
  • Vue.js落成1个自定义分页组件vue-paginaiton
  • webpack+vue.js落成组件化详解
<my-component v-bind:my-name.once="name" v-bind:my-age.once="age"></my-component>

my age{{ myAge }}

澳门葡京 54

View
Demo

示例

运营那几个页面,我们做多少个小规模试制验:

为了尽快消化这个知识,我们来做3个小示例吧。

  1. 在页面上修改子组件的多少
<!DOCTYPE html>
<html>

  <head>
    <meta charset="UTF-8">
    <title></title>
    <link rel="stylesheet" href="styles/demo.css" />
  </head>

  <body>
    <div id="app">
      <div id="searchBar">
        Search <input type="text" v-model="searchQuery" />
      </div>
      <simple-grid :data="gridData" :columns="gridColumns" :filter-key="searchQuery">
      </simple-grid>
    </div>

    <template id="grid-template">
      <table>
        <thead>
          <tr>
            <th v-for="col in columns">
              {{ col | capitalize}}
            </th>
          </tr>
        </thead>
        <tbody>
          <tr v-for="entry in data | filterBy filterKey">
            <td v-for="col in columns">
              {{entry[col]}}
            </td>
          </tr>
        </tbody>
      </table>
    </template>

  </body>
  <script src="js/vue.js"></script>
  <script>
    Vue.component('simple-grid', {
      template: '#grid-template',
      props: {
        data: Array,
        columns: Array,
        filterKey: String
      }
    })

    var demo = new Vue({
      el: '#app',
      data: {
        searchQuery: '',
        gridColumns: ['name', 'age', 'sex'],
        gridData: [{
          name: 'Jack',
          age: 30,
          sex: 'Male'
        }, {
          name: 'Bill',
          age: 26,
          sex: 'Male'
        }, {
          name: 'Tracy',
          age: 22,
          sex: 'Female'
        }, {
          name: 'Chris',
          age: 36,
          sex: 'Male'
        }]
      }
    })
  </script>

</html>

澳门葡京 55

除此而外以上介绍的知识点,那么些示例还用到了两个知识点:

修改了子组件的多少,未有影响父组件的多少。

  1. prop验证
  1. 在页面上退换父组件的数量
props: {
  data: Array,
  columns: Array,
  filterKey: String
}

澳门葡京 56

那段代码表示:父组件传递过来的data和columns必须是Array类型,filterKey必须是字符串类型。

修改了父组件的数量,同时影响了子组件。

越多prop验证的牵线,请参考:法定文书档案prop验证

prop默许是单向绑定:当父组件的习性变化时,将传输给子组件,不过转头不会。那是为了幸免子组件无意修改了父组件的处境

2. filterBy过滤器

双向绑定

能够依据钦点的字符串过滤数据。

能够使用.sync显式地钦赐双向绑定,那使得子组件的数量修改会回传给父组件。

澳门葡京 57

澳门葡京 58

总结

View
Deom

行使组件的前提是创立并登记组件,本篇小说详细介绍了组件从创制到使用的手续,并介绍了两种分裂的不二等秘书技去创设和挂号组件;然后介绍了组件的props选项,它用于将父组件的数额传递给子组件,最终我们用叁个小的示范演示了那么些知识点。

单次绑定

您可能感兴趣的稿子:

  • 详解vue.js组件化开辟施行
  • vue.js学习之递归组件
  • Vue.js中用v-bind绑定class的注意事项
  • vue贰.0开销试行计算之费劲篇
  • JavaScript之Vue.js【入门基础】
  • 深深理解vue.js双向绑定的实现原理
  • vue.js指令v-model达成情势
  • Vue.js路由组件vue-router使用情势详解
  • Vue二达成组件props双向绑定
  • 依照vue.js完结图片轮播效果
  • 浅谈Vue的为主选择
  • 迅猛入门Vue

能够使用.once显式地钦定单次绑定,单次绑定在建立以往不会同步之后的更换,那代表正是父组件修改了数据,也不会传导给子组件。

澳门葡京 59

View
Deom

示例

为了赶紧消化那些文化,我们来做1个小示例吧。

Search{{ col | capitalize}}{{entry[col]}}

View
Demo

除此之外上述介绍的知识点,这么些示例还用到了多少个知识点:

1. prop验证

props: {    data:Array,    columns:Array,    filterKey:String}

那段代码表示:父组件传递过来的data和columns必须是Array类型,filterKey必须是字符串类型。

更多prop验证的介绍,请参考:官方文档prop验证

2. filterBy过滤器

能够依照内定的字符串过滤数据。

澳门葡京 60

总结

应用组件的前提是创办并登记组件,本篇小说详细介绍了组件从创建到使用的步调,并介绍了两种不一致的法子去成立和挂号组件;然后介绍了组件的props选项,它用于将父组件的多少传递给子组件,最后大家用3个小的示范演示了这么些知识点。

转自新浪:

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website