0入门基础知识之全局API

3.全局API

3.全局API

1、什么是全局API?

壹、什么是大局API?

叁-1. Vue.directive 自定义指令

三-一. Vue.directive 自定义指令

大局API并不在构造器里,而是先证明全局变量或然直接在Vue上定义一些新职能,Vue内置了部分大局API,比方大家今天要上学的吩咐Vue.directive。说的简要些正是,在构造器外部用Vue提须求大家的API函数来定义新的功能。

大局API并不在构造器里,而是先评释全局变量大概直接在Vue上定义一些新效率,Vue内置了部分大局API,例如大家前日要上学的命令Vue.directive。说的简要些就是,在构造器外部用Vue提须求我们的API函数来定义新的机能。

Vue.directive用于自定义全局的一声令下

Vue.directive用于自定义全局的命令

二、Vue.directive自定义指令

二、Vue.directive自定义指令

实比如下:

实举例下:

澳门葡京 ,咱俩在第二季就学习了内部指令,大家也能够定义一些属于自身的吩咐,比方咱们要定义一个v-jspang的一声令下,效用正是让文字变成暗青。

我们在首先季就学习了里面指令,我们也得以定义一些属于自身的吩咐,比如大家要定义二个v-jspang的一声令下,功能正是让文字产生草地绿。

 1 <body>
 2     <div id="app">
 3         <p v-sq="color">{{message}}</p>
 4     </div>
 5 </body>
 6 <script>
 7     Vue.directive('sq', function (el, binding, vnode) {
 8         el.style.color = binding.value;
 9     });
10     var vm = new Vue({
11         el: "#app",
12         data: {
13             message: "前端工程师",
14             color: "red"
15         }
16     });
17 </script>
 1 <body>
 2     <div id="app">
 3         <p v-sq="color">{{message}}</p>
 4     </div>
 5 </body>
 6 <script>
 7     Vue.directive('sq', function (el, binding, vnode) {
 8         el.style.color = binding.value;
 9     });
10     var vm = new Vue({
11         el: "#app",
12         data: {
13             message: "前端工程师",
14             color: "red"
15         }
16     });
17 </script>

在自定义指令前我们写2个小作用,在页面上有2个数字为十,数字的底下有2个按键,大家每点击2遍按键后,数字加一.

在自定义指令前我们写三个小功能,在页面上有2个数字为10,数字的上面有叁个开关,大家每点击叁遍开关后,数字加一.

作用为p标签彰显为暗蓝,directive指令中的参数一(实例中的‘sq’)能够类比前篇小说内部指令的bind、on;参数贰是1个回调函数,这一个回调函数包括多个参数(el:即命令绑定的成分,实例中的el即为p成分;binding:包括指令的有关音信,能够透过console.log打字与印刷出来;vnode:即Vue编写翻译生成的杜撰节点。虚拟节点即vue二.0中引进的新职能,用js对象替代DOM节点,创新直接操作DOM代价大引发的习性难点)。

意义为p标签显示为革命,directive指令中的参数1(实例中的‘sq’)能够类比前篇小说内部指令的bind、on;参数二是贰个回调函数,这么些回调函数包括多少个参数(el:即命令绑定的成分,实例中的el即为p元素;binding:包括指令的相关音讯,能够由此console.log打字与印刷出来;vnode:即Vue编写翻译生成的虚拟节点。虚拟节点即vue二.0中引进的新功效,用js对象代替DOM节点,创新直接操作DOM代价大引发的质量难点)。

你不要紧模仿下边包车型大巴意义,在团结本地先写出这么些效果。笔者用JSRun提供了预览和代码显示效果,你也能够在线调节和测试。

您不要紧模仿下边的功用,在融洽本地先写出那么些功用。小编用JSRun提供了预览和代码显示效果,你也得以在线调试。

指令都是有生命周期的,一样地,自定义指令有五个生命周期,分别是:bind、inserted、update、componentUpdated、unbind

命令都是有生命周期的,一样地,自定义指令有四个生命周期,分别是:bind、inserted、update、componentUpdated、unbind

写好了那几个效应,大家今后就和谐定义3个大局的一声令下。大家那边运用Vue.directive(
);

写好了这些功效,我们明天就融洽定义三个大局的授命。我们那里运用Vue.directive(
);

叁-二  Vue.extend 构造器的延长

3-贰  Vue.extend 构造器的拉开

 

 

extend国语即延伸、扩充的意趣。Vue.extend重返的就是3个“扩大实例构造器,并挂载到自定义成分上。

extend汉语即延伸、扩充的乐趣。Vue.extend重返的就是叁个“扩充实例构造器,并挂载到自定义成分上。

1
2
3
Vue.directive(‘jspang’,function(el,binding,vnode){
        el.style=’color:’+binding.value;
});
1
2
3
Vue.directive(‘jspang’,function(el,binding,vnode){
        el.style=’color:’+binding.value;
});

实比如下:

实比如下:

 能够看来数字已经济体改成了紫色,表达自定义指令起到了功效。或然您看那些代码还是有些不晓得的,举例传入的七个参数到底是怎么。

 能够看看数字已经成为了铁黑,表明自定义指令起到了功能。或者您看那一个代码依旧稍微不知晓的,比方传入的七个参数到底是怎么着。

 1 <body>
 2     <div id="app">
 3       <p class="gz"></p>
 4     </div>
 5    <p class="gz"></p>
 6 </body>
 7 <script>
 8   var author=Vue.extend({
 9        template:"<a>最终解释权归作者所有</a>"
10    })
11    new author().$mount('.gz');
12 </script>
 1 <body>
 2     <div id="app">
 3       <p class="gz"></p>
 4     </div>
 5    <p class="gz"></p>
 6 </body>
 7 <script>
 8   var author=Vue.extend({
 9        template:"<a>最终解释权归作者所有</a>"
10    })
11    new author().$mount('.gz');
12 </script>

3、自定义指令中传送的多个参数

三、自定义指令中传递的多少个参数

p标签会替换来template的值,但只限于第1个p标签,因为只挂载了3遍,实例中用的是class,将其换来id或标签一样适用。

p标签会替换来template的值,但只限于第2个p标签,因为只挂载了壹回,实例中用的是class,将其换来id或标签一样适用。

el: 指令所绑定的元素,能够用来直接操作DOM。

0入门基础知识之全局API。el: 指令所绑定的成分,能够用来一贯操作DOM。

三-三 Vue.set全局操作

三-三 Vue.set全局操作

binding:  1个目的,包罗指令的众多音讯。

binding:  二个对象,包蕴指令的重重音信。

Vue.set的作用就是在构造器外部操作构造器内部的数据、属性或然措施。Vue.set存在的意思是弥补js语言的缺陷,因为Vue无法自动物检疫查实验数组的三种转移:壹.行使索引设置3个因素;二.改造数组的尺寸。用Vue.set更新数据时,依次传入八个参数壹数组名号贰索引三元素

Vue.set的效益就是在构造器外部操作构造器内部的数额、属性或然措施。Vue.set存在的意义是弥补js语言的老毛病,因为Vue不可能自动检查测试数组的二种更动:1.用到索引设置3个成分;贰.修改数组的长度。用Vue.set更新数据时,依次传入多个参数1数组称号贰索引3元素

vnode: Vue编写翻译生成的虚拟节点。

vnode: Vue编写翻译生成的虚构节点。

3-肆 Vue的生命周期

叁-四 Vue的生命周期

 

 

Vue的生命周期即钩子函数。包涵10共,遵照顺序依次为:beforeCreate、created、beforeMount、mounted、beforeUpdate、updated、activated、deactivated、beforeDastroy、destroyed。详细的构造图可参考vue官方网址的图例介绍。

Vue的生命周期即钩子函数。包蕴十共,遵照顺序依次为:beforeCreate、created、beforeMount、mounted、beforeUpdate、updated、activated、deactivated、beforeDastroy、destroyed。详细的构造图可参看vue官方网址的图例介绍。

4、自定义指令的生命周期

4、自定义指令的生命周期

3-5 Template模板

3-5 Template模板

自定义指令有七个生命周期(也叫钩子函数),分别是
bind,inserted,update,componentUpdated,unbind

自定义指令有五个生命周期(也叫钩子函数),分别是
bind,inserted,update,componentUpdated,unbind

Template模板大致有两种写法:

Template模板差不离有两种写法:

  1. bind:只调用一次,指令第叁回绑定到成分时调用,用这几个钩子函数能够定义2个绑定时进行三回的伊始化动作。
  2. inserted:被绑定成分插入父节点时调用(父节点存在就能够调用,不必存在于document中)。
  3. update:被绑定于成分所在的模版更新时调用,而无论是绑定值是不是变动。通过相比立异前后的绑定值,可以忽略不要求的沙盘更新。
  4. componentUpdated:被绑定成分所在模板完毕1次立异周期时调用。
  5. unbind:只调用二回,指令与成分解绑时调用。
  1. bind:只调用3次,指令第3回绑定到元素时调用,用这么些钩子函数可以定义2个绑按期推行一遍的先河化动作。
  2. inserted:被绑定成分插入父节点时调用(父节点存在就可以调用,不必存在于document中)。
  3. update:被绑定于成分所在的模板更新时调用,而不论是绑定值是不是变动。通过相比较革新前后的绑定值,能够忽略不须要的模版更新。
  4. componentUpdated:被绑定成分所在模板完毕三回立异周期时调用。
  5. unbind:只调用1回,指令与成分解绑时调用。

1.像样前边讲到Vue.extend挂载时的template写法,但不是双引号包罗内容,而是“(英文tab键)

一.类似前面讲到Vue.extend挂载时的template写法,但不是双引号包罗内容,而是“(英文tab键)

 

 

二.用到template模板:<template></template>。这几个近乎于Backbone中模板的写法 

二.接纳template模板:<template></template>。那一个近乎于Backbone中模板的写法 

 

 

三.在script标签中写入模板内容,不过那时type为”x-tempate”.。那种写法能够将模板从外表导入。

三.在script标签中写入模板内容,不过此时type为”x-tempate”.。那种写法可以将模板从表面导入。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
bind:function(){//被绑定
     console.log(‘1 – bind’);
},
inserted:function(){//绑定到节点
      console.log(‘2 – inserted’);
},
update:function(){//组件更新
      console.log(‘3 – update’);
},
componentUpdated:function(){//组件更新完成
      console.log(‘4 – componentUpdated’);
},
unbind:function(){//解绑
      console.log(‘1 – bind’);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
bind:function(){//被绑定
     console.log(‘1 – bind’);
},
inserted:function(){//绑定到节点
      console.log(‘2 – inserted’);
},
update:function(){//组件更新
      console.log(‘3 – update’);
},
componentUpdated:function(){//组件更新完成
      console.log(‘4 – componentUpdated’);
},
unbind:function(){//解绑
      console.log(‘1 – bind’);
}

除此以外索要重申一点、vue二.0中规定模板内容必须求要有一个根成分,一般地用div包裹住整个模板内容。

此外部需要要重申一点、vue二.0中明确模板内容必要求要有二个根成分,一般地用div包裹住整个模板内容。

 

 

3-6 component组件

3-6 component组件



component组件本质上正是自定义的竹签。component组件分为全局化注册组件和部分注册组件,两者的不相同之处在于选择的限量(类比于全局变量和有个别变量)。

component组件本质上正是自定义的标签。component组件分为全局化注册组件和有个别注册组件,两者的分歧之处在于选拔的限定(类比于全局变量和壹部分变量)。

 

 

三-陆-1 component组件的挂号

三-六-1 component组件的注册

第一节:Vue.extend构造器的延长

一、什么是Vue.extend?

Vue.extend
重回的是1个“扩张实例构造器”,也正是预设了部分选项的Vue实例构造器。经平常衣裳务于Vue.component用来变化组件,能够归纳理解为当在模板中遇见该零件名称作为标签的自定义成分时,会自动调用“扩展实例构造器”来生产零件实例,并挂载到自定义成分上。

是因为大家还一直不上学Vue的自定义组件,所以大家先看跟组件非亲非故的用途。

 

二、自定义无参数标签

咱俩想像3个供给,须求是那样的,要在博客页面多处突显小编的网名,并在网名上一向有链接地址。大家愿目的在于html中只须求写<author></author>
,那和自定义组件很像,不过她从未传递任何参数,只是个静态标签。

我们的Vue.extend该上场了,我们先用它来编排1个扩大实例构造器。代码如下:

 

 

1
2
3
4
5
6
7
8
9
var authorExtend = Vue.extend({
    template:"<p><a :href=’authorUrl’>{{authorName}}</a></p>",
    data:function(){
    return{
          authorName:’JSPang’,
          authorUrl:’http://www.jspang.com’
          }
    }
});

此时html中的标签可能不起效用的,因为扩大实例构造器是索要挂载的,大家再张开3回挂载。

 

1
new authorExtend().$mount(‘author’);

那时候大家在html写<author><author>正是管用的。我们来看一下百分百代码:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <script type="text/javascript" src="../assets/js/vue.js"></script>
    <title>vue.extend-扩展实例构造器</title>
</head>
<body>
    <h1>vue.extend-扩展实例构造器</h1>
    <hr>
    <author></author>
 
    <script type="text/javascript">
       var authorExtend = Vue.extend({
           template:"<p><a :href=’authorUrl’>{{authorName}}</a></p>",
           data:function(){
               return{
                   authorName:’JSPang’,
                   authorUrl:’http://www.jspang.com’
               }
           }
       });
       new authorExtend().$mount(‘author’);
    </script>
</body>
</html>

末段兑现结果:
叁、挂载到一般标签上

还足以因此HTML标签上的id或许class来生成扩张实例构造器,Vue.extend里的代码是同样的,只是在挂载的时候,大家用类似jquery的采取器的诀窍,来张开挂载就能够了。

 

1
new authorExtend().$mount(‘#author’);

 

 


 

第三节:Vue.extend构造器的拉开

一、什么是Vue.extend?

Vue.extend
再次回到的是1个“扩充实例构造器”,也正是预设了有个别增选的Vue实例构造器。经平常衣服务于Vue.component用来扭转组件,能够大约驾驭为当在模板中相见该零件名称作为标签的自定义成分时,会自行调用“扩大实例构造器”来生产零件实例,并挂载到自定义成分上。

是因为大家还一贯不上学Vue的自定义组件,所以我们先看跟组件非亲非故的用途。

 

二、自定义无参数标签

咱俩想像2个要求,必要是那样的,要在博客页面多处展现我的网名,并在网名上一贯有链接地址。大家希望在html中只必要写<author></author>
,那和自定义组件很像,不过她从未传递任何参数,只是个静态标签。

大家的Vue.extend该上场了,我们先用它来编排一个恢弘实例构造器。代码如下:

 

 

1
2
3
4
5
6
7
8
9
var authorExtend = Vue.extend({
    template:"<p><a :href=’authorUrl’>{{authorName}}</a></p>",
    data:function(){
    return{
          authorName:’JSPang’,
          authorUrl:’http://www.jspang.com’
          }
    }
});

那儿html中的标签也许不起效能的,因为扩充实例构造器是急需挂载的,我们再展开二遍挂载。

 

1
new authorExtend().$mount(‘author’);

此刻我们在html写<author><author>就是管用的。大家来看一下全方位代码:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <script type="text/javascript" src="../assets/js/vue.js"></script>
    <title>vue.extend-扩展实例构造器</title>
</head>
<body>
    <h1>vue.extend-扩展实例构造器</h1>
    <hr>
    <author></author>
 
    <script type="text/javascript">
       var authorExtend = Vue.extend({
           template:"<p><a :href=’authorUrl’>{{authorName}}</a></p>",
           data:function(){
               return{
                   authorName:’JSPang’,
                   authorUrl:’http://www.jspang.com’
               }
           }
       });
       new authorExtend().$mount(‘author’);
    </script>
</body>
</html>

末段兑现结果:
3、挂载到经常标签上

还足以因此HTML标签上的id或许class来生成扩大实例构造器,Vue.extend里的代码是一模同样的,只是在挂载的时候,大家用类似jquery的选拔器的章程,来拓展挂载就能够了。

 

1
new authorExtend().$mount(‘#author’);

 

 


 

一.全局化注册组件

1.全局化注册组件

第2节:Vue.set全局操作

Vue.set
的效劳正是在构造器外部操作构造器内部的多少、属性只怕措施。比方在vue构造器内部定义了一个count为一的数据,大家在构造器外部定义了1个方式,要每一遍点击按键给值加壹.就要求用到Vue.set。

一、引用构造器外部数据:

如何是外表数据,正是不在Vue构造器里里的data处证明,而是在构造器外部声明,然后在data处引用就足以了。外部数据的进入让程序更为灵活,大家能够在外表获得其余想要的多寡方式,然后让data引用。

看3个简短的代码:

 

1
2
3
4
5
6
7
8
9
10
//在构造器外部声明数据
var outData={
    count:1,
    goodName:’car’
};
var app=new Vue({
    el:’#app’,
    //引用外部数据
    data:outData
})

2、在外表改变多少的两种办法:

1、用Vue.set改变

 

1
2
3
function add(){
       Vue.set(outData,’count’,4);
}

二、用Vue对象的章程增加

 

1
app.count++;

3、直接操作外部数据

 

1
outData.count++;

实际那三种方法都能够操作外部的多少,Vue也给大家扩展了壹种操作外部数据的办法。

三、为啥要有Vue.set的存在?

出于Javascript的界定,Vue不可能自动物检疫查测试以下改造的数组。

*当您利用索引直接设置二个项时,vue不会为大家自动更新。

*当您改改数组的尺寸时,vue不会为大家自动更新。

看一段代码:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <script type="text/javascript" src="../assets/js/vue.js"></script>
    <title>Vue.set 全局操作</title>
</head>
<body>
    <h1>Vue.set 全局操作</h1>
    <hr>
    <div id="app">
        <ul>
            <li v-for=" aa in arr">{{aa}}</li>
        </ul>
      
    </div>
    <button onclick="add()">外部添加</button>
 
    <script type="text/javascript">
    
        function add(){
            console.log("我已经执行了");
           app.arr[1]=’ddd’;
           //Vue.set(app.arr,1,’ddd’);
        }
        var outData={
            arr:[‘aaa’,’bbb’,’ccc’]
        };
        var app=new Vue({
            el:’#app’,
            data:outData
        })
    </script>
</body>
</html>

那时候大家的分界面是不会自行跟新数组的,大家须要用Vue.set(app.arr,1,’ddd’)来设置改动,vue才会给大家自动更新,那便是Vue.set存在的意思。

 

 


 

第二节:Vue.set全局操作

Vue.set
的功能正是在构造器外部操作构造器内部的多寡、属性也许措施。比方在vue构造器内部定义了二个count为一的数量,我们在构造器外部定义了贰个主意,要每回点击开关给值加一.就要求用到Vue.set。

壹、引用构造器外部数据:

什么是外表数据,便是不在Vue构造器里里的data处注解,而是在构造器外部注脚,然后在data处引用就足以了。外部数据的加盟让程序越来越灵敏,我们得以在外表获得此外想要的数据格局,然后让data引用。

看三个轻松易行的代码:

 

1
2
3
4
5
6
7
8
9
10
//在构造器外部声明数据
var outData={
    count:1,
    goodName:’car’
};
var app=new Vue({
    el:’#app’,
    //引用外部数据
    data:outData
})

二、在外表改动多少的三种艺术:

1、用Vue.set改变

 

1
2
3
function add(){
       Vue.set(outData,’count’,4);
}

二、用Vue对象的艺术增添

 

1
app.count++;

3、间接操作外部数据

 

1
outData.count++;

实际上那两种办法都能够操作外部的多寡,Vue也给我们扩展了1种操作外部数据的主意。

叁、为啥要有Vue.set的留存?

是因为Javascript的限量,Vue不能够自动物检疫查测试以下退换的数组。

*当您利用索引直接设置3个项时,vue不会为大家自动更新。

*当你改改数组的尺寸时,vue不会为我们自动更新。

看1段代码:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <script type="text/javascript" src="../assets/js/vue.js"></script>
    <title>Vue.set 全局操作</title>
</head>
<body>
    <h1>Vue.set 全局操作</h1>
    <hr>
    <div id="app">
        <ul>
            <li v-for=" aa in arr">{{aa}}</li>
        </ul>
      
    </div>
    <button onclick="add()">外部添加</button>
 
    <script type="text/javascript">
    
        function add(){
            console.log("我已经执行了");
           app.arr[1]=’ddd’;
           //Vue.set(app.arr,1,’ddd’);
        }
        var outData={
            arr:[‘aaa’,’bbb’,’ccc’]
        };
        var app=new Vue({
            el:’#app’,
            data:outData
        })
    </script>
</body>
</html>

那儿我们的分界面是不会自行跟新数组的,大家须要用Vue.set(app.arr,一,’ddd’)来安装退换,vue才会给大家自动更新,那正是Vue.set存在的意思。

 

 


 

实例如下:

实举例下:

第5节:Vue的生命周期(钩子函数)

Vue1共有13个生命周期函数,我们能够运用这几个函数在vue的每一个阶段都开始展览操作数据可能改换内容。

实则在Vue的官方网址有一张图已经很好的笺注了生命周期,作者在此地就不再多讲了,间接贴图,然后上程序代码。

澳门葡京 1

 

作者们直接来看一段代码:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <script type="text/javascript" src="../assets/js/vue.js"></script>
    <title>构造器的声明周期</title>
</head>
<body>
    <h1>构造器的声明周期</h1>
    <hr>
    <div id="app">
        {{message}}
        <p><button @click="jia">加分</button></p>
    </div>
        <button onclick="app.$destroy()">销毁</button>
 
    <script type="text/javascript">
        var app=new Vue({
            el:’#app’,
            data:{
                message:1
            },
            methods:{
                jia:function(){
                    this.message ++;
                }
            },
            beforeCreate:function(){
                console.log(‘1-beforeCreate 初始化之后’);
            },
            created:function(){
                console.log(‘2-created 创建完成’);
            },
            beforeMount:function(){
                console.log(‘3-beforeMount 挂载之前’);
            },
            mounted:function(){
                console.log(‘4-mounted 被创建’);
            },
            beforeUpdate:function(){
                console.log(‘5-beforeUpdate 数据更新前’);
            },
            updated:function(){
                console.log(‘6-updated 被更新后’);
            },
            activated:function(){
                console.log(‘7-activated’);
            },
            deactivated:function(){
                console.log(‘8-deactivated’);
            },
            beforeDestroy:function(){
                console.log(‘9-beforeDestroy 销毁之前’);
            },
            destroyed:function(){
                console.log(’10-destroyed 销毁之后’)
            }
 
        })
    </script>
</body>
</html>

 


 

第六节:Vue的生命周期(钩子函数)

Vue1共有11个生命周期函数,大家能够运用那些函数在vue的每种阶段都实行操作数据或然改换内容。

实则在Vue的官方网址有一张图已经很好的表明了生命周期,作者在此间就不再多讲了,直接贴图,然后上程序代码。

澳门葡京 2

 

笔者们直接来看一段代码:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <script type="text/javascript" src="../assets/js/vue.js"></script>
    <title>构造器的声明周期</title>
</head>
<body>
    <h1>构造器的声明周期</h1>
    <hr>
    <div id="app">
        {{message}}
        <p><button @click="jia">加分</button></p>
    </div>
        <button onclick="app.$destroy()">销毁</button>
 
    <script type="text/javascript">
        var app=new Vue({
            el:’#app’,
            data:{
                message:1
            },
            methods:{
                jia:function(){
                    this.message ++;
                }
            },
            beforeCreate:function(){
                console.log(‘1-beforeCreate 初始化之后’);
            },
            created:function(){
                console.log(‘2-created 创建完成’);
            },
            beforeMount:function(){
                console.log(‘3-beforeMount 挂载之前’);
            },
            mounted:function(){
                console.log(‘4-mounted 被创建’);
            },
            beforeUpdate:function(){
                console.log(‘5-beforeUpdate 数据更新前’);
            },
            updated:function(){
                console.log(‘6-updated 被更新后’);
            },
            activated:function(){
                console.log(‘7-activated’);
            },
            deactivated:function(){
                console.log(‘8-deactivated’);
            },
            beforeDestroy:function(){
                console.log(‘9-beforeDestroy 销毁之前’);
            },
            destroyed:function(){
                console.log(’10-destroyed 销毁之后’)
            }
 
        })
    </script>
</body>
</html>

 


 

 1 <body>
 2     <div id="app">
 3         <plp></plp>
 4     </div>
 5 </body>
 6 <script>
 7     Vue.component('plp', {
 8         template: `<a>最终解释权归作者所有</a>`
 9     })
10     var vm = new Vue({
11         el: "#app"
12     })
13 </script>
 1 <body>
 2     <div id="app">
 3         <plp></plp>
 4     </div>
 5 </body>
 6 <script>
 7     Vue.component('plp', {
 8         template: `<a>最终解释权归作者所有</a>`
 9     })
10     var vm = new Vue({
11         el: "#app"
12     })
13 </script>

第伍节:Template 制作模版

第伍节:Template 制作模版

二.有的注册组件

2.局地注册组件

一、直接写在甄选里的沙盘

一向在布局器里的template选项后面编写。那种写法相比直观,可是假设模板html代码太多,不建议如此写。

javascript代码:

 

1
2
3
4
5
6
7
8
9
var app=new Vue({
     el:’#app’,
     data:{
         message:’hello Vue!’
      },
     template:`
        <h1 style="color:red">我是选项模板</h1>
     `
})

此处须要注意的是模板的标志不是单引号和双引号,而是“,正是Tab上边的键。

一、直接写在增选里的模板

直白在结构器里的template选项后面编写。那种写法相比较直观,可是只要模板html代码太多,不提出那样写。

javascript代码:

 

1
2
3
4
5
6
7
8
9
var app=new Vue({
     el:’#app’,
     data:{
         message:’hello Vue!’
      },
     template:`
        <h1 style="color:red">我是选项模板</h1>
     `
})

此间需求小心的是模板的标识不是单引号和双引号,而是“,便是Tab下面的键。

实比方下:

实举个例子下:

贰、写在<template>标签里的模版

那种写法更像是在写HTML代码,固然不会写Vue的人,也足以构建页面。

 

1
2
3
4
5
6
7
8
9
10
11
12
13
    <template id="demo2">
             <h2 style="color:red">我是template标签模板</h2>
    </template>
 
    <script type="text/javascript">
        var app=new Vue({
            el:’#app’,
            data:{
                message:’hello Vue!’
            },
            template:’#demo2′
        })
    </script>

 

贰、写在<template>标签里的模版

那种写法更像是在写HTML代码,固然不会写Vue的人,也能够创设页面。

 

1
2
3
4
5
6
7
8
9
10
11
12
13
    <template id="demo2">
             <h2 style="color:red">我是template标签模板</h2>
    </template>
 
    <script type="text/javascript">
        var app=new Vue({
            el:’#app’,
            data:{
                message:’hello Vue!’
            },
            template:’#demo2′
        })
    </script>

 

 1 <body>
 2     <div id="app">
 3         <plp></plp>
 4     </div>
 5 </body>
 6 <script>
 7     var vm = new Vue({
 8         el: "#app",
 9         components: {
10             'plp': {
11                 template: `<p>最终解释权归作者所有</p>`
12             }
13         }
14     })
15 </script>
 1 <body>
 2     <div id="app">
 3         <plp></plp>
 4     </div>
 5 </body>
 6 <script>
 7     var vm = new Vue({
 8         el: "#app",
 9         components: {
10             'plp': {
11                 template: `<p>最终解释权归作者所有</p>`
12             }
13         }
14     })
15 </script>

三、写在<script>标签里的模板

那种写模板的章程,可以让模板文件从外表引进。

 

1
2
3
4
5
6
7
8
9
10
11
12
13
    <script type="x-template" id="demo3">
        <h2 style="color:red">我是script标签模板</h2>
    </script>
 
    <script type="text/javascript">
        var app=new Vue({
            el:’#app’,
            data:{
                message:’hello Vue!’
            },
            template:’#demo3′
        })
    </script>

那节课我们学习了Template的二种写法,现在学习到vue-cli的时候还会学到壹种xxx.vue的写法。


 

三、写在<script>标签里的模版

那种写模板的秘诀,能够让模板文件从表面引进。

 

1
2
3
4
5
6
7
8
9
10
11
12
13
    <script type="x-template" id="demo3">
        <h2 style="color:red">我是script标签模板</h2>
    </script>
 
    <script type="text/javascript">
        var app=new Vue({
            el:’#app’,
            data:{
                message:’hello Vue!’
            },
            template:’#demo3′
        })
    </script>

那节课我们上学了Template的三种写法,今后学习到vue-cli的时候还会学到1种xxx.vue的写法。


 

3-6-2 component组件的props属性

3-6-2 component组件的props属性

第6节:Component 初识组件

前言(废话):component组件是Vue学习的首要、器重、珍视,主要的事务说二遍。所以您不能不学好Vue
component。其实组件正是制作自定义的竹签,那么些标签在HTML中是未曾的。比如:<jspang></jspang>,那大家就起来攻读那种技艺吧。

第伍节:Component 初识组件

序言(废话):component组件是Vue学习的最重要、重视、重视,主要的业务说一回。所以你无法不学好Vue
component。其实组件正是塑造自定义的标签,那一个标签在HTML中是向来不的。比如:<jspang></jspang>,那大家就从头学习那种工夫呢。

component组件的props属性便是用来安装和获取标签上的属性值。

component组件的props属性正是用来设置和得到标签上的属性值。

一、全局化注册组件

全局化正是在构造器的表面用Vue.component来注册,大家报了名现在就注册1个<jspang></jspang>的零部件来感受一下。

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <script type="text/javascript" src="../assets/js/vue.js"></script>
    <title>component-1</title>
</head>
<body>
    <h1>component-1</h1>
    <hr>
    <div id="app">
        <jspang></jspang>
    </div>
 
    <script type="text/javascript">
        //注册全局组件
        Vue.component(‘jspang’,{
            template:`<div style="color:red;">全局化注册的jspang标签</div>`
        })
        var app=new Vue({
            el:’#app’,
            data:{
            }
        })
    </script>
</body>
</html>

咱俩在javascript里登记了多个零件,在HTML中调用了她。那正是最简易的2个零部件的编排方法,并且它能够放置多个构造器的魔法域里。

一、全局化注册组件

全局化就是在构造器的表面用Vue.component来注册,大家报了名今后就注册3个<jspang></jspang>的零件来感受一下。

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <script type="text/javascript" src="../assets/js/vue.js"></script>
    <title>component-1</title>
</head>
<body>
    <h1>component-1</h1>
    <hr>
    <div id="app">
        <jspang></jspang>
    </div>
 
    <script type="text/javascript">
        //注册全局组件
        Vue.component(‘jspang’,{
            template:`<div style="color:red;">全局化注册的jspang标签</div>`
        })
        var app=new Vue({
            el:’#app’,
            data:{
            }
        })
    </script>
</body>
</html>

大家在javascript里登记了3个零件,在HTML中调用了她。那正是最轻便易行的三个组件的编纂方法,并且它能够放手多个构造器的效益域里。

实举例下:

实比如下:

二、局地注册组件局地注册组件和全局注册组件是向对应的,局地注册的零件只幸亏组件注册的功用域里进行应用,别的效用域使用无效。

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <script type="text/javascript" src="../assets/js/vue.js"></script>
    <title>component-1</title>
</head>
<body>
    <h1>component-1</h1>
    <hr>
    <div id="app">
      <panda></panda>
    </div>
 
    <script type="text/javascript">
        var app=new Vue({
            el:’#app’,
            components:{
                "panda":{
                    template:`<div style="color:red;">局部注册的panda标签</div>`
                }
            }
        })
    </script>
</body>
</html>

从代码中你能够观察某些注册其实就是写在构造器里,可是你供给注意的是,构造器里的components
是加s的,而全局注册是不加s的。

2、局地注册组件局地注册组件和大局注册组件是向对应的,局地注册的组件只辛亏组件注册的成效域里开展利用,其余成效域使用无效。

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <script type="text/javascript" src="../assets/js/vue.js"></script>
    <title>component-1</title>
</head>
<body>
    <h1>component-1</h1>
    <hr>
    <div id="app">
      <panda></panda>
    </div>
 
    <script type="text/javascript">
        var app=new Vue({
            el:’#app’,
            components:{
                "panda":{
                    template:`<div style="color:red;">局部注册的panda标签</div>`
                }
            }
        })
    </script>
</body>
</html>

从代码中您能够观察有些注册其实便是写在构造器里,然则你要求留意的是,构造器里的components
是加s的,而全局注册是不加s的。

 1 <body>
 2     <div id="app">
 3         <plp city="YiChang"></plp>
 4     </div>
 5 </body>
 6 <script>
 7     var vm = new Vue({
 8         el: "#app",
 9         components: {
10             'plp': {
11                 props:['city'],
12                 template: `<p>I like {{city}}</p>`
13             }
14         }
15     })
16 </script>
 1 <body>
 2     <div id="app">
 3         <plp city="YiChang"></plp>
 4     </div>
 5 </body>
 6 <script>
 7     var vm = new Vue({
 8         el: "#app",
 9         components: {
10             'plp': {
11                 props:['city'],
12                 template: `<p>I like {{city}}</p>`
13             }
14         }
15     })
16 </script>

三、组件和指令的不一致

组件注册的是2个标签,而下令注册的是已有标签里的多少个属性。在事实上开销中大家还是用组件相比多,指令用的相比少。因为指令看起来封装的没那么好,那只是个人观点。

 


 

三、组件和下令的区分

零件注册的是2个标签,而下令注册的是已有标签里的一个属性。在骨子里支付中大家照旧用组件比较多,指令用的可比少。因为指令看起来封装的没那么好,那只是个人观点。

 


 

先是component组件的props选项通过[‘city’]获得自定义标签该属性的值,然后在tepmlate中经过{{city}}插值的办法设置属性值。须要小心的一些是自定义标签的属性取值尽量幸免使用’-‘,如有须求运用小驼峰命名,能够联想到通过原生JS设置成分的颜色;elements.style.backgroundColor,而不是element.style.background-color

首先component组件的props选项通过[‘city’]得到自定义标签该属性的值,然后在tepmlate中经过{{city}}插值的点子设置属性值。要求专注的有个别是自定义标签的性质取值尽量防止使用’-‘,如有需要运用小驼峰命名,可以联想到通过原生JS设置成分的颜色;elements.style.backgroundColor,而不是element.style.background-color

第10节:Component 组件props 属性设置

props选项正是安装和得到标签上的属性值的,比如大家有一个自定义的零部件<panda></panda>,那时大家想给她加个标签属性写成<panda
here=’China’></panda>
意思正是大杜洞尕来自中中原人民共和国,当然那里的China能够换来别的值。定义属性的精选是props。

第8节:Component 组件props 属性设置

props选项正是安装和获得标签上的属性值的,举个例子我们有一个自定义的组件<panda></panda>,那时大家想给他加个标签属性写成<panda
here=’China’></panda>
意思就是大猛豹来自中夏族民共和国,当然那里的China能够换到别的值。定义属性的选项是props。

component组件传值,使用:bind绑定就可以。

component组件传值,使用:bind绑定就能够。

一、定义属性并赢得属性值

概念属性我们供给用props选项,加上数组情势的属性名称,比如:props:[‘here’]。在组件的模板里读出属性值只供给用插值的花样,举个例子{{
here }}.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <script type="text/javascript" src="../assets/js/vue.js"></script>
    <title>component-2</title>
</head>
<body>
    <h1>component-2</h1>
    <hr>
    <div id="app">
      <panda here="China"></panda>
    </div>
 
    <script type="text/javascript">
        var app=new Vue({
            el:’#app’,
            components:{
                "panda":{
                    template:`<div style="color:red;">Panda from {{ here }}.</div>`,
                    props:[‘here’]
                }
            }
        })
    </script>
</body>
</html>

地点的代码定义了panda的组件,并用props设置了here的属性值,在here属性值里传递了China给组件。

最后输出的结果是乙巳革命字体的Panda from China.

壹、定义属性并拿走属性值

概念属性我们须求用props选项,加上数组格局的习性名称,举个例子:props:[‘here’]。在组件的模板里读出属性值只必要用插值的样式,举例{{
here }}.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <script type="text/javascript" src="../assets/js/vue.js"></script>
    <title>component-2</title>
</head>
<body>
    <h1>component-2</h1>
    <hr>
    <div id="app">
      <panda here="China"></panda>
    </div>
 
    <script type="text/javascript">
        var app=new Vue({
            el:’#app’,
            components:{
                "panda":{
                    template:`<div style="color:red;">Panda from {{ here }}.</div>`,
                    props:[‘here’]
                }
            }
        })
    </script>
</body>
</html>

位置的代码定义了panda的零部件,并用props设置了here的属性值,在here属性值里传递了China给组件。

末尾输出的结果是新民主主义革命字体的Panda from China.

三-陆-三 component老爹和儿子组件

三-6-叁 component老爹和儿子组件

二、属性中带’-‘的管理情势

作者们在写属性时平日会加盟’-‘来拓展分词,例如:<panda   from-here=”China”></panda>,那那时大家在props里如果写成props:[‘form-here’]是谬误的,大家必须用小驼峰式写法props:[‘formHere’]。

html文件:

 

1
<panda from-here="China"></panda>

javascript文件:

 

1
2
3
4
5
6
7
8
9
        var app=new Vue({
            el:’#app’,
            components:{
                "panda":{
                    template:`<div style="color:red;">Panda from {{ here }}.</div>`,
                    props:[‘fromHere’]
                }
            }
        })

PS:因为此处有坑,所以依然少用-为好。

2、属性中带’-‘的管理情势

我们在写属性时日常会投入’-‘来拓展分词,举个例子:<panda   from-here=”China”></panda>,那那时大家在props里借使写成props:[‘form-here’]是漏洞百出的,大家亟须用小驼峰式写法props:[‘formHere’]。

html文件:

 

1
<panda from-here="China"></panda>

javascript文件:

 

1
2
3
4
5
6
7
8
9
        var app=new Vue({
            el:’#app’,
            components:{
                "panda":{
                    template:`<div style="color:red;">Panda from {{ here }}.</div>`,
                    props:[‘fromHere’]
                }
            }
        })

PS:因为那边有坑,所以依然少用-为好。

component老爹和儿子组件正是在多个component组件里再写1个component组件。

component父亲和儿子组件正是在3个component组件里再写二个component组件。

三、在构造器里向组件中传值

把构造器中data的值传递给组件,大家假若举办绑定就足以了。正是我们先是季学的v-bind:xxx.

大家一贯看代码:

Html文件:

 

1
<panda v-bind:here="message"></panda>

javascript文件:

 

1
2
3
4
5
6
7
8
9
10
11
12
        var app=new Vue({
            el:’#app’,
            data:{
               message:’SiChuan’
            },
            components:{
                "panda":{
                    template:`<div style="color:red;">Panda from {{ here }}.</div>`,
                    props:[‘here’]
                }
            }
        })

 

 

 


 

三、在构造器里向组件中传值

把构造器中data的值传递给组件,大家只要举行绑定就可以了。就是大家首先季学的v-bind:xxx.

小编们从来看代码:

Html文件:

 

1
<panda v-bind:here="message"></panda>

javascript文件:

 

1
2
3
4
5
6
7
8
9
10
11
12
        var app=new Vue({
            el:’#app’,
            data:{
               message:’SiChuan’
            },
            components:{
                "panda":{
                    template:`<div style="color:red;">Panda from {{ here }}.</div>`,
                    props:[‘here’]
                }
            }
        })

 

 

 


 

实比如下:

实举例下:

第十节:Component 父亲和儿子组件关系

在其实耗费中大家平常会遭逢在3个自定义组件中要选择其余自定义组件,那就供给三个父亲和儿子组件关系。

第八节:Component 老爹和儿子组件关系

在实际上付出中我们经常会遇上在三个自定义组件中要运用其余自定义组件,那就要求三个老爹和儿子组件关系。

 1 <body>
 2     <div id="app">
 3         <plp :city="like"></plp>
 4     </div>
 5 </body>
 6 <script>
 7     var vm = new Vue({
 8         el: "#app",
 9         data: {
10             like: 'YiChang'
11         },
12         components: {
13             'plp': {
14                 props: ['city'],
15                 template: `<p>I like {{city}} <ppl></ppl></p>`,
16                 components: {
17                     'ppl': {
18                         template: `very much!`
19                     }
20                 }
21             }
22         }
23     })
24 </script>
 1 <body>
 2     <div id="app">
 3         <plp :city="like"></plp>
 4     </div>
 5 </body>
 6 <script>
 7     var vm = new Vue({
 8         el: "#app",
 9         data: {
10             like: 'YiChang'
11         },
12         components: {
13             'plp': {
14                 props: ['city'],
15                 template: `<p>I like {{city}} <ppl></ppl></p>`,
16                 components: {
17                     'ppl': {
18                         template: `very much!`
19                     }
20                 }
21             }
22         }
23     })
24 </script>

1、构造器外部写一些注册组件

地方上课我们都把一些组件的编排泄到了构造器内部,借使组件代码量非常的大,会影响构造器的可读性,形成拖拉和不当。

大家把组件编写的代码放到构造器外部或然说单独文件。

咱俩需求先声美赞臣个目的,对象里正是组件的始末。

 

1
2
3
var jspang = {
   template:`<div>Panda from China!</div>`
}

宣示好对象后在布局器里引用就足以了。

 

1
2
3
components:{
    "jspang":jspang
}

html中引用

 

1
<jspang></jspang>

 

一、构造器外部写一些注册组件

上边上课我们都把有个别组件的编排泄到了构造器内部,假诺组件代码量不小,会影响构造器的可读性,变成拖拉和不当。

我们把组件编写的代码放到构造器外部可能说单独文件。

我们要求先声明一(Wissu)(Beingmate)个目的,对象里便是组件的始末。

 

1
2
3
var jspang = {
   template:`<div>Panda from China!</div>`
}

声称好对象后在结构器里引用就足以了。

 

1
2
3
components:{
    "jspang":jspang
}

html中引用

 

1
<jspang></jspang>

 

实例中涉及到component组件嵌套,在plp组件中嵌套组件ppl。当然实际支付中组件的嵌套远比那几个复杂,须求的时候能够在构造器外部定义评释局地component组件。

实例中提到到component组件嵌套,在plp组件中嵌套组件ppl。当然实际付出中组件的嵌套远比那些纷纷,要求的时候能够在构造器外部定义注解局地component组件。

二、父子组件的嵌套

咱俩先声惠氏个父组件,比方叫jspang,然后中间大家到场贰个city组件,大家来看这么的代码怎么样写。

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <script type="text/javascript" src="../assets/js/vue.js"></script>
    <title>component-3</title>
</head>
<body>
    <h1>component-3</h1>
    <hr>
    <div id="app">
      <jspang></jspang>  
    </div>
    <script type="text/javascript">
       var city={
           template:`<div>Sichuan of China</div>`
       }
        var jspang = {
            template:`<div>
                    <p> Panda from China!</p>
                    <city></city>
            </div>`,
            components:{
                "city":city
            }
        }
        var app=new Vue({
            el:’#app’,
            components:{
                "jspang":jspang
            }
          
        })
    </script>
</body>
</html>

 

 


 

二、父亲和儿子组件的嵌套

我们先声Bellamy(Bellamy)个父组件,比方叫jspang,然后里面我们进入八个city组件,大家来看这么的代码怎样写。

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <script type="text/javascript" src="../assets/js/vue.js"></script>
    <title>component-3</title>
</head>
<body>
    <h1>component-3</h1>
    <hr>
    <div id="app">
      <jspang></jspang>  
    </div>
    <script type="text/javascript">
       var city={
           template:`<div>Sichuan of China</div>`
       }
        var jspang = {
            template:`<div>
                    <p> Panda from China!</p>
                    <city></city>
            </div>`,
            components:{
                "city":city
            }
        }
        var app=new Vue({
            el:’#app’,
            components:{
                "jspang":jspang
            }
          
        })
    </script>
</body>
</html>

 

 


 

3-6-4 component标签

3-6-4 component标签

第9节:Component 标签

<component></component>标签是Vue框架自定义的价签,它的用途就是足以动态绑定大家的组件,依据数量的例外更动不一致的零部件。

1.大家先在构造器外部定义四个不一样的组件,分别是componentA,componentB和componentC.

 

1
2
3
4
5
6
7
8
9
var componentA={
     template:`<div>I’m componentA</div>`
}
var componentB={
      template:`<div>I’m componentB</div>`
}
var componentC={
    template:`<div>I’m componentC</div>`
}

二.我们在构造器的components选项里进入那八个零件。

 

1
2
3
4
5
components:{
    "componentA":componentA,
    "componentB":componentB,
    "componentC":componentC,
}

三.大家在html里插入component标签,并绑定who数据,依据who的值不一样,调用差别的零部件。

 

1
<component v-bind:is="who"></component>

那正是大家的组件标签的核心用法。大家抓牢以下,给页面加个开关,每点以下更动一个零部件。

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <script type="text/javascript" src="../assets/js/vue.js"></script>
    <title>component-4</title>
</head>
<body>
    <h1>component-4</h1>
    <hr>
    <div id="app">
       <component v-bind:is="who"></component>
       <button @click="changeComponent">changeComponent</button>
    </div>
 
    <script type="text/javascript">
        var componentA={
            template:`<div style="color:red;">I’m componentA</div>`
        }
        var componentB={
            template:`<div style="color:green;">I’m componentB</div>`
        }
        var componentC={
            template:`<div style="color:pink;">I’m componentC</div>`
        }
      
        var app=new Vue({
            el:’#app’,
            data:{
                who:’componentA’
            },
            components:{
                "componentA":componentA,
                "componentB":componentB,
                "componentC":componentC,
            },
            methods:{
                changeComponent:function(){
                    if(this.who==’componentA’){
                        this.who=’componentB’;
                    }else if(this.who==’componentB’){
                        this.who=’componentC’;
                    }else{
                        this.who=’componentA’;
                    }
                }
            }
        })
    </script>
</body>
</html>

第9节:Component 标签

<component></component>标签是Vue框架自定义的价签,它的用途就是足以动态绑定大家的组件,根据数量的不等更动区别的零部件。

一.咱们先在构造器外部定义八个不一样的组件,分别是componentA,componentB和componentC.

 

1
2
3
4
5
6
7
8
9
var componentA={
     template:`<div>I’m componentA</div>`
}
var componentB={
      template:`<div>I’m componentB</div>`
}
var componentC={
    template:`<div>I’m componentC</div>`
}

二.我们在构造器的components选项里进入那多少个零件。

 

1
2
3
4
5
components:{
    "componentA":componentA,
    "componentB":componentB,
    "componentC":componentC,
}

叁.我们在html里插入component标签,并绑定who数据,依据who的值不一致,调用不一样的零部件。

 

1
<component v-bind:is="who"></component>

那正是我们的组件标签的宗旨用法。大家坚实以下,给页面加个按键,每点以下更动2个零部件。

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <script type="text/javascript" src="../assets/js/vue.js"></script>
    <title>component-4</title>
</head>
<body>
    <h1>component-4</h1>
    <hr>
    <div id="app">
       <component v-bind:is="who"></component>
       <button @click="changeComponent">changeComponent</button>
    </div>
 
    <script type="text/javascript">
        var componentA={
            template:`<div style="color:red;">I’m componentA</div>`
        }
        var componentB={
            template:`<div style="color:green;">I’m componentB</div>`
        }
        var componentC={
            template:`<div style="color:pink;">I’m componentC</div>`
        }
      
        var app=new Vue({
            el:’#app’,
            data:{
                who:’componentA’
            },
            components:{
                "componentA":componentA,
                "componentB":componentB,
                "componentC":componentC,
            },
            methods:{
                changeComponent:function(){
                    if(this.who==’componentA’){
                        this.who=’componentB’;
                    }else if(this.who==’componentB’){
                        this.who=’componentC’;
                    }else{
                        this.who=’componentA’;
                    }
                }
            }
        })
    </script>
</body>
</html>

<component></component>标签是Vue框架自定义的价签,它的用途正是足以动态绑定我们的组件,依照数量的比不上退换分歧的零部件。

<component></component>标签是Vue框架自定义的竹签,它的用处就是能够动态绑定大家的零件,依照数据的例外更动分歧的组件。

好啊,关于Vue的大局API就介绍到此地,下一篇关于Vue的基础知识,我们聊聊Vue二.0的选项以及实例内置组件~

好啊,关于Vue的大局API就介绍到此处,下壹篇关于Vue的基础知识,我们聊聊Vue二.0的选项以及实例内置组件~

相关文章

发表评论

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

*
*
Website