# Vue

# 认识 Vue

# 基本认识

​ Vue 是一种渐进式 JavaScript 框架，用来动态构建用户界面。

​ 开发者

# 基本特点

• 遵循 MVVM 模式
• 编码简洁，体积小，运行效率高，适合 移动 / PC 端开发
• 它本身只关注 UI，可以轻松引入 vue 插件或其它第三方库开发项目
• 采用组件化模式，提高代码复用率、且让代码更好维护
• 声明式编码，让编码人员无需直接操作 DOM，提高开发效率
• 使用虚拟 DOM 和 Diff 算法，尽量复用 DOM 节点

与其它前端 JS 框架的关联：

• 借鉴 angular 的 模板 和 数据绑定 技术
• 借鉴 react 的 组件化 和 虚拟 DOM 技术

# Vue 的使用

# 引入 Vue.js

1. 本地引入

   <script type="text/javascript" src="../js/vue.js"></script>
   

2. CDN 引入

# 创建 Vue 对象

• 想让 Vue 工作，就必须创建一个 Vue 实例，且要传入一个配置对象；
• root 容器里的代码依然符合 html 规范，只不过混入了一些特殊的 Vue 语法；
• root 容器里的代码被称为【Vue 模板】；
• Vue 实例和容器是一一对应的；
• 真实开发中只有一个 Vue 实例，并且会配合着组件一起使用；
• 中的xxx要写js表达式，且xxx可以自动读取到data中的所有属性；
• 一旦 data 中的数据发生改变，那么页面中用到该数据的地方也会自动更新；

new Vue({

    el: '#root',//

    data: {

        name: 'Sakura',

        address:'chengdu'

          }

})

​ 由 Vue 管理的函数，一定不要写箭头函数，一旦写了箭头函数，this 就不再是 Vue 实例了。

# el 与 data

el ：用于指定当前 Vue 实例为哪个容器服务，值通常为 CSS 选择器字符串；

data ：用于存储数据，数据供 el 所指定的容器去使用；

el 的两种写法

1. new Vue 的时候配置 el 属性

   	const v =new Vue({
   	el:'#root',
   	data:{
   	name:'Sakura',
   	}
   	})

2. 先创建 Vue 实例，再通过 v.$mount (xxx) 指定 el 的值

   	const v =new Vue({
   	data:{
   	name:'Sakura',
   	}
   	})
   	v.$mount('root')

data 的两种写法

1. 对象式

   	data:{
   	name:'sakura'
   	}

2. 函数式

   	data(){
   	console.log('@@@',this)
   	return{
   	name:'sakura'
   	}
   	}

# MVVM 模型

M

模型 (Model) ：data 中的数据

V

视图 (View) ：模板代码（不是静态页面） （两个语法：指令，大括号表达式）

VM

viewModel: 视图模型（Vue 的实例）

• Dom Listeners （Dom 监听）
• Data Bindings （数据绑定）

MVVM
MVVM 本质上是 MVC （Model-View- Controller）的改进版。即模型 - 视图 - 视图模型。

​ 模型 model 指的是后端传递的数据，视图 view 指的是所看到的页面。

​ 视图模型 viewModel 是 mvvm 模式的核心，它是连接 view 和 model 的桥梁。它有两个方向：

​ 将模型转化成视图，即将后端传递的数据转化成所看到的页面。实现的方式是：数据绑定
​ 将视图转化成模型，即将所看到的页面转化成后端的数据。实现的方式是：DOM 事件监听

​ 这两个方向都实现的，我们称之为数据的双向绑定

# 模板语法

# 插值语法

1. 语法： {{XXX}} xxx 是 js 表达式，可以直接读取到 data 中的所有属性；
2. 功能：用于解析标签体内容，向页面输出数据

# 指令语法

# v-bind

功能：强制数据绑定（单向绑定）

语法：

v-bind:xxx='yyy'   //yyy会作为表达式解析执行
:xxx='yyy'        //简写

特点：数据只能从 data 流向页面

# v-model

功能：强制数据绑定（双向绑定）

语法：

v-model:value='xxx'    
v-model='xxx'        //简写

原理：

<input type:'text' :value='msg' @input={msg=$event.target.value} /> 

特点：

1. 数据不仅能从 data 流向页面，还能从页面流向 data；
2. 不仅可用于表单类元素，还可用作父子组件数据的同步；

# v-on

功能：绑定指定事件名的回调函数

语法：

v-on:click='xxx'
v-on:click='xxx($event，参数)'  //获得参数与点击事件
@keyup='xxx'          //按钮抬起时触发
@keydown='xxx'        //按钮敲下时触发
@click='xxx'          //简写

# v-show

功能：条件渲染；

语法：

<div v-show='xxx'></div>   
//xxx表达式的值为ture或false

适用于：切换频率较高的场景；

特点：不展示的 DOM 元素未被移除，只是被隐藏掉

# v-if

功能：条件渲染；

语法：

<div v-if='xxx'></div>
<div v-else-if='xxx'></div>
<div v-else></div>
//xxx表达式的值为true或false
<template v-if='xxx'>
	<h2></h2>
	<h2></h2>
	<h2></h2>
</template>//不影响结构的使用方法

适用于：切换频率较低的场景

特点：不展示的 DOM 元素直接被移除

注意：v-if 可以和 v-else-if、v-else 一起使用，但要求结构不能被 “打断”；

# v-for

功能：用于展示列表数据，可遍历数组、对象、字符串、指定次数

语法：

v-for='(item.index) in xxx' :key='yyy'
//xxx为数组或对象
v-for='(item.index) of xxx' :key='yyy'
//xxx为字符串或数字（用的比较少）
//in与of的使用没有区别

• 数组: (item, index)
• 对象: (value, key)
• 字符串：(char, index)
• 数字：(number, index)

# key 的原理

虚拟 DOM 中 key 的作用：

key 是虚拟 DOM 对象的标识，当数据发生变化时，Vue 会根据【新数据】生成【新的虚拟 DOM】, 随后 Vue 进行【新虚拟 DOM】与【旧虚拟 DOM】的差异比较，比较规则如下：

对比规则：

1. 旧虚拟 DOM 中找到了与新虚拟 DOM 相同的 key：
   ①若虚拟 DOM 中内容没变，直接使用之前的真实 DOM；
   ②若虚拟 DOM 中内容变了，则生成新的真实 DOM，随后替换掉页面中之前的真实 DOM；
2. 旧虚拟 DOM 中未找到与新虚拟 DOM 相同的 key 创建新的真实 DOM，随后渲染到到页面。

用 index 作为 key 可能会引发的问题：

1. 若对数据进行：逆序添加、逆序删除等破坏顺序操作：会产生没有必要的真实 DOM 更新 ==> 界面效果没问题，但效率低；
2. 如果结构中还包含输入类的 DOM： 会产生错误 DOM 更新 ==> 界面有问题

开发中如何选择 key:

1. 最好使用每条数据的唯一标识作为 key, 比如 id、手机号、身份证号、学号等唯一值。
2. 如果不存在对数据的逆序添加、逆序删除等破坏顺序操作，仅用于渲染列表用于展示，使用 index 作为 key 是没有问题的。

# v-text

1. 作用：向其所在的节点中渲染文本内容。
2. 与插值语法的区别： v-text 会替换掉节点中的内容， {{xx}} 则不会。

# v-html

1. 作用：向指定节点中渲染包含 html 结构的内容。
2. 与插值语法的区别：
   • v-html 会替换掉节点中所有的内容，则不会
   • v-html 可以识别 html 结构。
3. 严重注意：v-html 有安全性问题！！！！
   • 在网站上动态渲染任意 HTML 是非常危险的，容易导致 XSS 攻击。
   • 一定要在可信的内容上使用 v-html，永不要用在用户提交的内容上！

# v-clock

1. 本质是一个特殊属性（没有值），Vue 实例创建完毕并接管容器后会删掉 c-clock 属性；
2. 使用 CSS（即通过属性选择器 [v-cloak] { display: none } ）配合 v-clock 可以解决网速慢时页面展示出的问题。

# v-once

1. v-once 所在节点在初次动态渲染后，就视为静态内容了。
2. 以后数据的改变不会引起 v-once 所在结构的更新，可以用于优化性能。

# v-pre

1. 跳过其所在节点的编译过程。
2. 可利用它跳过：没有使用指令语法、没有使用插值语法的节点，会加快编译。

# 自定义指令

语法：

局部指令

//对象式
new Vue({
	dirextives:{
		指令名:{
			配置对象1(){xxx},
			配置对象2(){xxx},
				}}
		})
//函数式
new Vue({
	directives(){}
})

全局指令

//对象式
Vue.dirctive(指令名，{
	配置对象1(){},
	配置对象2(){},
})
//函数式
Vue.directive(指令名,回调函数)

配置对象中的三个常用回调：

• .bind ：指令与元素成功绑定时调用；
• .inserted ：指令所在元素被插入页面时调用；
• update ：指令所在模板结构被重新解析时调用。

注意事项：

1. 指令定义时不加 v- ，但使用时要加 v- ;
2. 指令名如果是多个单词时，要使用 xxx-yyy 的命名方式。

代码实例：

<!DOCTYPE html>
<html>
	<head>
		<meta charset="UTF-8" />
		<title>自定义指令</title>
		<script type="text/javascript" src="../js/vue.js"></script>
	</head>
	<body>
		<!-- 准备好一个容器-->
		<div id="root">
			<h2>{{name}}</h2>
			<h2>当前的n值是：<span v-text="n"></span> </h2>
			<!-- <h2>放大10倍后的n值是：<span v-big-number="n"></span> </h2> -->
			<h2>放大10倍后的n值是：<span v-big="n"></span> </h2>
			<button @click="n++">点我n+1</button>
			<hr/>
			<input type="text" v-fbind:value="n">
		</div>
	</body>
	
	<script type="text/javascript">
		Vue.config.productionTip = false

		//定义全局指令
		/* Vue.directive('fbind',{
			//指令与元素成功绑定时（一上来）
			bind(element,binding){
				element.value = binding.value
			},
			//指令所在元素被插入页面时
			inserted(element,binding){
				element.focus()
			},
			//指令所在的模板被重新解析时
			update(element,binding){
				element.value = binding.value
			}
		}) */

		new Vue({
			el:'#root',
			data:{
				name:'Sakura',
				n:1
			},
			directives:{
				//big函数何时会被调用？1.指令与元素成功绑定时（一上来）。2.指令所在的模板被重新解析时。
				/* 'big-number'(element,binding){
					// console.log('big')
					element.innerText = binding.value * 10
				}, */
				big(element,binding){
					console.log('big',this) //注意此处的this是window
					// console.log('big')
					element.innerText = binding.value * 10
				},
				fbind:{
					//指令与元素成功绑定时（一上来）
					bind(element,binding){
						element.value = binding.value
					},
					//指令所在元素被插入页面时
					inserted(element,binding){
						element.focus()
					},
					//指令所在的模板被重新解析时
					update(element,binding){
						element.value = binding.value
					}
				}
			}
		})
		
	</script>
</html>

# 事件处理

# 绑定监听

1. 使用 v-on:xxx 或 @xxx 绑定事件 xxx；

2. 事件的回调方法配置在 Vue 的 methods 对象中，最终会在 vm 上（methods 中配置的方法不能用箭头函数，否则 this 指向 windows）；

3. 事件对象

   • 默认事件形参： event

   • 隐含属性对象： $event

     $event 就是当前触发事件的元素，即使不传 $event ，在回调函数中也可以使用 event 这个参数。

   event 方法：

   event.target.value：获得当前元素的值

   event.key：获得按键的名

   event.keyCode：获得按键的编码

# 事件修饰符

语法：

1. 在 methods 上：

2. @click.xxx='yyy'
   @click.xx1.xx2='yyy'     //可以同时使用多个修饰符，按左右顺序执行
   

3. prevent: 阻止默认事件

4. stop: 阻止事件冒泡

5. once：事件只触发一次

6. capture：使用事件的捕获模式

7. self：只有 event.target 是当前操作的元素才触发事件；

8. passive：事件的默认行为立即执行，无需等待事件回调执行完毕；

# 键盘修饰符

语法：

@keyup.xxx='yyy'        //xxx为键盘修饰符
@keydown.xx1.xx2='yyy'     //可以同时使用多个修饰符，常用于系统修饰键

Vue 提供的按键别名

1. 回车：enter
2. 删除：delete
3. 退出：esc
4. 空格：space
5. 换行：tab（特殊，必须配合 keydown 去使用）
6. 上：up
7. 下：down
8. 左：left
9. 右：right

Vue 未提供的按键别名

可以通过 event.key 获得按键的名（若名称为两个单词则转换为小写短横线命名）

系统修饰键（ctrl、alt、shift、meta）

1. 使用 keyup：按下修饰键的同时，再按下其他键，随后释放其他键，事件才被触发；
2. 使用 keydown：正常触发事件

# 计算属性与监听属性

computed 和 watch 之间的区别：

1. computed 能完成的功能，watch 都可以完成；
2. watch 能完成的功能，computed 不一定能完成，例如：watch 可以进行异步操作。

两个重要的小原则：

1. 所被 Vue 管理的函数，最好写成普通函数，这样 this 的指向才是 vm 或组件实例对象；
2. 所有不被 Vue 所管理的函数（定时器的回调函数、ajax 的回调函数等、Promise 的回调函数），最好写成箭头函数，这样 this 的指向才是 vm 或组件实例对象。

# 计算属性 computed

• 方法：在 computed 属性对象中定义计算属性的方法；
• 使用：在页面中使用来显示计算结果；
• 定义：通过已有属性计算得到所需要的属性；
• 原理：底层借助了 Objcet.defineproperty 方法提供的 getter 和 setter ；
• 优势：与 methods 实现相比，内部有缓存机制（复用），效率更高，调试方便；
• 计算属性最终会出现在 vm 上，直接读取即可

**get ()** 的执行：

初次读取时会执行一次，当依赖的数据（已定义的属性）发生改变时会再次被调用；

**set ()** 的执行：

计算属性被修改时被调用，用于引起计算时所依赖的数据发生改变；

代码实例：

<body>
    <div id="root">
        姓:<input type="text" v-model="firstname"><br>
        名:<input type="text" v-model='lastname'><br>
        姓名：<span>{{fullname}}</span>
    </div>

</body>
<script>
    const vm = new Vue({
        el: '#root',
        data: {
            firstname: '张',
            lastname: '三',
        },
        //完整写法
        computed: {
            fullname: {
                get() {
                    return this.firstname.slice(0, 2) + '-' + this.lastname
                },
                set(value) {
                    console.log('set', value)
                    const arr = value.split('-')
                    this.firstname = arr[0]
                    this.lastname = arr[1]
                }
            }
        },
    })
</script>
//简写(省略set)
fullName(){
	console.log('get被调用了')
	return this.firstName + '-' + this.lastName
}

# 监视属性 watch

• 使用方法：通过 vm 对象的 $watch() 或 watch 属性配置来监视指定的属性；
• 功能：当被监视的属性变化时，回调函数自动调用，进行相关操作；

深度监视

• Vue 中的 watch 默认不监测对象内部值的改变（一层）。
• 配置 deep:true 可以监测对象内部值改变（多层）。
• 备注：
• (1). Vue 自身可以监测对象内部值的改变，但 Vue 提供的 watch 默认不可以！
• (2). 使用 watch 时根据数据的具体结构，决定是否采用深度监视。

代码实例：

//watch属性配置
watch:{
	isHot:{
		immediate:true, //初始化时让handler调用一下
		handler(newValue,oldValue){
			console.log('isHot被修改了',newValue,oldValue)
		}，
  	
	}
}
//$watch()方法配置
vm.$watch('isHot',{
	immediate:true, //初始化时让handler调用一下
	handler(newValue,oldValue){
		console.log('isHot被修了',newValue,oldValue)
	}
})
//深度监视
numbers:{
	deep:true,
	handler(){
		console.log('numbers改变了')
	}
}

watch 属性的简写

当 watch 属性的配置项只有 handler 的时候

//正常写法
//第一种
isHot:{
	// immediate:true, //初始化时让handler调用一下
	// deep:true,//深度监视
	handler(newValue,oldValue){
		console.log('isHot被修改了',newValue,oldValue)
	}
}
//第二种
vm.$watch('isHot',{
	immediate:true, //初始化时让handler调用一下
	handler(newValue,oldValue){
		console.log('isHot被修了',newValue,oldValue)
	}
})

//简写
//第一种
isHot(newValue,oldValue){
	console.log('isHot被修改了',newValue,oldValue,this)
} 
//第二种
vm.$watch('isHot'，function(newValue,oldValue){
	console.log('isHot被修了',newValue,oldValue)
})

# 列表过滤与排序

一般采用计算属性更为简单方便

代码实例：

//关键字搜索列表
<body>
    <div id="root">
        <h2>人员列表</h2>
        <input type="text" v-model='keyWord' placeholder="请输入名字">
        <ul>
            <li v-for="(p,index) of filperson1" :key='id'>
                {{p.name}}--{{p.age}}--{{p.sex}}
            </li>
        </ul>
    </div>
</body>
<script>
    const vm = new Vue({
        el: '#root',
        data: {
            keyWord: '',
            persons: [
                { id: '001', name: '马冬梅', age: 18, sex: '女' },
                { id: '002', name: '周冬雨', age: 19, sex: '女' },
                { id: '003', name: '周杰伦', age: 20, sex: '男' },
                { id: '004', name: '温兆伦', age: 20, sex: '男' },
            ],
        },
        computed: {
            filperson1() {
                return this.persons.filter((p) => {
                    return p.name.indexOf(this.keyWord) !== -1
                })
            }
        }
    })
</script>

//列表过滤与排序
<body>
    <div id="root">
        <h2>人员列表</h2>
        <input type="text" v-model='keyWord' placeholder="请输入名字">
        <button @click='softType=2'>年龄升序</button>
        <button @click='softType=1'>年龄降序</button>
        <button @click='softType=0'>原顺序</button>
        <ul>
            <li v-for="(p,index) of filperson1" :key='id'>
                {{p.name}}--{{p.age}}--{{p.sex}}
            </li>
        </ul>
    </div>
</body>
<script>
    const vm = new Vue({
        el: '#root',
        data: {
            keyWord: '',
            softType: 0,
            persons: [
                { id: '001', name: '马冬梅', age: 30, sex: '女' },
                { id: '002', name: '周冬雨', age: 19, sex: '女' },
                { id: '003', name: '周杰伦', age: 20, sex: '男' },
                { id: '004', name: '温兆伦', age: 15, sex: '男' },
            ],
        },
        computed: {
            filperson1() {
                const arr = this.persons.filter((p) => {
                    return p.name.indexOf(this.keyWord) !== -1
                })
                if (this.softType) {
                    arr.sort((p1, p2) => {
                        return this.softType === 1 ? p2.age - p1.age : p1.age - p2.age
                    })
                }
                return arr
            },

        }
    })
</script>

# Vue 监视数据的原理

• Vue 会监视 data 中所有层次的数据；

• 如何检测对象中的数据？

  通过 setter 实现监视，且要做 new Vue 时就传入要检测的数据。

  1. 对象中后追加的属性，Vue 默认不做响应式处理；

  2. 如需给后添加的属性做响应式，请使用如下 API：

     Vue.set (target,propertyName/index,value) 或

     vm.$set(target,propertyName/index,value)

• 如何检测数组中的数据？

  通过包裹数组更新元素的方法实现，本质就是做了两件事：

  1. 调用原生对应的方法对数组进行了更新；
  2. 重新解析模板，进而更新页面

• 在 Vue 修改数组中的某个元素时一定要用如下方法：

  1. 改变原数组：

     push() pop() shift() unshift() splice() sort() reverse() Vue.set() vm.$set()

     (使用 Vue.set () 与 vm.$set () 时不能给 vm 或 vm 的跟数据对象添加属性)

  2. 替换数组：

     filter() concat() slice()

     (它们不会变更原数组，而总是返回一个新数组，当使用非变更方法时，可以使用新数组替换旧数组)

代码实例：

<!DOCTYPE html>
<html>
	<head>
		<meta charset="UTF-8" />
		<title>总结数据监视</title>
		<style>
			button{
				margin-top: 10px;
			}
		</style>
		<!-- 引入Vue -->
		<script type="text/javascript" src="../js/vue.js"></script>
	</head>
	<body>
		<!--
 
		-->
		<!-- 准备好一个容器-->
		<div id="root">
			<h1>学生信息</h1>
			<button @click="student.age++">年龄+1岁</button> <br/>
			<button @click="addSex">添加性别属性，默认值：男</button> <br/>
			<button @click="student.sex = '未知' ">修改性别</button> <br/>
			<button @click="addFriend">在列表首位添加一个朋友</button> <br/>
			<button @click="updateFirstFriendName">修改第一个朋友的名字为：张三</button> <br/>
			<button @click="addHobby">添加一个爱好</button> <br/>
			<button @click="updateHobby">修改第一个爱好为：开车</button> <br/>
			<button @click="removeSmoke">过滤掉爱好中的抽烟</button> <br/>
			<h3>姓名：{{student.name}}</h3>
			<h3>年龄：{{student.age}}</h3>
			<h3 v-if="student.sex">性别：{{student.sex}}</h3>
			<h3>爱好：</h3>
			<ul>
				<li v-for="(h,index) in student.hobby" :key="index">
					{{h}}
				</li>
			</ul>
			<h3>朋友们：</h3>
			<ul>
				<li v-for="(f,index) in student.friends" :key="index">
					{{f.name}}--{{f.age}}
				</li>
			</ul>
		</div>
	</body>

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

		const vm = new Vue({ 
			el:'#root',
			data:{
				student:{
					name:'tom',
					age:18,
					hobby:['抽烟','喝酒','烫头'],
					friends:[
						{name:'jerry',age:35},
						{name:'tony',age:36}
					]
				}
			},
			methods: {
				addSex(){
					// Vue.set(this.student,'sex','男')
					this.$set(this.student,'sex','男')
				},
				addFriend(){
					this.student.friends.unshift({name:'jack',age:70})
				},
				updateFirstFriendName(){
					this.student.friends[0].name = '张三'
				},
				addHobby(){
					this.student.hobby.push('学习')
				},
				updateHobby(){
					// this.student.hobby.splice(0,1,'开车')
					// Vue.set(this.student.hobby,0,'开车')
					this.$set(this.student.hobby,0,'开车')
				},
				removeSmoke(){
					this.student.hobby = this.student.hobby.filter((h)=>{
						return h !== '抽烟'
					})
				}
			}
		})
	</script>
</html>

# 样式绑定

# class 绑定

语法：

:class='xxx'  //xxx可以是字符串、数组或对象

• 字符串写法

  <div class="basic" :class='mood' @click='changemood'>{{name}}</div>
  

  适用于：样式的类名不确定，要动态获取；

• 数组写法

  <div class="basic" :class='classArr' @click='changemood'>{{name}}</div>
  //classArr是个数组，可以包含多个样式类名
  

  适用于：要绑定多个样式，个数不确定，名字也不确定；

• 对象写法

  <div class="basic" :class="classObj">{{name}}</div> 
  //classObj是个对象，对象的key为样式类名，其对应的值为ture或false
  

  适用于：要绑定多个样式，个数确定，名字也确定，但不确定用不用；

# style 绑定

语法：

:style='xxx'  //xxx可以是对象或数组

• 对象写法

  <div class="basic" :style="styleObj">{{name}}</div> 
  //styleObj是个对象，对象的key为style属性值，其值为具体数额
  

• 数组写法

  <div class="basic" :style="styleArr">{{name}}</div> 
  //styleArr是个数组，数组包含多个样式对象(即对象写法)
  

# Vue 的数组方法

# filter()

​ filter () 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。

语法：

const arr= [32, 33, 16, 40];

const arr1 = arr.filter(item => item >= 18)

console.log(arr1)  // [32, 33, 40]

# map()

​ map () 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。

语法：

const arr= [4, 9, 16, 25];

const arr1 = arr.map(item => item+2)

console.log(arr1)  // [6, 11, 18, 27]

# forEach()

​ forEach () 方法用于调用数组的每个元素，并将元素传递给回调函数。（对空数组是不会执行回调函数的）

语法：

const arr= [4, 9, 16, 25];

const arr1 = [];

arr.forEach(item => arr1.push(item))

console.log(arr1)  // [4, 9, 16, 25]

# find()

​ find () 方法返回通过测试（函数内判断）的数组的第一个元素的值，之后的值不会再调用执行函数，如果没有符合条件的元素返回 undefined。（对于空数组，函数是不会执行的）

findIndex()

​ findIndex () 方法返回传入一个测试条件（函数）符合条件的数组第一个元素位置，之后的值不会再调用执行函数，如果没有符合条件的元素返回 - 1.（对于空数组，函数是不会执行的）

语法：

//find()

const arr= [4, 9, 16, 25];

const b1 = arr.find(item => item>10)

const c1 = arr.find(item => item<1)

console.log(b1)  // 16

console.log(c1)  // undefined

//findIndex()

const b2 = arr.findIndex(item => item>10)

const c2 = arr.findIndex(item => item<1)

console.log(b2)  // 2

console.log(c2)  // -1

# some()&every()

​ some () 方法用于依次检测数组中的元素是否满足指定条件（函数提供）。

• 如果有一个元素满足条件，则表达式返回 true , 剩余的元素不会再执行检测。
• 如果没有满足条件的元素，则返回 false。

every () 方法用于检测数组所有元素是否都符合指定条件（通过函数提供）。

• 如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。
• 如果所有元素都满足条件，则返回 true。

​ 两者均不会对空数组进行检测，且不会改变原始数组。

# fill()

​ fill () 方法用于将一个固定值替换数组的元素.

该方法会改变原始数组，但不会对空数组进行填充。

语法：

const arr1= [4, 9, 16, 25];

const b = arr1.fill(100);

const arr2= [4, 9, 16, 25];

const c = arr2.fill(100, 2, 4)  // 2 为开始填充的起始位置，4 为结束位置（不包含）

const arr3= [];

const d = arr3.fill(100);

console.log(arr1)   // [100, 100, 100, 100]

console.log(b)  // [100, 100, 100, 100]

console.log(arr2)  // [4, 9, 100, 100]

console.log(c)  // [4, 9, 100, 100]

console.log(arr3)  // []

console.log(d)  // []

# 表单数据收集

​ Vue 的表单数据收集一般使用 v-model (双向数据绑定) 自动收集数据。

v-model 的三个修饰符：

• lazy ：失去焦点后再收集数据；
• number ：输入字符串转为有效的数字；
• trim ：输入的首尾空格将被过滤；

# 输入栏

text

语法：

<input type='text' v-model='xxx'/>

password

语法：

<input type='password' v-model='xxx'/>

number

语法：

<input type='number' v-model.number='xxx'/> 

​ 需配合 v-model 的 .number 修饰符使用，将输入的字符串转为有效的数字；

radio

语法：

男<input type="radio" name='sex' v-model='userinfo.sex' value="man">
女<input type="radio" name='sex' v-model='userinfo.sex' value="woman">

1. 如果需要多选一，则需要配置 name 属性；
2. v-model 收集的 value 值，故一定需要给标签配置 value 值；

checkbox

语法：

<input type="checkbox" v-model='userinfo.hobby' value="stydy">

1. 如果没有配置其 value 属性，则收集的为 checked（勾选 or 未勾选，布尔值）；
2. 如果配置了其 value 属性，还需要将 v-model 的初始值设为数组，这样才能收集 value 组成的数组，否则收集的还是 checked；

select

语法：

所属校区
<select v-model='userinfo.school'>                 		<option value="">请选择校区</option>
    <option value="shahe">沙河</option>            	<option value="qingshuihe">清水河</option>
</select>

textarea

语法：

<textarea v-model.lazy='userinfo.other'></textarea>

​ 一般配合 v-model 的 .lazy 修饰符使用，来减少无效开销；

# 表单代码实例

<!DOCTYPE html>
<html lang="zh-cn">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>收集表单数据</title>
    <script src="../js/vue.js"></script>
</head>

<body>
    <div id="root">
        <form @submit.prevent='demo'>
            账号:<input type="text" v-model.trim='userinfo.account'><br><br>
            密码:<input type="password" v-model='userinfo.password'><br><br>
            年龄:<input type="number" v-model.number='userinfo.age'><br><br>
            性别:
            男<input type="radio" name='sex' v-model='userinfo.sex' value="man">
            女<input type="radio" name='sex' v-model='userinfo.sex' value="woman"><br><br>
            爱好:
            学习<input type="checkbox" v-model='userinfo.hobby' value="stydy">
            打游戏<input type="checkbox" v-model='userinfo.hobby' value="game">
            吃饭<input type="checkbox" v-model='userinfo.hobby' value="eat"><br><br>
            所属校区
            <select v-model='userinfo.school'>
                <option value="">请选择校区</option>
                <option value="shahe">沙河</option>
                <option value="qingshuihe">清水河</option>
            </select><br><br><br><br>
            其它信息:
            <textarea v-model.lazy='userinfo.other'></textarea><br><br>
            <input type="checkbox" v-model='userinfo.agree'> 阅读并接收<a href="#">《用户协议》</a>
            <button>提交</button>
        </form>
    </div>

</body>
<script>
    new Vue({
        el: '#root',
        data: {
            userinfo: {
                account: '',
                password: '',
                age: 18,
                sex: 'man',
                hobby: [],
                school: '',
                other: '',
                agree: '',
            }
        },
        methods: {
            demo() {
                console.log(JSON.stringify(this.userinfo))
            }
        },
    })
</script>
</html>

# 生命周期

官方生命周期图：

细节解释

# 常用的生命周期方法

mounted()

​ 【初始化操作】

​ 发送 ajax 请求，启动定时器、绑定自定义事件、订阅消息等异步任务；

beforeDestory()

​ 【收尾工作】

​ 清除定时器、解绑自定义事件、取消订阅消息等收尾工作；

# Vue 组件的使用

组件的定义：

​ 实现应用中局部功能代码和资源的集合。

# 非单文件组件

使用组件的三大步骤：

1. 定义组件（创建组件）
2. 注册组件
3. 使用组件（编写组件结构）

定义组件

​ 使用 Vue.extend(options) 创建，其中 options 和 new Vue（options) 时传入的那个 options 几乎一样，但有以下区别:

1. 不要写 el —— 最终所有的组件都要经过一个 vm 的管理，由 vm 中的 el 决定服务哪个容器；
2. data 必须写成函数 —— 避免组件被复用时，数据存在引用关系；

注册组件

1. 局部注册： new Vue 的时候传入 components 选项
2. 全局注册： Vue.component (‘组件名’, 组件)

使用组件

使用 Vue 的 template 属性创建组件结构，用两个顿号（`）包裹结构。

非单文件代码实例：

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

# 注意项

关于组件名
一个单词组成：
第一种写法（首字母小写）：school
第二种写法（首字母大写）：School

多个单词组成：
第一种写法（kebab-case 命名）：my-school
第二种写法（CamelCase 命名）：MySchool（需要 Vue 脚手架支持）

备注
① 组件名尽可能回避 HTML 中已有的元素名称，例如 h2、H2；
② 可以使用 name 配置项指定组件在开发者工具中呈现的名字；

关于组件标签
第一种写法：
第二种写法：(不使用脚手架会导致后续组件不能渲染)

简写方式
const school = Vue.extend(options) 可以简写成 const school = options

# VueComponent

1. app 组件本质是一个名为 VueComponent 的构造函数，且不是程序员定义的，是 Vue.extend 生成的；
2. 我们只需要写或，Vue 解析时会帮我们创建 app 组件的实例对象，即 Vue 帮我们执行 new VueComponent (options);
3. 特别注意：每次调用 Vue.extend，返回的都是一个全新的 VueComponent;
4. 关于 this 指向
   ① 组件配置中：data 函数、methods 中的函数、watch 中的函数、computed 中的函数 它们的 this 均是【VueComponent 实例对象】
   ② new Vue (options) 配置中：data 函数、methods 中的函数、watch 中的函数、computed 中的函数 它们的 this 均是【Vue 实例对象】;
5. VueComponent 的实例对象，以后简称 vc（也可称之为：组件实例对象）;

一个重要的内置关系

VueComponent.prototype.__proto__ === Vue.prototype

这样组件实例对象 vc 就可以访问到 Vue 原型上的属性和方法。

# 单文件组件

主要由三部分组成：

1. Vue 组件
2. main.js 文件
3. index.html 文件

Vue 组件

1. 普通组件的组成

   • 模板页面
   • JS 模块对象
   • 样式

   代码实例：

   //模板页面
   <template>
     <div class="demo">
       <h2>学生名称:{{ name }}</h2>
       <h2>学生地址:{{ address }}</h2>
       <button @click="showName"></button>
     </div>
   </template>
   
   //JS模块对象
   <script>
   export default {
     name: "school",
     data() {
       return {
         name: "Sakura",
         address: "成都",
       };
     },
     methods: {
       showName() {
         alert(this.name);
       },
     },
   };
   </script>
   
   //样式
   <style>
   .demo {
     background: orange;
   }
   </style>
   

2. App.vue

   所有组件的父组件，用于调控和使用其它组件。

   代码实例：

   <template>
     <div>
       <School></School>
       <Student></Student>
     </div>
   </template>
   
   <script>
   import School from "./School";
   import Student from "./Student.vue";
   export default {
     name: "App",
     component: {
       School,
       Student,
     },
   };
   </script>
   

main.js 文件

代码实例：

import App from './App.vue'

new Vue({

    el: '#root',

    template: `<App></App>`,

    component: { App }

})

index.html 文件

代码实例：

<!DOCTYPE html>

<html lang="zh-cn">

<head>

    <meta charset="UTF-8">

    <meta http-equiv="X-UA-Compatible" content="IE=edge">

    <meta name="viewport" content="width=device-width, initial-scale=1.0">

    <title>单文件组件</title>

</head>

<body>

    <div id="root">

        <!-- <App></App> -->

    </div>

    <script src="../js/vue.js"></script>

    <script src="./main.js"></script>

</body>

</html>

# Vue CLI

# 脚手架的安装

暂略

# 脚手架文件结构

├── node_modules
├── public
│ ├── favicon.ico: 页签图标
│ └── index.html: 主页面
├── src
│ ├── assets: 存放静态资源
│ │ └── logo.png
│ │── component: 存放组件
│ │ └── HelloWorld.vue
│ │── App.vue: 汇总所有组件
│ │── main.js: 入口文件
├── .gitignore: git 版本管制忽略的配置
├── babel.config.js: babel 的配置文件
├── package.json: 应用包配置文件
├── README.md: 应用描述文件
├── package-lock.json：包版本控制文件

# render()

vue.js 与 vue.runtime.xxx.js 的区别：

1. vue.js 是完整版的 Vue，包含：核心功能 + 模板解析器。
2. vue.runtime.xxx.js 是运行版的 Vue，只包含：核心功能；没有模板解析器。

因为 vue.runtime.xxx.js 没有模板解析器，所以不能使用 template 这个配置项，需要使用 render 函数接收到的 createElement 函数去指定具体内容。

代码实例：

new Vue({

  render: h => h(App),

}).$mount('#app')

# 个性化配置

​ 先创建 vue.config.js 文件，再参考配置参考 | Vue CLI (vuejs.org) 后将需要修改的部分写入文件。

# Vue 高级知识

# ref 属性

功能：

​ 被用来给元素或子组件注册引用信息（id 的替代者）。

1. 应用在 html 标签上获取的是真实 DOM 元素；
2. 应用在组件标签上获取的是组件实例对象（vc）

使用方式：

1. 打标识：<h1 ref="xxx">.....</h1 > 或 <School ref="xxx"></School>
2. 获取：this.$refs.xxx

代码实例：

<template>
  <div>
    <h1 v-text="msg" ref="title"></h1>
    <button @click="showDOM" ref="btn">输出上方的DOM元素</button>
    <School ref="sch" />
  </div>
</template>

<script>
import School from "./components/School.vue";
export default {
  name: "App",
  components: {
    School,
  },
  data() {
    return {
      msg: "Vue",
    };
  },
  methods: {
    showDOM() {
      console.log(this.$refs.title);
      console.log(this.$refs.btn);
      console.log(this.$refs.sch);
    },
  },
};
</script>

# props 属性

功能：

​ 让组件接收外部传过来的数据；

使用方式：

• 传送数据： <Demo name="xxx"/>
• 接收数据：

1. 第一种方式（只接收）： props:['name'] ；

2. 第二种方式（限制类型）： props:{name:String} ；

3. 第三种方式（限制类型、限制必要性、指定默认值）：

   	props:{
   	name:{
   	type:String, // 类型
   	required:true, // 必要性
   	default:'老王' // 默认值
   	}
   	}

** 备注：**props 是只读的，Vue 底层会监测你对 props 的修改，如果进行了修改，就会发出警告，若业务需求确实需要修改，那么请复制 props 的内容到 data 中一份，然后去修改 data 中的数据。

代码实例：

<template>
  <div class="student">
    <h2>学生名称:{{ name }}</h2>
    <h2>学生地址:{{ address }}</h2>
    <h2>学生年龄:{{ age + 1 }}</h2>
  </div>
</template>

<script>
export default {
  name: "Student",
  data() {
    return {
      maName: this.name,
      myAge: this.age,
    };
  },
  //简单接收
  // props: ["name", "address", "age"],
  //
  //类型限制的接收
  // props: {
  //   name: String,
  //   age: Number,
  //   sex: String,
  // },
  //类型的限制、默认值的限定、必要性的限定
  props: {
    name: {
      type: String,
      required: true,
    },
    age: {
      type: Number,
      default: 10,
    },
    sex: {
      type: String,
      required: true,
    },
  },
};
</script>

<style>
.student {
  background-color: grey;
}
</style>

# mixin 属性

功能：

​ 可以把多个组件共用的配置提取成一个混入对象；

使用方式：

1. 第一步：定义混入（js 文件）：

   	{
   	data(){....},
   	methods:{....}
   	....
   	}

2. 第二步：使用混入

• 全局混入：在 mian.js 中 Vue.mixin(xxx)
• 局部混入：在 Vue 组件中 mixins:['xxx']

代码实例：

mixin.js:

export const hunhe = {

  methods: {

    showName() {

      alert(this.name);

    },

  },

  mounted() {

    console.log("你好啊！");

  },

};

export const hunhe2 = {

  data() {

    return {

      x: 100,

      y: 200,

    };

  },

};

# Vue 自定义插件

功能：

​ 用于增强 Vue；

使用方式：

1. 定义插件

   本质：包含 install 方法的一个对象，install 的第一个参数是 Vue，第二个以后的参数是插件使用者传递的数据。

   代码实例：

   	export default {
   	install(Vue, x, y, z) {
   	console.log(x, y, z);
   	// 定义混入
   	Vue.mixin({
   	data() {
   	return {
   	x: 100,
   	y: 200,
   	};
   	},
   	});
   	// 给 Vue 原型上添加一个方法（vm 和 vc 就都能用了）
   	Vue.prototype.hello = () => {
   	alert("你好啊");
   	};
   	},
   	};

2. 使用插件： Vue.use()

   代码实例：

   main.js:

   	// 引入 Vue
   	import Vue from "vue";
   	// 引入 App
   	import App from "./App.vue";
   	// 引入插件
   	import plugins from "./plugins";
   	// 应用（使用）插件
   	Vue.use(plugins, 1, 2, 3);
   	// 创建 vm
   	new Vue({
   	el: "#app",
   	render: (h) => h(App),
   	});

# scoped 样式

作用：

​ 让样式在局部生效，防止冲突；

写法：

`<style scoped> </style>`

# $children

​ this.$children ：可以获得当前组件下的所有子组件（数组形式）；

# $parent

​ this.$parent ：可以获得当前组件的父组件；

# slot 插槽

功能：

​ 让父组件可以向子组件指定位置插入 html 结构，也是一种组件间通信的方式，适用于 父组件 ===> 子组件

默认插槽

父组件：

<Category>
   <div>html结构1</div>
</Category>

子组件（ Category.vue ）

<template>
    <div>
       <!-- 定义插槽 -->
       <slot>插槽默认内容...</slot>
    </div>
</template>

具名插槽

父组件：

<Category>
    <template slot="center">
      <div>html结构1</div>
    </template>

    <template v-slot:footer>
       <div>html结构2</div>
    </template>
</Category>

子组件（ Category.vue ）

<template>
    <div>
       <!-- 定义插槽 -->
       <slot name="center">插槽默认内容...</slot>
       <slot name="footer">插槽默认内容...</slot>
    </div>
</template>

作用域插槽

理解：

​ 数据在组件的自身，但根据数据生成的结构需要组件的使用者来决定。（games 数据在 Category 组件中，但使用数据所遍历出来的结构由 App 组件决定）

父组件

<Category>
	<template scope="scopeData">
		<!-- 生成的是ul列表 -->
		<ul>
			<li v-for="g in scopeData.games" :key="g">{{g}}</li>
		</ul>
	</template>
</Category>

<Category>
	<template slot-scope="scopeData">
		<!-- 生成的是h4标题 -->
		<h4 v-for="g in scopeData.games" :key="g">{{g}}</h4>
	</template>
</Category>

子组件（ Category.vue ）

<template>
    <div>
        <slot :games="games"></slot>
    </div>
</template>

<script>
    export default {
        name:'Category',
        props:['title'],
        //数据在子组件自身
        data() {
            return {
                games:['红色警戒','穿越火线','劲舞团','超级玛丽']
            }
        },
    }
</script>

# Vuex

概念：

​ 在 Vue 中实现集中式状态（数据）管理的一个 Vue 插件，对 vue 应用中多个组件的共享状态进行集中式的管理（读 / 写数据或方法），也是一种组件间通信的方式，且适用于任意组件间通信。

# 搭建 Vuex 环境

1. 创建文件： src/store/index.js

   	// 引入 Vue 核心库
   	import Vue from 'vue'
   	// 引入 Vuex
   	import Vuex from 'vuex'
   	// 应用 Vuex 插件
   	Vue.use(Vuex)
   	// 准备 actions 对象 —— 响应组件中用户的动作
   	const actions = {}
   	// 准备 mutations 对象 —— 修改 state 中的数据
   	const mutations = {}
   	// 准备 state 对象 —— 保存具体的数据
   	const state = {}
   	// 创建并暴露 store
   	export default new Vuex.Store({
   	actions,
   	mutations,
   	state
   	})

2. 在 main.js 中创建 vm 时传入 store 配置项

   	......
   	// 引入 store
   	import store from './store'
   	......
   	// 创建 vm
   	new Vue({
   	el:'#app',
   	render: h => h(App),
   	store
   	})

# 基本使用

1. 初始化数据、配置 actions 、配置 mutation

2. 组件中读取 vuex 中的数据： $store.state.sum

3. 组件中修改 vuex 中的数据： $store.dispatch('action中的方法名',数据) 或 $store.commit('mutations中的方法名',数据)

   备注：若没有网络请求或其他业务逻辑，组件中也可以越过 actions，即不写 dispatch ，直接编写 commit

# getters

概念：

​ 当 state 中的数据需要经过加工后再使用时，可以使用 getters 加工。

使用方法：

1. 在 store.js 中追加 getters 配置

   	......
   	const getters = {
   	bigSum(state){
   	return state.sum * 10
   	}
   	}
   	// 创建并暴露 store
   	export default new Vuex.Store({
   	......
   	getters
   	})

2. 组件中读取数据： $store.getters.bigSum

# 四个 Map 方法

• mapState 方法：用于帮助我们映射 state 中的数据为计算属性；

  	computed: {
  	// 借助 mapState 生成计算属性：sum、school、subject（对象写法）
  	...mapState({sum:'sum',school:'school',subject:'subject'}),
  	// 借助 mapState 生成计算属性：sum、school、subject（数组写法）
  	...mapState(['sum','school','subject']),
  	},

• mapGetters 方法：用于帮助我们映射 getters 中的数据为计算属性；

  	computed: {
  	// 借助 mapGetters 生成计算属性：bigSum（对象写法）
  	...mapGetters({bigSum:'bigSum'}),
  	// 借助 mapGetters 生成计算属性：bigSum（数组写法）
  	...mapGetters(['bigSum'])
  	},

• mapActions 方法：用于帮助我们生成与 actions 对话的方法，即：包含 $store.dispatch(xxx) 的函数；

  	methods:{
  	// 靠 mapActions 生成：incrementOdd、incrementWait（对象形式）
  	...mapActions({incrementOdd:'jiaOdd',incrementWait:'jiaWait'})
  	// 靠 mapActions 生成：incrementOdd、incrementWait（数组形式）
  	...mapActions(['jiaOdd','jiaWait'])
  	}

• mapMutations 方法：用于帮助我们生成与 mutations 对话的方法，即：包含 $store.commit(xxx) 的函数；

  	methods:{
  	// 靠 mapActions 生成：increment、decrement（对象形式）
  	...mapMutations({increment:'JIA',decrement:'JIAN'}),
  	// 靠 mapMutations 生成：JIA、JIAN（对象形式）
  	...mapMutations(['JIA','JIAN']),
  	}

备注：

1. 4 个 Map () 方法使用前需要先引用 import {xxx} from 'vuex' (xxx 为 Map 方法名)
2. mapActions 与 mapMutations 使用时，若需要传递参数需要：在模板中绑定事件时传递好参数，否则参数是事件对象。

# 模块化

功能：

​ 让代码更好维护，让多种数据分类更加明确。

使用方法：

1. 开启命名空间；

   	const countAbout = {
   	namespaced:true,// 开启命名空间
   	state:{x:1},
   	mutations: { ... },
   	actions: { ... },
   	getters: {
   	bigSum(state){
   	return state.sum * 10
   	}
   	}
   	}
   	const personAbout = {
   	namespaced:true,// 开启命名空间
   	state:{ ... },
   	mutations: { ... },
   	actions: { ... }
   	}
   	const store = new Vuex.Store({
   	modules: {
   	countAbout,
   	personAbout
   	}
   	})

2. 开启命名空间后，组件中读取 state 数据；

   	// 方式一：自己直接读取
   	this.$store.state.personAbout.list
   	// 方式二：借助 mapState 读取：
   	...mapState('countAbout',['sum','school','subject']),

3. 开启命名空间后，组件中读取 getters 数据；

   	// 方式一：自己直接读取
   	this.$store.getters['personAbout/firstPersonName']
   	// 方式二：借助 mapGetters 读取：
   	...mapGetters('countAbout',['bigSum'])

4. 开启命名空间后，组件中调用 dispatch；

   	// 方式一：自己直接 dispatch
   	this.$store.dispatch('personAbout/addPersonWang',person)
   	// 方式二：借助 mapActions：
   	...mapActions('countAbout',{incrementOdd:'jiaOdd',incrementWait:'jiaWait'})

5. 开启命名空间后，组件中调用 commit；

   	// 方式一：自己直接 commit
   	this.$store.commit('personAbout/ADD_PERSON',person)
   	// 方式二：借助 mapMutations：
   	...mapMutations('countAbout',{increment:'JIA',decrement:'JIAN'}),

# 路由

原理：

​ 一个路由（route）就是一组映射关系（key - value），多个路由需要路由器（router）进行管理。

# 基本使用

1. 安装 vue-router，命令： npm i vue-router

2. 应用插件： Vue.use(VueRouter)

3. 编写 router 配置项:

   	// 引入 VueRouter
   	import VueRouter from 'vue-router'
   	// 引入 Luyou 组件
   	import About from '../components/About'
   	import Home from '../components/Home'
   	// 创建 router 实例对象，去管理一组一组的路由规则
   	const router = new VueRouter({
   	routes:[
   	{
   	path:'/about',
   	component:About
   	},
   	{
   	path:'/home',
   	component:Home
   	}
   	]
   	})
   	// 暴露 router
   	export default router

4. 实现切换（active-class 可配置高亮样式）；

   <router-link active-class="active" to="/about">About</router-link>
   

5. 指定展示位置；

   <router-view></router-view>
   

备注：

• 路由组件通常存放在 pages 文件夹，一般组件通常存放在 components 文件夹；
• 通过切换，“隐藏” 了的路由组件，默认是被销毁掉的，需要的时候再去挂载；
• 每个组件都有自己的 $route 属性，里面存储着自己的路由信息；
• 配置路由的时候可以给路由的 $route 添加（配置）路由元信息 meta ；
• 整个应用只有一个 router，可以通过组件的 $router 属性获取到；

# 路由的参数传递

# query 传参数

1. 传递参数：

   <!-- 跳转并携带query参数，to的字符串写法 -->
   <router-link :to="/home/message/detail?id=666&title=你好">跳转</router-link>
   <script>
   	goSearch() {
               this.$router.push("/search"+"?k="+this.keyword);
           },
   </script>
   
   				
   <!-- 跳转并携带query参数，to的对象写法 -->
   <router-link 
   	:to="{
   		path:'/home/message/detail',
   		query:{
   		   id:666,
               title:'你好'
   		}
   	}"
   >跳转</router-link>
   

2. 接收参数：

   $route.query.id
   $route.query.title
   

# params 传参数

1. 配置路由，声明接收 params 参数:

   	{
   	path:'/home',
   	component:Home,
   	children:[
   	{
   	path:'news',
   	component:News
   	},
   	{
   	component:Message,
   	children:[
   	{
   	name:'xiangqing',
   	path:'detail/:id/:title', // 使用占位符声明接收 params 参数 (如果在占位符声明后加上？，则可以实现可传可不不 chuan)
   	component:Detail
   	}
   	]
   	}
   	]
   	}

2. 传递参数：

   <!-- 跳转并携带params参数，to的字符串写法 -->
   <router-link :to="/home/message/detail/666/你好">跳转</router-link>
   
   <script>
   	goSearch() {
        this.$router.push("/search""+this.keyword);
           },
   </script>
   
   <!-- 跳转并携带params参数，to的对象写法 -->
   <router-link 
   	:to="{
   		name:'xiangqing',
   		params:{
   		   id:666,
               title:'你好'
   		}
   	}"
   >跳转</router-link>
   

   备注：路由携带 params 参数时，若使用 to 的对象写法，则不能使用 path 配置项，必须使用 name 配置！

3. 接收参数：

   	$route.params.id
   	$route.params.title

# props 配置

** 作用：** 让路由组件更方便的收到参数

{

	name:'xiangqing',

	path:'detail/:id',

	component:Detail,

	// 第一种写法：props 值为对象，该对象中所有的 key-value 的组合最终都会通过 props 传给 Detail 组件

	// props:{a:900}

	// 第二种写法：props 值为布尔值，布尔值为 true，则把路由收到的所有 params 参数通过 props 传给 Detail 组件

	// props:true

	// 第三种写法：props 值为函数，该函数返回的对象中每一组 key-value 都会通过 props 传给 Detail 组件

	props(route){

		return {

			id:route.query.id,

			title:route.query.title

		}

	}

}

# 路由跳转

# 通过标签跳转

基本方式

1. 配置路由规则，使用 children 配置项：

   	routes:[
   	{
   	path:'/about',
   	component:About,
   	},
   	{
   	path:'/home',
   	component:Home,
   	children:[ // 通过 children 配置子级路由
   	{
   	path:'news', // 此处一定不要写：/news
   	component:News
   	},
   	{
   	path:'message',
   	component:Message
   	}
   	]
   	}
   	]

2. 跳转（要写完整路径）：

   <router-link to="/home/news">News</router-link>
   

命名路由

1. 给路由命名：

   	{
   	path:'/demo',
   	component:Demo,
   	children:[
   	{
   	path:'test',
   	component:Test,
   	children:[
   	{
   	name:'hello' // 给路由命名
   	path:'welcome',
   	component:Hello,
   	}
   	]
   	}
   	]
   	}

2. 简化跳转：

   <!--简化后，直接通过名字跳转 -->
   <router-link :to="{name:'hello'}">跳转</router-link>
   
   <!--简化写法配合传递参数 -->
   <router-link 
   	:to="{
   		name:'hello',
   		query:{
   		   id:666,
               title:'你好'
   		}
   	}"
   >跳转</router-link>
   

# 编程式路由导航

作用：

​ 不借助 <router-link> 实现路由跳转，让路由跳转更加灵活；

代码实例：

在组件的 methods 中定义方法再输入以下操作方法

//$router 的两个 API

this.$router.push({

	name:'xiangqing',

		params:{

			id:xxx,

			title:xxx

		}

})

this.$router.replace({

	name:'xiangqing',

		params:{

			id:xxx,

			title:xxx

		}

})

this.$router.forward() // 前进

this.$router.back() // 后退

this.$router.go() // 可前进也可后退

# 路由守卫

作用：

​ 对路由进行权限控制。

• 全局守卫

  	// 在此之前需要对路由的 meta 属性进行设置，创新新对象的 key {isAuth}，值为 true or false
  	// 全局前置守卫：初始化时执行、每次路由切换前执行
  	router.beforeEach((to,from,next)=>{
  	console.log('beforeEach',to,from)
  	if(to.meta.isAuth){ // 判断当前路由是否需要进行权限控制
  	if(localStorage.getItem('school') === 'atguigu'){ // 权限控制的具体规则
  	next() // 放行
  	}else{
  	alert('暂无权限查看')
  	// next({name:'guanyu'})
  	}
  	}else{
  	next() // 放行
  	}
  	})
  	// 在此之前需要对路由的 meta 属性进行设置，创新新对象的 key，一般设置为 {title：'xxx'}
  	// 全局后置守卫：初始化时执行、每次路由切换后执行
  	router.afterEach((to,from)=>{
  	console.log('afterEach',to,from)
  	if(to.meta.title){
  	document.title = to.meta.title // 修改网页的 title
  	}else{
  	document.title = 'vue_test'
  	}
  	})

• 独显守卫

  	//beforeEnter 为路由的一个属性
  	beforeEnter(to,from,next){
  	console.log('beforeEnter',to,from)
  	if(to.meta.isAuth){ // 判断当前路由是否需要进行权限控制
  	if(localStorage.getItem('school') === 'atguigu'){
  	next()
  	}else{
  	alert('暂无权限查看')
  	// next({name:'guanyu'})
  	}
  	}else{
  	next()
  	}
  	}

• 组件内守卫

  	// 进入守卫：通过路由规则，进入该组件时被调用
  	beforeRouteEnter (to, from, next) {
  	},
  	// 离开守卫：通过路由规则，离开该组件时被调用
  	beforeRouteLeave (to, from, next) {
  	}

完整的导航解析流程

1. 导航被触发。

2. 在失活的组件里调用 beforeRouteLeave 守卫。

3. 调用全局的 beforeEach 守卫。

4. 在重用的组件里调用 beforeRouteUpdate 守卫 (2.2+)。

5. 在路由配置里调用 beforeEnter 。

6. 解析异步路由组件。

7. 在被激活的组件里调用 beforeRouteEnter 。

8. 调用全局的 beforeResolve 守卫 (2.5+)。

9. 导航被确认。

10. 调用全局的 afterEach 钩子。

11. 触发 DOM 更新。

12. 调用 beforeRouteEnter 守卫中传给 next 的回调函数，创建好的组件实例会作为回调函数的参数传入。

# 缓存路由组件

作用：

​ 让不展示的路由组件保持挂载，不被销毁。

代码实例：

//XXX为组件名；XXX也可以为数组，包含多个组件名
<keep-alive include="XXX"> 
    <router-view></router-view>
</keep-alive>

# 路由独有的钩子

1. activated 路由组件被激活时触发。
2. deactivated 路由组件失活时触发。

使用方式与其它生命周期的使用方式一样。

# replace 属性

1. 作用：控制路由跳转时操作浏览器历史记录的模式
2. 浏览器的历史记录有两种写入方式：分别为 push 和 replace ， push 是追加历史记录， replace 是替换当前记录。路由跳转时候默认为 push
3. 如何开启 replace 模式： <router-link replace .......>News</router-link>

# 路由的两种工作模式

hash 模式

hash 值：# 及其后面的内容就是 hash 值，hash 值不会包含在 HTTP 请求中，即：hash 值不会带给服务器。

特点：

1. 地址中永远带着 #号，不美观 ；
2. 若以后将地址通过第三方手机 app 分享，若 app 校验严格，则地址会被标记为不合法；
3. 兼容性较好；

history 模式

特点：

1. 地址干净，美观 。
2. 兼容性和 hash 模式相比略差。
3. 应用部署上线时需要后端人员支持，解决刷新页面服务端 404 的问题。

(3 条消息) 【面试】前端路由 hash 和 history 的区别_sqwu 的博客 - CSDN 博客_hash 和 history

# webStorage

1. 存储内容大小一般支持 5MB 左右（不同浏览器可能还不一样）

2. 浏览器端通过 Window.sessionStorage 和 Window.localStorage 属性来实现本地存储机制。

3. 相关 API：

   1. xxxxxStorage.setItem('key', 'value');
      该方法接受一个键和值作为参数，会把键值对添加到存储中，如果键名存在，则更新其对应的值。

   2. xxxxxStorage.getItem('person');

      ​ 该方法接受一个键名作为参数，返回键名对应的值。

   3. xxxxxStorage.removeItem('key');

      ​ 该方法接受一个键名作为参数，并把该键名从存储中删除。

   4. xxxxxStorage.clear()

      ​ 该方法会清空存储中的所有数据。

4. 备注：

   1. SessionStorage 存储的内容会随着浏览器窗口关闭而消失。
   2. LocalStorage 存储的内容，需要手动清除才会消失。
   3. xxxxxStorage.getItem(xxx) 如果 xxx 对应的 value 获取不到，那么 getItem 的返回值是 null。
   4. JSON.parse(null) 的结果依然是 null。
   5. 一般配合深度监视使用。

# 组件的自定义事件

1. 一种组件间通信的方式，适用于：子组件 ===> 父组件

2. 使用场景：A 是父组件，B 是子组件，B 想给 A 传数据，那么就要在 A 中给 B 绑定自定义事件（事件的回调在 A 中）。

3. 绑定自定义事件：

   1. 第一种方式，在父组件中： <Demo @atguigu="test"/> 或 <Demo v-on:atguigu="test"/>

   2. 第二种方式，在父组件中：

      	<Demo ref="demo"/>
      	......
      	mounted(){
      	this.$refs.xxx.$on('atguigu',this.test)
      	}

   3. 若想让自定义事件只能触发一次，可以使用 once 修饰符，或 $once 方法。

4. 触发自定义事件： this.$emit('atguigu',数据)

5. 解绑自定义事件 this.$off('atguigu')

   如果自定义事件有多个则参数部分放入一个数组；如果要解除所有自定义事件，还可以不传参数。

6. 组件上也可以绑定原生 DOM 事件，需要使用 .native 修饰符。

7. 注意：通过 this.$refs.xxx.$on('atguigu',回调) 绑定自定义事件时，回调要么配置在 methods 中，要么用箭头函数，否则 this 指向会出问题！

# 全局事件总线

全局事件总线（GlobalEventBus）是一种组件间通信的方式，适用于任意组件间通信。

全局事件总线的安装：

//main.js

new Vue({

	......

	beforeCreate() {

		Vue.prototype.$bus = this // 安装全局事件总线，$bus 就是当前应用的 vm

	},

    ......

})

使用事件总线：

接收数据：A 组件想接收数据，则在 A 组件中给 $bus 绑定自定义事件，事件的回调留在 A 组件自身。

methods(){

  demo(data){......}

}

......

mounted() {

  this.$bus.$on('xxxx',this.demo)

}

提供数据： this.$bus.$emit('xxxx',数据)

注意事项：

​ 最好在 beforeDestroy 钩子中，用 $off 去解绑当前组件所用到的事件。

# TodoList 案例

• 组件化编码流程：

  1. 拆分静态组件：组件要按照功能点拆分，命名不要与 html 元素冲突；

  2. 实现动态组件：考虑好数据的存放位置，数据是一个组件在用，还是一些组件在用：

     一个组件在用：放在组件自身即可；

     一些组件在用：放在他们共同的父组件上（状态提升）；

  3. 实现交互：从绑定事件开始。

• props 适用于：

  • 父组件 ==> 子组件 通信
  • 子组件 ==> 父组件 通信（要求父先给子一个函数）

• 使用 v-model 时要切记：v-model 绑定的值不能是 props 传过来的值，因为 props 是不可以修改的！

• props 传过来的若是对象类型的值，修改对象中的属性时 Vue 不会报错，但不推荐这样做。

• 组件间的通信规则：

  • 父传子：使用 props ；
  • 子传父：组件的自定义事件；
  • 兄弟间 / 爷孙间：全局事件总线；

• 输入框的焦点问题：

  • 失去焦点 <input @blur='xxx()' ref='yyy'>

  • 获得焦点

    	xxx(){
    	this.$nextTick(function () {
    	this.$refs.inputTitle.focus();
    	});
    	}

• nextTick

  • 语法： this.$nextTick(回调函数)
  • 作用：在下一次 DOM 更新结束后执行其指定的回调，它也是声明周期的钩子之一。
  • 什么时候用：当改变数据后，要基于更新后的新 DOM 进行某些操作时，要在 nextTick 所指定的回调函数中执行。

代码实例：

App.vue

<template>
  <div id="root">
    <div class="todo-container">
      <div class="todo-wrap">
        <MyHeader :receive="receive" />
        <MyList
          :todos="todos"
          :checkTodo="checkTodo"
          :deleteTodo="deleteTode"
        />
        <MyFooter
          :todos="todos"
          :checkAllTodo="checkAllTodo"
          :clearAllTodo="clearAllTodo"
        />
      </div>
    </div>
  </div>
</template>

<script>
import MyHeader from "./components/MyHeader.vue";
import MyFooter from "./components/MyFooter.vue";
import MyList from "./components/MyList.vue";

export default {
  name: "App",
  components: {
    MyHeader,
    MyFooter,
    MyList,
  },
  //浏览器存储读取
  data() {
    return {
      todos: JSON.parse(localStorage.getItem("todos")) || [],
    };
  },
  //深度监视与浏览器存储
  watch: {
    todos: {
      deep: true,
      handler(value) {
        localStorage.setItem("todos", JSON.stringify(value));
      },
    },
  },
  methods: {
    receive(todoObj) {
      this.todos.unshift(todoObj);
    },
    checkTodo(id) {
      this.todos.forEach((todo) => {
        if (todo.id === id) todo.done = !todo.done;
      });
    },
    deleteTode(id) {
      this.todos = this.todos.filter((todo) => {
        return todo.id !== id;
      });
    },
    checkAllTodo(done) {
      this.todos.forEach((todo) => (todo.done = done));
    },
    clearAllTodo() {
      this.todos = this.todos.filter((todo) => {
        return !todo.done;
      });
    },
  },
};
</script>

<style>
/*base*/
body {
  background: #fff;
}

.btn {
  display: inline-block;
  padding: 4px 12px;
  margin-bottom: 0;
  font-size: 14px;
  line-height: 20px;
  text-align: center;
  vertical-align: middle;
  cursor: pointer;
  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.2),
    0 1px 2px rgba(0, 0, 0, 0.05);
  border-radius: 4px;
}

.btn-danger {
  color: #fff;
  background-color: #da4f49;
  border: 1px solid #bd362f;
}

.btn-danger:hover {
  color: #fff;
  background-color: #bd362f;
}

.btn:focus {
  outline: none;
}

.todo-container {
  width: 600px;
  margin: 0 auto;
}
.todo-container .todo-wrap {
  padding: 10px;
  border: 1px solid #ddd;
  border-radius: 5px;
}
</style>

MyHeader.vue

<template>
  <div class="todo-header">
    <input
      type="text"
      placeholder="请输入你的任务名称，按回车键确认"
      @keyup.enter="add"
      v-model="title"
    />
  </div>
</template>

<script>
import { nanoid } from "nanoid";
export default {
  name: "MyHooter",
  props: ["receive"],
  data() {
    return {
      title: "",
    };
  },
  methods: {
    add() {
      if (!this.title.trim()) {
        return alert("输入不能为空");
      }
      const todoObj = {
        id: nanoid(),
        title: this.title,
        done: false,
      };
      this.receive(todoObj);
      this.title = "";
    },
  },
};
</script>

<style scoped>
/*header*/
.todo-header input {
  width: 560px;
  height: 28px;
  font-size: 14px;
  border: 1px solid #ccc;
  border-radius: 4px;
  padding: 4px 7px;
}

.todo-header input:focus {
  outline: none;
  border-color: rgba(82, 168, 236, 0.8);
  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075),
    0 0 8px rgba(82, 168, 236, 0.6);
}
</style>

MyList.vue

<template>
  <ul class="todo-main">
    <MyItem
      v-for="todoObj in todos"
      :key="todoObj.id"
      :todo="todoObj"
      :checkTodo="checkTodo"
      :deleteTodo="deleteTodo"
    />
  </ul>
</template>

<script>
import MyItem from "./MyItem.vue";
export default {
  name: "MyList",
  components: {
    MyItem,
  },
  props: ["todos", "checkTodo", "deleteTodo"],
};
</script>


<style scoped>
/*main*/
.todo-main {
  margin-left: 0px;
  border: 1px solid #ddd;
  border-radius: 2px;
  padding: 0px;
}

.todo-empty {
  height: 40px;
  line-height: 40px;
  border: 1px solid #ddd;
  border-radius: 2px;
  padding-left: 5px;
  margin-top: 10px;
}
</style>

MyItem.vue

<template>
  <li>
    <label>
      <input
        type="checkbox"
        :checked="todo.done"
        @change="handlecheck(todo.id)"
      />
      <!-- 修改了props，违背了原则，但可以完成功能 -->
      <!-- <input type="checkbox" v-model="todo.done" /> -->
      <span>{{ todo.title }}</span>
    </label>
    <button class="btn btn-danger" @click="del(todo.id)">删除</button>
  </li>
</template>

<script scoped>
export default {
  name: "MyItem",
  props: ["todo", "checkTodo", "deleteTodo"],
  methods: {
    handlecheck(id) {
      this.checkTodo(id);
    },
    del(id) {
      if (confirm("确定删除吗")) {
        this.deleteTodo(id);
      }
    },
  },
};
</script>

<style scoped>
/*item*/
li {
  list-style: none;
  height: 36px;
  line-height: 36px;
  padding: 0 5px;
  border-bottom: 1px solid #ddd;
}

li label {
  float: left;
  cursor: pointer;
}

li label li input {
  vertical-align: middle;
  margin-right: 6px;
  position: relative;
  top: -1px;
}

li button {
  float: right;
  display: none;
  margin-top: 3px;
}

li:before {
  content: initial;
}

li:last-child {
  border-bottom: none;
}
li:hover {
  background-color: #ddd;
}
li:hover button {
  display: block;
}
</style>

MyFooter.vue

<template>
  <div class="todo-footer" v-show="todos.length">
    <label>
      <input type="checkbox" :checked="isAll" @click="checkAll" />
      <!-- <input type="checkbox" v-model="isAll" /> -->
    </label>
    <span>
      <span>已完成{{ doneTatal }}</span> / 全部{{ todos.length }}
    </span>
    <button class="btn btn-danger" @click="clearAll">清除已完成任务</button>
  </div>
</template>

<script>
export default {
  name: "MyFooter",
  props: ["todos", "checkAllTodo", "clearAllTodo"],
  computed: {
    doneTatal() {
      // this.todos.reduce((pre, currrnt) => {
      //   return pre + (currrnt.done ? 1 : 0);
      // }, 0);
      //简写形式
      return this.todos.reduce(
        (pre, current) => pre + (current.done ? 1 : 0),
        0
      );
    },
    //v-model的回调方法（计算属性的完整写法）
    // isAll: {
    //   get() {
    //     return this.doneTatal === this.todos.length && this.todos.length !== 0;
    //   },
    //   set(value) {
    //     this.checkAllTodo(value);
    //   },
    // },
    isAll() {
      return this.doneTatal === this.todos.length && this.todos.length !== 0;
    },
  },
  methods: {
    checkAll(e) {
      this.checkAllTodo(e.target.checked); //e.target.value也行
    },
    clearAll() {
      this.clearAllTodo();
    },
  },
};
</script>

<style scoped>
/*footer*/
.todo-footer {
  height: 40px;
  line-height: 40px;
  padding-left: 6px;
  margin-top: 5px;
}

.todo-footer label {
  display: inline-block;
  margin-right: 20px;
  cursor: pointer;
}

.todo-footer label input {
  position: relative;
  top: -1px;
  vertical-align: middle;
  margin-right: 5px;
}

.todo-footer button {
  float: right;
  margin-top: 5px;
}
</style>

# pubsub

​ 消息的订阅与发布（pubsub）是一种组件间通信的方式，适用于任意组件间通信。

使用步骤：

1. 安装 pubsub： npm i pubsub-js

2. 引入: import pubsub from 'pubsub-js'

3. 接收数据：A 组件想接收数据，则在 A 组件中订阅消息，订阅的回调留在 A 组件自身；

   	methods(){
   	demo(data){......}
   	}
   	......
   	mounted() {
   	this.pid = pubsub.subscribe('xxx',this.demo) // 订阅消息
   	}

4. 提供数据： pubsub.publish('xxx',数据) ；

5. 最好在 beforeDestroy 钩子中，用 PubSub.unsubscribe(pid) 去取消订阅。

# 过渡与动画

# Vue 封装的过度与动画

功能：

​ 在插入、更新或移除 DOM 元素时，在合适的时候给元素添加样式类名。

写法：

• ​ 元素进入的样式：

  1. v-enter：进入的起点
  2. v-enter-active：进入过程中
  3. v-enter-to：进入的终点

• 元素离开的样式：

  1. v-leave：离开的起点
  2. v-leave-active：离开过程中
  3. v-leave-to：离开的终点

• 过渡代码实例：

  <style scoped>
  	h1{
  		background-color: orange;
  	}
  	/* 进入的起点、离开的终点 */
  	.hello-enter,.hello-leave-to{
  		transform: translateX(-100%);
  	}
  	.hello-enter-active,.hello-leave-active{
  		transition: 0.5s linear;
  	}
  	/* 进入的终点、离开的起点 */
  	.hello-enter-to,.hello-leave{
  		transform: translateX(0);
  	}
  </style>
  

• 动画代码实例：

  	.bounce-enter-active {
  	animation: bounce-in .5s;
  	}
  	.bounce-leave-active {
  	animation: bounce-in .5s reverse;
  	}
  	@keyframes bounce-in {
  	0% {
  	transform: scale(0);
  	}
  	50% {
  	transform: scale(1.5);
  	}
  	100% {
  	transform: scale(1);
  	}
  	}

• 使用 <transition> 包裹要过度或动画的元素，并配置 name 属性：

  <transition name="hello">
  	<h1 v-show="isShow">你好啊！</h1>
  </transition>
  

  备注：若有多个元素需要过度，则需要使用： <transition-group> ，且每个元素都要指定 key 值。

# 第三方库的使用

常用的第三方库动画的地址：animate.css - npm (npmjs.com)

代码实例：

<template>
	<div>
		<button @click="isShow = !isShow">显示/隐藏</button>
		<transition-group 
			appear
			name="animate__animated animate__bounce" 
			enter-active-class="animate__swing"
			leave-active-class="animate__backOutUp"
		>
			<h1 v-show="!isShow" key="1">你好啊！</h1>
			<h1 v-show="isShow" key="2">尚硅谷！</h1>
		</transition-group>
	</div>
</template>

<script>
	import 'animate.css'
	export default {
		name:'Test',
		data() {
			return {
				isShow:true
			}
		},
	}
</script>

<style scoped>
	h1{
		background-color: orange;
	}
</style>

# vue 脚手架配置代理

方法一

​ 在 vue.config.js 中添加如下配置：

devServer:{

  proxy:"http://localhost:5000"

}

说明：

1. 优点：配置简单，请求资源时直接发给前端（8080）即可。
2. 缺点：不能配置多个代理，不能灵活的控制请求是否走代理。
3. 工作方式：若按照上述配置代理，当请求了前端不存在的资源时，那么该请求会转发给服务器 （优先匹配前端资源）

方法二

​ 编写 vue.config.js 配置具体代理规则：

module.exports = {

	devServer: {

      proxy: {

      '/api1': {// 匹配所有以 '/api1' 开头的请求路径

        target: 'http://localhost:5000',// 代理目标的基础路径

        changeOrigin: true,

        pathRewrite: {'^/api1': ''}

      },

      '/api2': {// 匹配所有以 '/api2' 开头的请求路径

        target: 'http://localhost:5001',// 代理目标的基础路径

        changeOrigin: true,

        pathRewrite: {'^/api2': ''}

      }

    }

  }

}

/*

   changeOrigin 设置为 true 时，服务器收到的请求头中的 host 为：localhost:5000

   changeOrigin 设置为 false 时，服务器收到的请求头中的 host 为：localhost:8080

   changeOrigin 默认值为 true

*/

说明：

1. 优点：可以配置多个代理，且可以灵活的控制请求是否走代理。
2. 缺点：配置略微繁琐，请求资源时必须加前缀。

# 组件通信方式总结

# props

​ 适用于父子组件通信：父组件传参数给子组件；

Props | Vue.js (vuejs.org)

# 自定义事件

​ 适用于父子组件通信：子组件传数据给父组件（$on 与 $emit）；

# 全局事件总线 $bus

​ 万能

Vue.prototype.$bus=this;

# Vuex

​ 万能

# 插槽

​ 父子组件通信：一般传结构

默认插槽，具名插槽，作用域插槽

# V-model

​ 父子组件通信：作用于组件上可实现某数据在父子组件间的双向绑定

# 路由懒加载

const foo = ()=>{
	return import('xxx/pages/Home') //返回一个Promise
}
{
	path:'xxx',
	component:foo,
}
//简洁写法
{
	path:'xxx',
	component:()=>import('xxx/pages/Home'),
}

# 问题与解决方案

Vue 的面试题

1. 前端面试题 -- Vue - SegmentFault 思否

报错

• Vue 报错：component has been registered but not used，即定义好的组件未被使用