3 Vue组件化

3.1 什么是组件

  1. 传统方式开发的应用

一个网页通常包括三部分：结构（HTML）、样式（CSS）、交互（JavaScript）

动力节点Vue笔记—— ③Vue组件化_前端框架

传统应用存在的问题：

  1. 关系纵横交织，复杂，牵一发动全身，不利于维护。
  2. 代码虽然复用，但复用率不高。
  3. 组件化方式开发的应用

动力节点Vue笔记—— ③Vue组件化_前端_02

使用组件化方式开发解决了以上的两个问题：

  1. 每一个组件都有独立的js，独立的css，这些独立的js和css只供当前组件使用，不存在纵横交错。更加便于维护。
  2. 代码复用性增强。组件不仅让js css复用了，HTML代码片段也复用了（因为要使用组件直接引入组件即可）。
  3. 什么是组件？
  1. 组件：实现应用中局部功能的代码和资源的集合。凡是采用组件方式开发的应用都可以称为组件化应用。
  2. 模块：一个大的js文件按照模块化拆分规则进行拆分，生成多个js文件，每一个js文件叫做模块。凡是采用模块方式开发的应用都可以称为模块化应用。
  3. 任何一个组件中都可以包含这些资源：HTML CSS JS 图片 声音 视频等。从这个角度也可以说明组件是可以包括模块的。
  1. 组件的划分粒度很重要，粒度太粗会影响复用性。为了让复用性更强，Vue的组件也支持父子组件嵌套使用。

动力节点Vue笔记—— ③Vue组件化_Vue_03

子组件由父组件来管理，父组件由父组件的父组件管理。在Vue中根组件就是vm。因此每一个组件也是一个Vue实例。

3.2组件的创建、注册和使用

1. <!DOCTYPE html>  
2. <html lang="en">  
3. <head>  
4.     <meta charset="UTF-8">  
5.     <title>组件的创建注册和使用</title>  
6.     <script src="../js/vue.js"></script>  
7. </head>  
8. <body>  
9.     <div id="app">  
10.         <h1>{{msg}}</h1>  
11.         <!-- 3.使用组件 -->  
12.         <userlist></userlist>  
13.         <userlist></userlist>  
14.         <userlogin></userlogin>  
15.         <userlogin></userlogin>  
16.     </div>  
17.     <script>  
18.         // 1.创建组件  
19.         const userListComponent = Vue.extend({  
20.             template : `  
21.                 <ul>  
22.                     <li v-for="(user,index) of users" :key="user.id">  
23.                         {{index}},{{user.name}}  
24.                     </li>  
25.                 </ul>      
26.             `,  
27.             data(){  
28.                 return {  
29.                     users : [  
30.                         {id:'001', name:'jack'},  
31.                         {id:'002', name:'lucy'},  
32.                         {id:'003', name:'james'}  
33.                     ]  
34.                 }  
35.             }  
36.         })  
37.   
38.         // 1.创建组件  
39.         const userLoginComponent = Vue.extend({  
40.             template : `  
41.             <div>  
42.             <h3>用户登录</h3>  
43.             <form @submit.prevent="login">  
44.             账号：<input type="text" v-model="username"><br><br>  
45.             密码：<input type="password" v-model="password"><br><br>  
46.             <button>登录</button>  
47.             </form>  
48.             </div>  
49.             `,  
50.             data(){  
51.                 return {  
52.                     username : 'admin',  
53.                     password : '123'  
54.                 }  
55.             },  
56.             methods : {  
57.                 login(){  
58.                     alert(this.username + "," + this.password)  
59.                 }  
60.             }  
61.         })  
62.   
63.         const vm = new Vue({  
64.             el : '#app',  
65.             data : {  
66.                 msg : '组件的创建注册和使用'  
67.             },  
68.             // 2.注册组件（局部注册）  
69.             components : {  
70.                 // userlist 就是组件的名字  
71.                 userlist : userListComponent,  
72.                 userlogin : userLoginComponent  
73.             }  
74.         })  
75.     </script>  
76. </body>  
77. </html>
  1. 创建组件
  1. const userComponent = Vue.extend({这个配置项和创建Vue实例的配置项几乎是一样的，只是略有差异})
  2. 需要注意的是：
  1. el不能用。组件具有通用性，不特定为某个容器服务，它为所有容器服务。
  2. data必须使用函数形式：return {}
  3. 使用template配置项配置页面结构：HTML。
  1. 注册组件
  1. 局部注册
  1. 使用components配置项：components : {user : userComponent}，user就是组件名。
  1. 全局注册
  1. Vue.component(‘user’, userComponent)
  1. 使用组件
  1. 直接在页面需要使用组件的位置：
  2. 也可以这样使用： （不在脚手架环境中使用这种方式会出现后续元素不渲染的问题。）
  1. 创建组件对象也有简写形式：Vue.extend() 可以省略。直接写：{}
  2. 组件的命名细节：
  1. 全部小写
  2. 首字母大写，后面全部小写
  3. kebab-case串式命名法
  4. CamelCase驼峰式命名法（这种方式需要在脚手架环境中使用）
  5. 不要使用HTML内置的标签作为组件名称。
  6. 可以使用name配置项来指定Vue开发者工具中显示的组件名。

3.3 组件嵌套

1.<!DOCTYPE html>  
2.<html lang="en">  
3.<head>  
4.    <meta charset="UTF-8">  
5.    <title>组件嵌套</title>  
6.    <script src="../js/vue.js"></script>  
7.</head>  
8.<body>  
9.    <div id="root"></div>  
10.    <script>  
11.        // 创建Y1组件  
12.        const y1 = {  
13.            template : `  
14.                <div>  
15.                    <h3>Y1组件</h3>  
16.                </div>  
17.            `  
18.        }  
19.        // 创建X1组件  
20.        const x1 = {  
21.            template : `  
22.                <div>  
23.                    <h3>X1组件</h3>  
24.                </div>  
25.            `  
26.        }  
27.        // 创建Y组件  
28.        const y = {  
29.            template : `  
30.                <div>  
31.                    <h2>Y组件</h2>  
32.                    <y1></y1>  
33.                </div>  
34.            `,  
35.            components : {y1}  
36.        }  
37.        // 创建X组件  
38.        const x = {  
39.            template : `  
40.                <div>  
41.                    <h2>X组件</h2>  
42.                    <x1></x1>  
43.                </div>  
44.            `,  
45.            components : {x1}  
46.        }  
47.        // 创建app组件  
48.        const app = {  
49.            template : `  
50.                <div>  
51.                    <h1>App组件</h1>  
52.                    <x></x>  
53.                    <y></y>  
54.                </div>  
55.            `,  
56.            // 注册X组件  
57.            components : {x,y}  
58.        }  
59.        // vm  
60.        const vm = new Vue({  
61.            el : '#root',  
62.            template : `  
63.                <app></app>  
64.            `,  
65.            // 注册app组件  
66.            components : {app}  
67.        })  
68.    </script>  
69.</body>  
70.</html>

嵌套结构：这种结构更加贴切实际项目的开发

动力节点Vue笔记—— ③Vue组件化_Vue_04

3.4 VueComponent & Vue

3.4.1 this

new Vue({})配置项中的this和Vue.extend({})配置项中的this他们分别是谁？

1.<!DOCTYPE html>  
2.<html lang="en">  
3.<head>  
4.    <meta charset="UTF-8">  
5.    <title>vm与vc</title>  
6.    <script src="../js/vue.js"></script>  
7.</head>  
8.<body>  
9.    <div id="app">  
10.        <mc></mc>  
11.    </div>  
12.    <script>  
13.        const myComponent = Vue.extend({  
14.            template : `<h1></h1>`,  
15.            mounted(){  
16.                console.log('vc', this)  
17.            }  
18.        })  
19.  
20.        const vm = new Vue({  
21.            el : '#app',  
22.            components : {  
23.                mc : myComponent  
24.            },  
25.            mounted() {  
26.                console.log('vm', this)  
27.            },  
28.        })  
29.    </script>  
30.</body>  
31.</html>

测试结果：

动力节点Vue笔记—— ③Vue组件化_前端框架_05

new Vue({})配置项中的this就是：Vue实例（vm）。Vue.extend({})配置项中的this就是：VueComponent实例（vc）。打开vm和vc你会发现，它们拥有大量相同的属性。例如：生命周期钩子、methods、watch等。

3.4.2 vm === vc ???

只能说差不多一样，不是完全相等。例如：vm上有el，vc上没有。另外data也是不一样的。vc的data必须是一个函数。只能这么说：vm上有的vc上不一定有，vc上有的vm上一定有。

3.4.3 Vue.extend()方法做了什么？

每一次的extend调用返回的都是一个全新的VueComponent函数。以下是Vue.extend()的源码：

动力节点Vue笔记—— ③Vue组件化_前端框架_06

动力节点Vue笔记—— ③Vue组件化_vue.js_07

注意：是每一次都会返回一个全新的VueComponent构造函数。是全新的！！！

构造函数有了，什么时候会调用构造函数来实例化VueComponent对象呢？

动力节点Vue笔记—— ③Vue组件化_html_08

Vue在解析****时会创建一个VueComponent实例，也就是：new VueComponent()

3.4.4 通过vc可以访问Vue原型对象上的属性

通过vc可以访问Vue原型对象上的属性：

  1. Vue.prototype.counter = 100
  2. console.log(vc.counter) // 100

为什么要这么设计？代码复用。Vue原型对象上有很多方法，例如：动力节点Vue笔记—— ③Vue组件化_Vue_09mount()，代码得到了复用。Vue框架是如何实现以上机制的呢？

  1. VueComponent.prototype.proto = Vue.prototype

测试：

1.<!DOCTYPE html>  
2.<html lang="en">  
3.<head>  
4.    <meta charset="UTF-8">  
5.    <title>测试</title>  
6.    <script src="../js/vue.js"></script>  
7.</head>  
8.<body>  
9.    <div id="app"></div>  
10.    <script>  
11.        const userlist = Vue.extend({  
12.            template : `<div><h1>用户列表</h1></div>`,  
13.        })  
14.        const vm = new Vue({  
15.            el : '#app',  
16.            template : `<userlist></userlist>`,  
17.            components : {userlist}  
18.        })  
19.        console.log(userlist.prototype.__proto__ === Vue.prototype) // true  
20.    </script>  
21.</body>  
22.</html>
3.4.4.1 回顾原型对象

prototype称为：显示的原型属性，用法：函数.prototype，例如：Vue.prototype

proto__称为：隐式的原型属性，用户：实例.proto，例如：vm.proto 无论是通过prototype还是__proto，获取的对象都是同一个，它是一个共享的对象，称为：XX的原型对象。如果通过Vue.prototype获取的对象就叫做：Vue的原型对象。如果通过User.prototype获取的对象就叫做：User的原型对象。请看下图：

动力节点Vue笔记—— ③Vue组件化_vue.js_10

3.4.4.2 原理剖析

VueComponent.prototype.proto = Vue.prototype

动力节点Vue笔记—— ③Vue组件化_前端框架_11

这样做的话，最终的结果就是：Vue、vm、VueComponent、vc都共享了Vue的原型对象（并且这个Vue的原型对象只有一个）。

3.5 单文件组件

  1. 什么是单文件组件？
  1. 一个文件对应一个组件（之前我们所学的是非单文件组件，一个html文件中定义了多个组件）
  2. 单文件组件的名字通常是：x.vue，这是Vue框架规定的，只有Vue框架能够认识，浏览器无法直接打开运行。需要Vue框架进行编译，将x.vue最终编译为浏览器能识别的html js css。
  3. 单文件组件的文件名命名规范和组件名的命名规范相同：
  1. 全部小写：userlist
  2. 首字母大写，后面全部小写：Userlist
  3. kebab-case命名法：user-list
  4. CamelCase命名法：UserList（我们使用这种方式，和Vue开发者工具呼应。）
  1. x.vue文件的内容包括三块：
  1. 结构：
  2. 交互：
  3. 样式：
  1. export和import，ES6的模块化语法。
  1. 使用export导出（暴露）组件，在需要使用组件的x.vue文件中使用import导入组件
  1. 默认导入和导出
  1. export default {}
  2. import 任意名称 from ‘模块标识符’
  1. 按需导入和导出
  1. export {a, b}
  2. import {a, b} from ‘模块标识符’
  1. 分别导出

export var name = ‘zhangsan’export function sayHi(){}

  1. VSCode工具可以安装一些插件，这样在编写x.vue的时候有提示。例如：vetur插件。
  1. 使用该插件之后，有高亮显示，并且也可以通过输入 <v 生成代码。
  1. 把之前“组件嵌套”的例子修改为单文件组件

动力节点Vue笔记—— ③Vue组件化_前端框架_12

动力节点Vue笔记—— ③Vue组件化_前端框架_13

auto rename tag插件

动力节点Vue笔记—— ③Vue组件化_html_14

动力节点Vue笔记—— ③Vue组件化_Vue_15

动力节点Vue笔记—— ③Vue组件化_前端_16

记住一个要领：不管是单文件组件还是非单文件组件，永远都包括三步：创建组件、注册组件、使用组件。 创建vm的代码就不是一个组件了，这个js代码写到一个js文件中即可，一般这个起名：main.js。寓意：入口

动力节点Vue笔记—— ③Vue组件化_html_17

还剩最后的一点HTML代码，一般这个文件叫做index.html，代码如下：

动力节点Vue笔记—— ③Vue组件化_前端_18

如上图，注意引入顺序。 代码执行原理：

  1. 第一步：浏览器打开index.html页面，加载容器
  2. 第二步：加载vue.js文件，有了Vue
  3. 第三步：加载main.js
  1. import App from ‘./App.vue’
  2. import X from './X.vue'
  3. import X1 from './X1.vue'
  4. import Y from './Y.vue'
  5. import Y1 from './Y1.vue'

这样就完成了所有组件以及子组件的创建和注册。

  1. 第四步：创建Vue实例vm，编译模板语句，渲染。

写完之后不能直接运行，浏览器不认识.vue文件，不认识ES6的模块化语法。需要安装Vue脚手架。

3.6 Vue脚手架

3.6.1 确保npm能用（安装Node.js）

Node.js的下载地址:https://nodejs.org/zh-cn/download/

动力节点Vue笔记—— ③Vue组件化_前端框架_19

动力节点Vue笔记—— ③Vue组件化_html_20

安装步骤如下：

动力节点Vue笔记—— ③Vue组件化_html_21

动力节点Vue笔记—— ③Vue组件化_html_22

动力节点Vue笔记—— ③Vue组件化_html_23

动力节点Vue笔记—— ③Vue组件化_Vue_24

动力节点Vue笔记—— ③Vue组件化_vue.js_25

动力节点Vue笔记—— ③Vue组件化_前端_26

动力节点Vue笔记—— ③Vue组件化_前端框架_27

动力节点Vue笔记—— ③Vue组件化_前端框架_28

动力节点Vue笔记—— ③Vue组件化_Vue_29

打开dos命令窗口，输入npm命令。

动力节点Vue笔记—— ③Vue组件化_前端_30

3.6.2 Vue CLI（脚手架安装）

  1. Vue的脚手架（Vue CLI: Command Line Interface）是Vue官方提供的标准化开发平台。它可以将我们.vue的代码进行编译生成html css js代码，并且可以将这些代码自动发布到它自带的服务器上，为我们Vue的开发提供了一条龙服务。脚手架官网地址：https://cli.vuejs.org/zh

注意：Vue CLI 4.x需要Node.js v8.9及以上版本，推荐v10以上。

  1. 脚手架安装步骤：
  2. 建议先配置一下npm镜像：
  1. npm config set registry https://registry.npm.taobao.org
  2. npm config get registry 返回成功，表示设置成功
  1. 第一步：安装脚手架（全局方式：表示只需要做一次即可）
  1. npm install -g @vue/cli
  2. 安装完成后，重新打开DOS命令窗口，输入vue命令可用表示成功了
  1. 第二步：创建项目（项目中自带脚手架环境，自带一个HelloWorld案例）
  1. 切换到要创建项目的目录，然后使用 vue create vue_pro

动力节点Vue笔记—— ③Vue组件化_前端框架_31

这里选择Vue2， babel：负责ES6语法转换成ES5。 eslint：负责语法检查的。 回车之后，就开始创建项目，创建脚手架环境（内置了webpack loader），自动生成HelloWorld案例。

动力节点Vue笔记—— ③Vue组件化_前端_32

  1. 第三步：编译Vue程序，自动将生成html css js放入内置服务器，自动启动服务。
  1. dos命令窗口中切换到项目根：cd vue_pro
  2. 执行：npm run serve，这一步会编译HelloWorld案例

动力节点Vue笔记—— ③Vue组件化_vue.js_33

ctrl + c停止服务。

  1. 打开浏览器，访问：http://localhost:8080

动力节点Vue笔记—— ③Vue组件化_前端框架_34

动力节点Vue笔记—— ③Vue组件化_前端_35

3.6.3 认识脚手架结构

使用VSCode将vue_pro项目打开：

动力节点Vue笔记—— ③Vue组件化_Vue_36

package.json：包的说明书（包的名字，包的版本，依赖哪些库）。该文件里有webpack的短命令： serve（启动内置服务器） build命令是最后一次的编译，生成html css js，给后端人员 lint做语法检查的。

3.6.4 分析HelloWorld程序

动力节点Vue笔记—— ③Vue组件化_html_37

可以看到在index.html中只有一个容器。没有引入vue.js，也没有引入main.js Vue脚手架可以自动找到main.js文件。（所以main.js文件名不要修改，位置也不要随便移动）

动力节点Vue笔记—— ③Vue组件化_Vue_38

接下来就是将之前写的程序拷贝到脚手架中，进行测试。 需要拷贝过来的是：App.vue、X.vue、Y.vue、X1.vue、Y1.vue。 main.js和index.html都不需要了，因为脚手架中有。

动力节点Vue笔记—— ③Vue组件化_vue.js_39

只需要将App.vue中的路径修改一下即可：

动力节点Vue笔记—— ③Vue组件化_前端框架_40

打开VSCode终端：ctrl + ` 在终端中执行：npm run serve 报错了：

动力节点Vue笔记—— ③Vue组件化_html_41

导致这个错误的原因是：组件的名字应该由多单词组成。这是eslint进行的es语法检测。 解决这个问题有两种方案： 第一种：把所有组件的名字修改一下。 第二种：在vue.config.js文件中进行脚手架的默认配置。配置如下：

动力节点Vue笔记—— ③Vue组件化_前端框架_42

在终端中ctrl + c 两次，终止之前的服务，再次运行命令：npm run serve

动力节点Vue笔记—— ③Vue组件化_前端框架_43

动力节点Vue笔记—— ③Vue组件化_前端框架_44

3.6.5 脚手架默认配置

脚手架默认配置在vue.config.js文件中进行。main.js、index.html等都是可以配置的。配置项可以参考Vue CLI官网手册，如下：

动力节点Vue笔记—— ③Vue组件化_前端_45

例如配置这两项： 第一个：保存时不检查语法 lintOnSave : false 第二个：配置入口

动力节点Vue笔记—— ③Vue组件化_前端框架_46

3.6.6 解释main.js中的render函数

将render函数更换为：template配置项，你会发现它是报错的。说明引入的Vue无法进行模板编译。原因：Vue脚手架默认引入的是精简版的Vue，这个精简版的Vue缺失模板编译器。

动力节点Vue笔记—— ③Vue组件化_Vue_47

实际引入的vue.js文件是：dist/vue.runtime.esm.js（esm版本是ES6模块化版本） 为什么缺失模板编译器？ Vue包含两部分：一部分是Vue的核心，一部分是模板编译器（模板编译器可能占整个vue.js文件的一大部分体积）。程序员最终使用webpack进行打包的时候，显然Vue中的模板编译器就没有存在的必要了。为了缩小体积，所以在Vue脚手架中直接引入的就是一个缺失模板编译器的vue.js。 这样就会导致template无法编译（注意：