1. 复习组件化编程

1.1 模块与组件、模块化与组件化

  1. 模块
  • 理解：向外提供特定功能的 js 程序，一般就是一个 js 文件
  • 为什么：js 文件很多很复杂
  • 作用：复用、简化 js 的编写，提高 js 运行效率
  1. 组件
  • 定义：用来实现局部功能的代码和资源的集合（html/css/js/image…）
  • 为什么：一个界面的功能很复杂
  • 作用：复用编码，简化项目编码，提高运行效率

  1. 模块化

    当应用中的 js 都以模块来编写的，那这个应用就是一个模块化的应用

  2. 组件化

    当应用中的功能都是多组件的方式来编写的，那这个应用就是一个组件化的应用

2. 非单文件组件

非单文件组件：一个文件中包含有 n 个组件
单文件组件：一个文件中只包含有 1 个组件

1. 基本使用

Vue中使用组件的三大步骤

一. 定义组件

使用Vue.extend(options)创建，其中options和new Vue(options)时传入的options几乎一样，但也有点区别

  • el不要写，因为最终所有的组件都要经过一个vm的管理，由vm中的el才决定服务哪个容器
  • data必须写成函数，避免组件被复用时，数据存在引用关系
    备注：使用template可以配置组件结构。

二. 注册组件

  • 局部注册：new Vue()的时候options传入components选项
  • 全局注册：Vue.component('组件名',组件)

    注意：组件名必须是多个单词组成，且每个单词都是小写字母开头，且多个单词之间用-连接

三. 使用组件
编写组件标签如 <school></school> 

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
<!DOCTYPE html>
<html>
 <head>
  <meta charset="UTF-8" />
  <title>基本使用</title>
  <script type="text/javascript" src="../js/vue.js"></script>
 </head>
 <body>
  <!-- 准备好一个容器-->
  <div id="root">
   <hello></hello>
   <hr>
   <h1>{{msg}}</h1>
   <hr>
   <!-- 第三步：编写组件标签 -->
   <school></school>
   <hr>
   <!-- 第三步：编写组件标签 -->
   <student></student>
  </div>

  <div id="root2">
   <hello></hello>
  </div>
 </body>

 <script type="text/javascript">
  Vue.config.productionTip = false

  //第一步：创建school组件
  const school = Vue.extend({
   template:`
    <div class="demo">
     <h2>学校名称：{{schoolName}}</h2>
     <h2>学校地址：{{address}}</h2>
     <button @click="showName">点我提示学校名</button> 
    </div>
   `,
   // el:'#root', //组件定义时，一定不要写el配置项，因为最终所有的组件都要被一个vm管理，由vm决定服务于哪个容器。
   data(){
    return {
     schoolName:'尚硅谷',
     address:'北京昌平'
    }
   },
   methods: {
    showName(){
     alert(this.schoolName)
    }
   },
  })

  //第一步：创建student组件
  const student = Vue.extend({
   template:`
    <div>
     <h2>学生姓名：{{studentName}}</h2>
     <h2>学生年龄：{{age}}</h2>
    </div>
   `,
   data(){
    return {
     studentName:'张三',
     age:18
    }
   }
  })
  
  //第一步：创建hello组件
  const hello = Vue.extend({
   template:`
    <div> 
     <h2>你好啊！{{name}}</h2>
    </div>
   `,
   data(){
    return {
     name:'Tom'
    }
   }
  })
  
  //第二步：全局注册组件
  Vue.component('hello',hello)

  //创建vm
  new Vue({
   el:'#root',
   data:{
    msg:'你好啊！'
   },
   //第二步：注册组件（局部注册）
   components:{
    school,
    student
   }
  })

  new Vue({
   el:'#root2',
  })
 </script>
</html>

3. 很重要的点

3.1 关于组件名:

  1. 一个单词组成：
  • 第一种写法(首字母小写)：school
  • 第二种写法(首字母大写)：School
  1. 多个单词组成：
  • 第一种写法(kebab-case命名)：my-school
  • 第二种写法(CamelCase命名)：MySchool (需要Vue脚手架支持)
    备注：
    (1).组件名尽可能回避HTML中已有的元素名称，例如：h2、H2都不行。
    (2).可以使用name配置项指定组件在开发者工具中呈现的名字。
  1. 关于组件标签:
  • 第一种写法：<school></school>
  • 第二种写法：<school/>
    备注：不用使用脚手架时，<school/>会导致后续组件不能渲染。
  1. 一个简写方式：
    const school = Vue.extend(options) 可简写为：const school = options
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
<!DOCTYPE html>
<html>
 <head>
  <meta charset="UTF-8" />
  <title>几个注意点</title>
  <script type="text/javascript" src="../js/vue.js"></script>
 </head>
 <body>
  <!-- 准备好一个容器-->
  <div id="root">
   <h1>{{msg}}</h1>
   <school></school>
  </div>
 </body>

 <script type="text/javascript">
  Vue.config.productionTip = false
  
  //定义组件
  const s = Vue.extend({
   name:'atguigu',
   template:`
    <div>
     <h2>学校名称：{{name}}</h2> 
     <h2>学校地址：{{address}}</h2> 
    </div>
   `,
   data(){
    return {
     name:'尚硅谷',
     address:'北京'
    }
   }
  })

  new Vue({
   el:'#root',
   data:{
    msg:'欢迎学习Vue!'
   },
   components:{
    school:s
   }
  })
 </script>
</html>

4. 组件的嵌套

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
<!DOCTYPE html>
<html>
 <head>
  <meta charset="UTF-8" />
  <title>组件的嵌套</title>
  <!-- 引入Vue -->
  <script type="text/javascript" src="../js/vue.js"></script>
 </head>
 <body>
  <!-- 准备好一个容器-->
  <div id="root">
   
  </div>
 </body>

 <script type="text/javascript">
  Vue.config.productionTip = false //阻止 vue 在启动时生成生产提示。

  //定义student组件
  const student = Vue.extend({
   name:'student',
   template:`
    <div>
     <h2>学生姓名：{{name}}</h2> 
     <h2>学生年龄：{{age}}</h2> 
    </div>
   `,
   data(){
    return {
     name:'尚硅谷',
     age:18
    }
   }
  })
  
  //定义school组件
  const school = Vue.extend({
   name:'school',
   template:`
    <div>
     <h2>学校名称：{{name}}</h2> 
     <h2>学校地址：{{address}}</h2> 
     <student></student>
    </div>
   `,
   data(){
    return {
     name:'尚硅谷',
     address:'北京'
    }
   },
   //注册组件（局部）
   components:{
    student
   }
  })

  //定义hello组件
  const hello = Vue.extend({
   template:`<h1>{{msg}}</h1>`,
   data(){
    return {
     msg:'欢迎来到尚硅谷学习！'
    }
   }
  })
  
  //定义app组件
  const app = Vue.extend({
   template:`
    <div> 
     <hello></hello>
     <school></school>
    </div>
   `,
   components:{
    school,
    hello
   }
  })

  //创建vm
  new Vue({
   template:'<app></app>',
   el:'#root',
   //注册组件（局部）
   components:{app}
  })
 </script>
</html>

5.VueComponent

  1. school组件本质是一个名为VueComponent的构造函数，且不是程序员定义的，是Vue.extend生成的。
  2. 我们只需要写<school/>或<school></school>，Vue解析时会帮我们创建school组件的实例对象，
    即Vue帮我们执行的：new VueComponent(options)。
  3. 特别注意：每次调用Vue.extend，返回的都是一个全新的VueComponent！！！！
  4. 关于this指向：
    (1).组件配置中：
    data函数、methods中的函数、watch中的函数、computed中的函数 它们的this均是【VueComponent实例对象】。
    (2).new Vue(options)配置中：
    data函数、methods中的函数、watch中的函数、computed中的函数 它们的this均是【Vue实例对象】。
    5.VueComponent的实例对象，以后简称vc（也可称之为：组件实例对象）。
    Vue的实例对象，以后简称vm。
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
63
64
65
66
67
68
69
70
71
72
<!DOCTYPE html>
<html>
 <head>
  <meta charset="UTF-8" />
  <title>VueComponent</title>
  <script type="text/javascript" src="../js/vue.js"></script>
 </head>
 <body>
  <!-- 准备好一个容器-->
  <div id="root">
   <school></school>
   <hello></hello>
  </div>
 </body>

 <script type="text/javascript">
  Vue.config.productionTip = false
  
  //定义school组件
  const school = Vue.extend({
   name:'school',
   template:`
    <div>
     <h2>学校名称：{{name}}</h2> 
     <h2>学校地址：{{address}}</h2> 
     <button @click="showName">点我提示学校名</button>
    </div>
   `,
   data(){
    return {
     name:'尚硅谷',
     address:'北京'
    }
   },
   methods: {
    showName(){
     console.log('showName',this)
    }
   },
  })

  const test = Vue.extend({
   template:`<span>atguigu</span>`
  })

  //定义hello组件
  const hello = Vue.extend({
   template:`
    <div>
     <h2>{{msg}}</h2>
     <test></test> 
    </div>
   `,
   data(){
    return {
     msg:'你好啊！'
    }
   },
   components:{test}
  })


  // console.log('@',school)
  // console.log('#',hello)

  //创建vm
  const vm = new Vue({
   el:'#root',
   components:{school,hello}
  })
 </script>
</html>

6. 一个重要的内置关系

1.一个重要的内置关系：VueComponent.prototype.__proto__ === Vue.prototype
2.为什么要有这个关系：让组件实例对象（vc）可以访问到 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
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
63
64
65
66
67
68
69
70
71
72
73
<!DOCTYPE html>
<html>
 <head>
  <meta charset="UTF-8" />
  <title>一个重要的内置关系</title>
  <!-- 引入Vue -->
  <script type="text/javascript" src="../js/vue.js"></script>
 </head>
 <body>
  <!-- 准备好一个容器-->
  <div id="root">
   <school></school>
  </div>
 </body>

 <script type="text/javascript">
  Vue.config.productionTip = false //阻止 vue 在启动时生成生产提示。
  Vue.prototype.x = 99

  //定义school组件
  const school = Vue.extend({
   name:'school',
   template:`
    <div>
     <h2>学校名称：{{name}}</h2> 
     <h2>学校地址：{{address}}</h2> 
     <button @click="showX">点我输出x</button>
    </div>
   `,
   data(){
    return {
     name:'尚硅谷',
     address:'北京'
    }
   },
   methods: {
    showX(){
     console.log(this.x)
    }
   },
  })

  //创建一个vm
  const vm = new Vue({
   el:'#root',
   data:{
    msg:'你好'
   },
   components:{school}
  })

  
  //定义一个构造函数
  /* function Demo(){
   this.a = 1
   this.b = 2
  }
  //创建一个Demo的实例对象
  const d = new Demo()

  console.log(Demo.prototype) //显示原型属性

  console.log(d.__proto__) //隐式原型属性

  console.log(Demo.prototype === d.__proto__)

  //程序员通过显示原型属性操作原型对象，追加一个x属性，值为99
  Demo.prototype.x = 99

  console.log('@',d) */

 </script>
</html>