一.认识组件的嵌套

1. App单独开发

• 前面我们是将所有的逻辑放到一个App.vue中：

  • 在之前的案例中，我们只是创建了一个组件App；
  • 如果我们一个应用程序将所有的逻辑都放在一个组件中，那么这个组件就会变成非常的臃肿和难以维护；
  • 所以组件化的核心思想应该是对组件进行拆分，拆分成一个个小的组件；
  • 再将这些组件组合嵌套在一起，最终形成我们的应用程序；
    

• 我们来分析一下下面代码的嵌套逻辑，假如我们将所有的代码逻辑都放到一个App.vue组件中：

<template>
  <div>
    <h2>Headerh2>
    <h2>NavBarh2>
  div>
  <div>
    <h2>Bannerh2>
    <ul>
      <li>商品列表1li>
      <li>商品列表2li>
      <li>商品列表3li>
      <li>商品列表4li>
      <li>商品列表5li>
    ul>
  div>
  <div>
    <h2>Footerh2>
    <h2>免责声明h2>
  div>
template>

<script>
export default {

};
script>

<style scoped>style>
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

• 我们会发现，将所有的代码逻辑全部放到一个组件中，代码是非常的臃肿和难以维护的。
• 并且在真实开发中，我们会有更多的内容和代码逻辑，对于扩展性和可维护性来说都是非常差的。
• 所以，在真实的开发中，我们会对组件进行拆分，拆分成一个个功能的小组件。

2. 组件的拆分

• 我们可以按照如下的方式进行拆分：
  
• 按照如上的拆分方式后，我们开发对应的逻辑只需要去对应的组件编写就可。

3. 组件的通信

• 上面的嵌套逻辑如下，它们存在如下关系：
  • App组件是Header、Main、Footer组件的父组件；
  • Main组件是Banner、ProductList组件的父组件；
• 在开发过程中，我们会经常遇到需要组件之间相互进行通信：
  • 比如App可能使用了多个Header，每个地方的Header展示的内容不同，那么我们就需要使用者传递给Header一些数据，让其进行展示；
  • 又比如我们在Main中一次性请求了Banner数据和ProductList数据，那么就需要传递给它们来进行展示；
  • 也可能是子组件中发生了事件，需要由父组件来完成某些操作，那就需要子组件向父组件传递事件；
• 总之，在一个Vue项目中，组件之间的通信是非常重要的环节，所以接下来我们就具体学习一下组件之间是如何相互之间传递数据的；

二. 父子组件的相互通信

1. 父子组件之间如何进行通信呢？

- **父**组件**传**递给**子**组件：`通过props属性`； 
- **子**组件传递给**父**组件：`通过$emit触发事件`；
1
2

2. 父组件传递给子组件（props）

• 在开发中很常见的就是父子组件之间通信，比如父组件有一些数据，需要子组件来进行展示：
  • 这个时候我们可以通过props来完成组件之间的通信；
• 什么是Props呢？
  • Props是你可以在组件上注册一些自定义的attribute；
  • 父组件给这些attribute赋值，子组件通过attribute的名称获取到对应的值；
• Props有两种常见的用法：
  • 方式一：字符串数组，数组中的字符串就是attribute的名称；
  • 方式二：对象类型，对象类型我们可以在指定attribute名称的同时，指定它需要传递的类型、是否是必须的、默认值等等

2.1 （掌握）Props的数组用法

代码：
ShowMessage.vue

<template>
  <div>
    <h2>{{title}}h2>
    <p>{{content}}p>
    <p>-----------p>
  div>
template>

<script>
  export default {
    props: ['title', 'content']
    }
  }
script>

<style scoped>

style>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

App.vue

<template>
  <div>
    <show-message
      id="abc"
      class="why"
      title="哈哈哈"
      content="我是哈哈哈哈"
      message-info=""
    >show-message>
    <show-message title="呵呵呵" content="我是呵呵呵呵">show-message>
    <show-message :title="title" :content="content">show-message>

    
    <show-message
      :title="message.title"
      :content="message.content"
    >show-message>
    
    
    <show-message v-bind="message">show-message>
  div>
template>

<script>
import ShowMessage from "./ShowMessage.vue";

export default {
  components: {
    ShowMessage
  },
  data() {
    return {
      title: "嘻嘻嘻",
      content: "我是嘻嘻嘻嘻",
      message: {
        title: "嘿嘿嘿",
        content: "我是嘿嘿嘿",
      },
    };
  },
};
script>

<style scoped>style>

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

2.2 （掌握）Props的对象用法

• 数组用法中我们只能说明传入的attribute的名称，并不能对其进行任何形式的限制，接下来我们来看一下对象的写法是如何让我们的props变得更加完善的。
• 当使用对象语法的时候，我们可以对传入的内容限制更多：
  • 比如指定传入的attribute的类型；
  • 比如指定传入的attribute是否是必传的；
  • 比如指定没有传入时，attribute的默认值；
    

细节一：那么type的类型都可以是哪些呢？

• 那么type的类型都可以是哪些呢？
  • String
  • Number
  • Boolean
  • Array
  • Object
  • Date
  • Function
  • Symbol

细节二：对象类型的其他写法

细节三：Prop 的大小写命名

• Prop 的大小写命名(camelCase vs kebab-case)
  • HTML 中的 attribute 名是大小写不敏感的，所以浏览器会把所有大写字符解释为小写字符；
  • 这意味着当你使用 DOM 中的模板时，camelCase (驼峰命名法) 的 prop 名需要使用其等价的 kebab-case (短横线分隔命名) 命名；
    

2.3 （掌握）非Prop的Attribute

• 什么是非Prop的Attribute呢？
  • 当我们传递给一个组件某个属性，但是该属性并没有定义对应的props或者emits时，就称之为 非Prop的Attribute；常见的包括class、style、id属性等；

分为以下三种情况:

2.3.1. Attribute继承

- 	当组件有单个根节点时，非Prop的Attribute将自动添加到根节点的Attribute中：
![-](https://img-blog.csdnimg.cn/ebef1bf2f6d444ad895c43a9ef51ba5a.png)
1
2

2.3.2 禁用Attribute继承

• 如果我们不希望组件的根元素继承attribute，可以在组件中设置 inheritAttrs: false：
  • 禁用attribute继承的常见情况是需要将attribute应用于根元素之外的其他元素；
  • 这时我们可以通过 $attrs来访问所有的 非props的attribute；
    
    

2.3.3 多根节点的attribute

• 多个根节点的attribute
  • 多个根节点的attribute如果没有显示的绑定，那么会报警告，我们必须手动的指定要绑定到哪一个属性上：
    

3. 子组件传递给父组件

• 什么情况下子组件需要传递内容到父组件呢？
  • 当子组件有一些事件发生的时候，比如在组件中发生了点击，父组件需要切换内容；
  • 子组件有一些内容想要传递给父组件的时候；
• 我们如何完成上面的操作呢？
  • 首先，我们需要在子组件中定义好在某些情况下触发的事件名称；
  • 其次，在父组件中以v-on的方式传入要监听的事件名称，并且绑定到对应的方法中；
  • 最后，在子组件中发生某个事件的时候，根据事件名称触发对应的事件；

3.1 自定义事件的流程

• 我们封装一个CounterOperation.vue的组件：
  • 内部其实是监听两个按钮的点击，点击之后通过 this.$emit的方式发出去事件；
    

3.2 自定义事件的参数和验证

• 自定义事件的时候，我们也可以传递一些参数给父组件：
  
• 在vue3当中，我们可以对传递的参数进行验证：
  
  代码：
  子组件CounterOperation.vue

<template>
  <div>
    <button @click="increment">+1button>
    <button @click="decrement">-1button>

    <input type="text" v-model.number="num">
    <button @click="incrementN">+nbutton>
  div>
template>

<script>
  export default {
    // vue3要先注册 触发哪些事件
    // 数组写法
    // emits: ["add", "sub", "addN"],
    // 对象写法的目的是为了进行参数的验证
    emits: {
      add: null,
      sub: null,
      // 对传递参数的验证
      addN: (num, name, age) => {
        console.log(num, name, age);
        if (num > 10) {
          return true
        }
        return false;
      }
    },
    data() {
      return {
        num: 0
      }
    },
    methods: {
      increment() {
        console.log("+1");
        this.$emit("add");
      },
      decrement() {
        console.log("-1");
        this.$emit("sub");
      },
      incrementN() {
        this.$emit('addN', this.num, "why", 18);
      }
    }
  }
script>

<style scoped>

style>
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

父组件App.vue

<template>
  <div>
    <h2>当前计数: {{counter}}h2>
    <counter-operation @add="addOne" 
                       @sub="subOne"
                       @addN="addNNum">
    counter-operation>
  div>
template>

<script>
  import CounterOperation from './CounterOperation.vue';

  export default {
    components: {
      CounterOperation
    },
    data() {
      return {
        counter: 0
      }
    },
    methods: {
      addOne() {
        this.counter++
      },
      subOne() {
        this.counter--
      },
      addNNum(num, name, age) {
        console.log(name, age);
        this.counter += num;
      }
    }
  }
script>

<style scoped>

style>
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

4. 父子组件间通信案例练习

• 我们来做一个相对综合的练习：
  
  子组件TabControl.vue

<template>
  <div class="tab-control">
    <div class="tab-control-item" 
         :class="{active: currentIndex === index}"
         v-for="(title, index) in titles" 
         :key="title"
         @click="itemClick(index)">
      <span>{{title}}span>
    div>
  div>
template>

<script>
  export default {
    emits: ["titleClick"],
    props: {
      titles: {
        type: Array,
        default() {
          return []
        }
      }
    },
    data() {
      return {
        currentIndex: 0
      }
    },
    methods: {
      itemClick(index) {
        this.currentIndex = index;
        this.$emit("titleClick", index);
      }
    }
  }
script>

<style scoped>
  .tab-control {
    display: flex;
  }

  .tab-control-item {
    flex: 1;
    text-align: center;
  }

  .tab-control-item.active {
    color: red;
  }

  .tab-control-item.active span {
    border-bottom: 3px solid red;
    padding: 5px 10px;
  }
style>
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

父组件App.vue

<template>
  <div>
    <tab-control :titles="titles" @titleClick="titleClick">tab-control>
    <h2>{{contents[currentIndex]}}h2>
  div>
template>

<script>
  import TabControl from './TabControl.vue';

  export default {
    components: {
      TabControl
    },
    data() {
      return {
        titles: ["衣服", "鞋子", "裤子"],
        contents: ["衣服页面", "鞋子页面", "裤子页面"],
        currentIndex: 0
      }
    },
    methods: {
      titleClick(index) {
        this.currentIndex = index;
      }
    }
  }
script>

<style scoped>

style>
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

三. 非父子组件的相互通信

• 在开发中，我们构建了组件树之后，除了父子组件之间的通信之外，还会有非父子组件之间的通信。
• 这里我们主要讲两种方式：
  • Provide/Inject；
  • Mitt全局事件总线；

1. Provide和Inject

• Provide/Inject用于非父子组件之间共享数据：
  • 比如有一些深度嵌套的组件，子组件想要获取父组件的部分内容；
  • 在这种情况下，如果我们仍然将props沿着组件链逐级传递下去，就会非常的麻烦；
  • 对于这种情况下，我们可以使用 Provide 和 Inject ：
• 无论层级结构有多深，父组件都可以作为其所有子组件的依赖提供者；
  • 父组件有一个 provide 选项来提供数据；
  • 子组件有一个 inject 选项来开始使用这些数据；
• 实际上，你可以将依赖注入看作是“long range props”，除了：
  • 父组件不需要知道哪些子组件使用它 provide 的 property
  • 子组件不需要知道 inject 的 property 来自哪里
    

1.1 Provide和Inject基本使用

• 我们开发一个这样的结构
  
  App.vue组件提供数据：

<template>
  <div>
    <home>home>
  div>
template>

<script>
  import Home from './Home.vue';


  export default {
    components: {
      Home
    },
    provide: {
        name: "why",
        age: 18,
  
     }
   
  }
script>

<style scoped>

style>
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

Home.vue是中间的组件：

<template>
  <div>
      <home-content>home-content>  
      div>
template>
<script>  
import HomeContent from './HomeContent.vue'; 
 export default {
     components: {      
		HomeContent    
	}  
}
script>
1
2
3
4
5
6
7
8
9
10
11
12
13

HomeContent.vue是获取数据的组件：

<template>
  <div>    
		<h2>HomeContenth2>    
		<h2>{{name}}-{{age}}h2>  
	div>
template>
<script>  
export default {  
  inject: ["name", "age"]  
  }
script>
1
2
3
4
5
6
7
8
9
10
11

1.2 Provide和Inject函数的写法

• 如果Provide中提供的一些数据是来自data，那么我们可能会想要通过this来获取：
  

• 这个时候会报错：

  • 这里给大家留一个思考题，我们的this使用的是哪里的this？
    

• 如何解决这个问题呢？

  • 我们需要将provide转成为返回对象的函数；
    

1.3 处理响应式数据

• 我们先来验证一个结果：如果我们修改了this.names的内容，那么使用length的子组件会不会是响应式的？
• 我们会发现对应的子组件中是没有反应的：
  • 这是因为当我们修改了names之后，之前在provide中引入的 this.names.length 本身并不是响应式的；
• 那么怎么样可以让我们的数据变成响应式的呢？
  • 非常的简单，我们可以使用响应式的一些API来完成这些功能，比如说computed函数；
  • 当然，这个computed是vue3的新特性，在后面我会专门讲解，这里大家可以先直接使用一下；
• 注意：我们在使用length的时候需要获取其中的value
• 这是因为computed返回的是一个ref对象，需要取出其中的value来使用；
  

2. (掌握)全局事件总线mitt库

2.1 mitt库

• Vue3从实例中移除了 $on、$off 和 $once 方法，所以我们如果希望继续使用全局事件总线，要通过第三方的库：
  • Vue3官方有推荐一些库，例如 mitt 或 tiny-emitter；
  • 这里我们主要讲解一下mitt库的使用；
• 首先，我们需要先安装这个库：
  npm install mitt
• 其次，我们可以封装一个工具eventbus.js：

这种工具类文件一般放在utils文件夹里面

import mitt from 'mitt';

const emitter = mitt();
// 可以创建很多个emitter对象const emitter = mitt();export default emitter;
// export const emitter1 = mitt();
// export const emitter2 = mitt();
// export const emitter3 = mitt();

export default emitter;

1
2
3
4
5
6
7
8
9
10

2.2 使用事件总线工具

• 在项目中可以使用它们：
  • 我们在Home.vue中监听事件；
  • 我们在App.vue中触发事件；

代码：
这里用About.vue触发事件，HomeContent.vue监听事件

App.vue

<template>
  <div>
    <home/>
    <about/>
  div>
template>

<script>
  import Home from './Home.vue';
  import About from './About.vue';

  export default {
    components: {
      Home,
      About
    }
  }
script>

<style scoped>

style>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Home.vue

<template>
  <div>
    <home-content>home-content>
  div>
template>

<script>
  import HomeContent from './HomeContent.vue';

  export default {
    components: {
      HomeContent
    }
  }
script>

<style scoped>

style>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

About.vue

<template>
  <div>
    <button @click="btnClick">按钮点击button>
  div>
template>

<script>
  import emitter from './utils/eventbus';

  export default {
    methods: {
      btnClick() {
        console.log("about按钮的点击");
        emitter.emit("why", {name: "why", age: 18});
        // emitter.emit("kobe", {name: "kobe", age: 30});
      }
    }
  }
script>

<style scoped>

style>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

HomeContent.vue

<template>
  <div>
  div>
template>

<script>
  import emitter from './utils/eventbus';

  export default {
    created() {
      emitter.on("why", (info) => {
        console.log("why:", info);
      });

      emitter.on("kobe", (info) => {
        console.log("kobe:", info);
      });
      // 监听所有事件
      emitter.on("*", (type, info) => {
        console.log("* listener:", type, info);
      })
    }
  }
script>

<style scoped>

style>

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

2.3 Mitt的事件取消

其他API的补充，如果在某些情况下我们想要取消事件，可以使用下面的API：

   // 取消emitter中所有的监听
    emitter.all.clear();
    // 定义一个函数
    function onFoo() {}
    emitter.on("foo", onFoo); // 监听
    emitter.off("foo", onFoo); // 取消监听
1
2
3
4
5
6