Vue.js 面试题大全

---

一、Vue概念（特点、原理）

1.Vue的优点

• 轻量级框架：只关注视图层，是一个构建数据的视图集合，大小只有几十 kb ；
• 简单易学：国人开发，中文文档，不存在语言障碍 ，易于理解和学习；
• 双向数据绑定：保留了 angular 的特点，在数据操作方面更为简单；
• 组件化：保留了 react 的优点，实现了 html 的封装和重用，在构建单页面应用方面有着独特的优势；
• 视图，数据，结构分离：使数据的更改更为简单，不需要进行逻辑代码的修改，只需要操作数据就能完成相关操作；
• 虚拟DOM：dom 操作是非常耗费性能的， 不再使用原生的 dom 操作节点，极大解放 dom 操作，但具体操作的还是 dom 不过是换了另一种方式；
• 运行速度更快：相比较于 react 而言，同样是操作虚拟 dom ，就性能而言， vue 存在很大的优势。

2.说说你对SPA单页面的理解，它的优缺点分别是什么？

SPA（ single page application ）仅在 Web 页面初始化时加载相应的 HTML、JavaScript 和 CSS。一旦页面加载完成，SPA 不会因为用户的操作而进行页面的重新加载或跳转，而页面的变化是利用路由机制实现 HTML 内容的变换，避免页面的重新加载。

优点

• 用户体验好+减轻服务器压力，内容的改变不需要重新加载整个页面，避免了不必要的跳转和重复渲染。
• 前后端职责分离，架构清晰，前端进行交互逻辑，后端负责数据处理。

缺点

• 初次加载耗时多
• 不能使用浏览器的前进后退功能，由于单页应用在一个页面中显示所有的内容，所以，无法前进后退
• 不利于搜索引擎检索：由于所有的内容都在一个页面中动态替换显示，所以在 SEO 上其有着天然的弱势。

3. SPA首屏加载速度慢的怎么解决？

首屏时间（First Contentful Paint），指的是浏览器从响应用户输入网址地址，到首屏内容渲染完成的时间，此时整个网页不一定要全部渲染完成，但需要展示当前视窗需要的内容；

加载慢的原因

• 网络延时问题
• 资源文件体积是否过大
• 资源是否重复发送请求去加载了
• 加载脚本的时候，渲染内容堵塞了

常见的几种SPA首屏优化方式

• 减小入口文件积
• 静态资源本地缓存
• UI框架按需加载
• 图片资源的压缩
• 组件重复打包
• 开启GZip压缩
• 使用SSR

4. Vue初始化过程中（new Vue(options)）都做了什么？

1. 处理组件配置项；初始化根组件时进行了选项合并操作，将全局配置合并到根组件的局部配置上；初始化每个子组件时做了一些性能优化，将组件配置对象上的一些深层次属性放到 m.$options 选项中，以提高代码的执行效率；
2. 初始化组件实例的关系属性，比如parent、children、root、refs等
3. 处理自定义事件
4. 调用 beforeCreate 钩子函数
5. 初始化组件的 inject 配置项，得到 ret[key] = val 形式的配置对象，然后对该配置对象进行响应式处理，并代理每个 key 到 vm 实例上
6. 数据响应式，处理 props、methods、data、computed、watch 等选项
7. 解析组件配置项上的 provide 对象，将其挂载到 vm._provided 属性上
8. 调用 created 钩子函数
9. 如果发现配置项上有 el 选项，则自动调用 $mount 方法，也就是说有了 el 选项，就不需要再手动调用 $mount 方法，反之，没提供 el 选项则必须调用 $mount
10. 接下来则进入挂载阶段

// core/instance/init.js
export function initMixin (Vue: Class<Component>) {
  Vue.prototype._init = function (options?: Object) {
      const vm: Component = this
      vm._uid = uid++
      
      // 如果是Vue的实例，则不需要被observe
      vm._isVue = true
      
      if (options && options._isComponent) {
        // optimize internal component instantiation
        // since dynamic options merging is pretty slow, and none of the
        // internal component options needs special treatment.
        initInternalComponent(vm, options)
      } else {
        vm.$options = mergeOptions(
          resolveConstructorOptions(vm.constructor),
          options || {},
          vm
        )
      }
      
      if (process.env.NODE_ENV !== 'production') {
        initProxy(vm)
      } else {
        vm._renderProxy = vm
      }

      vm._self = vm

      initLifecycle(vm)
      initEvents(vm)
      callHook(vm, 'beforeCreate')
      initInjections(vm) // resolve injections before data/props

      initState(vm)
      initProvide(vm) // resolve provide after data/props
      callHook(vm, 'created')
      
      if (vm.$options.el) {
        vm.$mount(vm.$options.el)
      }
  }
}

5. 对MVVM的理解？

MVVM 由 Model、View、ViewModel 三部分构成，

• Model 层代表数据模型，也可以在Model中定义数据修改和操作的业务逻辑；
• View 代表UI 组件，它负责将数据模型转化成UI 展现出来；
• ViewModel 是一个同步View 和 Model的对象。

在MVVM架构下，View 和 Model 之间并没有直接的联系，而是通过ViewModel进行交互，Model 和 ViewModel 之间的交互是双向的， 因此View 数据的变化会同步到Model中，而Model 数据的变化也会立即反应到View 上。

ViewModel 通过双向数据绑定把 View 层和 Model 层连接了起来，而View 和 Model 之间的同步工作完全是自动的，无需人为干涉，因此开发者只需关注业务逻辑，不需要手动操作DOM， 不需要关注数据状态的同步问题，复杂的数据状态维护完全由 MVVM 来统一管理。

6. Vue数据双向绑定原理 ★★★★★

实现mvvm的数据双向绑定，是采用数据劫持结合发布者-订阅者模式的方式，通过Object.defineProperty()来给各个属性添加setter，getter并劫持监听，在数据变动时发布消息给订阅者，触发相应的监听回调。就必须要实现以下几点：

1、实现一个数据监听器Observer，能够对数据对象的所有属性进行监听，如有变动可拿到最新值并通知订阅者

2、实现一个指令解析器Compile，对每个元素节点的指令进行扫描和解析，根据指令模板替换数据，以及绑定相应的更新函数

3、实现一个Watcher，作为连接Observer和Compile的桥梁，能够订阅并收到每个属性变动的通知，执行指令绑定的相应回调函数，从而更新视图

具体介绍：

如右图所示，new Vue一个实例对象a，其中有一个属性a.b，那么在实例化的过程中，通过Object.defineProperty()会对a.b添加getter和setter，同时Vue.js会对模板做编译，解析生成一个指令对象（这里是v-text指令），每个指令对象都会关联一个Watcher,当对a.b求值的时候，就会触发它的getter，当修改a.b的值的时候，就会触发它的setter，同时会通知被关联的Watcher，然后Watcher就会再次对a.b求值，计算对比新旧值，当值改变了，Watcher就会通知到指令，调用指令的update()方法，由于指令是对DOM的封装，所以就会调用DOM的原生方法去更新视图，这样就完成了数据改变到视图更新的一个自动过程

原理介绍：

大致上是使用数据劫持和订阅发布实现双向绑定。通过实例化一个Vue对象的时候，对其数据属性遍历，通过Object.defineProperty()给数据对象添加setter getter，并对模板做编译生成指令对象，每个指令对象绑定一个watcher对象，然后对数据赋值的时候就会触发setter，这时候相应的watcher对其再次求值，如果值确实发生变化了，就会通知相应的指令，调用指令的update方法，由于指令是对DOM的封装，这时候会调用DOM的原生方法对DOM做更新，这就实现了数据驱动DOM的变化。同时vue还会对DOM做事件监听，如果DOM发生变化，vue监听到，就会修改相应的data.

8 .Vue3.x响应式数据原理

Vue3.x改用Proxy替代Object.defineProperty。

因为Proxy可以直接监听对象和数组的变化，并且有多达13种拦截方法。并且作为新标准将受到浏览器厂商重点持续的性能优化。

Proxy只会代理对象的第一层，Vue3是怎样处理这个问题的呢？

判断当前Reflect.get的返回值是否为Object，如果是则再通过reactive方法做代理， 这样就实现了深度观测。

监测数组的时候可能触发多次get/set，那么如何防止触发多次呢？我们可以判断key是否为当前被代理对象target自身属性，也可以判断旧值与新值是否相等，只有满足以上两个条件之一时，才有可能执行trigger。

9. Vue3.0 里为什么要用 Proxy API替代 defineProperty API？

1.defineProperty API 的局限性最大原因是它只能针对单例属性做监听。
Vue2.x中的响应式实现正是基于defineProperty中的descriptor，对 data 中的属性做了遍历 + 递归，为每个属性设置了 getter、setter。这也就是为什么 Vue 只能对 data 中预定义过的属性做出响应的原因。

2.Proxy API的监听是针对一个对象的，那么对这个对象的所有操作会进入监听操作， 这就完全可以代理所有属性，将会带来很大的性能提升和更优的代码。
Proxy 可以理解成，在目标对象之前架设一层“拦截”，外界对该对象的访问，都必须先通过这层拦截，因此提供了一种机制，可以对外界的访问进行过滤和改写。

3.响应式是惰性的。
在 Vue.js 2.x 中，对于一个深层属性嵌套的对象，要劫持它内部深层次的变化，就需要递归遍历这个对象，执行 Object.defineProperty 把每一层对象数据都变成响应式的，这无疑会有很大的性能消耗。
在 Vue.js 3.0 中，使用 Proxy API 并不能监听到对象内部深层次的属性变化，因此它的处理方式是在 getter 中去递归响应式，这样的好处是真正访问到的内部属性才会变成响应式，简单的可以说是按需实现响应式，减少性能消耗。

10. Proxy 与 Object.defineProperty 优劣对比

1.Proxy 可以直接监听对象而非属性；

2.Proxy 可以直接监听数组的变化；

3.Proxy 有多达 13 种拦截方法,不限于 apply、ownKeys、deleteProperty、has 等等是 Object.defineProperty 不具备的；

4.Proxy 返回的是一个新对象,我们可以只操作新的对象达到目的,而 Object.defineProperty 只能遍历对象属性直接修改；

5.Proxy 作为新标准将受到浏览器厂商重点持续的性能优化，也就是传说中的新标准的性能红利；

6.Object.defineProperty 的优势：兼容性好，支持 IE9，而 Proxy 的存在浏览器兼容性问题,而且无法用 polyfill 磨平，因此 Vue 的作者才声明需要等到下个大版本( 3.0 )才能用 Proxy 重写。

11. 为什么vue采用异步渲染 ★★★

vue是组件级更新，当前组件里的数据变了，它就会去更新这个组件。当数据更改一次组件就要重新渲染一次，性能不高，为了防止数据一更新就更新组件，所以做了个异步更新渲染。（核心的方法就是nextTick）

源码实现原理：

当数据变化后会调用notify方法，将watcher遍历，调用update方法通知watcher进行更新，这时候watcher并不会立即去执行，在update中会调用queueWatcher方法将watcher放到了一个队列里，在queueWatcher会根据watcher的进行去重，多个属性依赖一个watcher，如果队列中没有该watcher就会将该watcher添加到队列中，然后通过nextTick异步执行flushSchedulerQueue方法刷新watcher队列。flushSchedulerQueue中开始会触发一个before的方法，其实就是beforeUpdate，然后watcher.run() 才开始真正执行watcher，执行完页面就渲染完成啦，更新完成后会调用updated钩子。

简单步骤：

• 响应式数据更新
• deep.notify : -> 通知watcher进行更新操作
• subs[i].update( ) : -> 依次调用watcher的update
• queueWatcher : -> 将watcher去重放到队列中
• nextTick(flushSchedulerQueue) : -> 异步刷新watcher队列

12. Vue 的异步更新机制是如何实现的？

• Vue 的异步更新机制的核心是利用了浏览器的异步任务队列来实现的，首选微任务队列，宏任务队列次之。

• 当响应式数据更新后，会调用 dep.notify 方法，通知 dep 中收集的 watcher 去执行 update 方法，watcher.update 将 watcher 自己放入一个 watcher 队列（全局的 queue 数组）。

• 然后通过 nextTick 方法将一个刷新 watcher 队列的方法（flushSchedulerQueue）放入一个全局的 callbacks 数组中。

• 如果此时浏览器的异步任务队列中没有一个叫 flushCallbacks 的函数，则执行 timerFunc 函数，将 flushCallbacks 函数放入异步任务队列。如果异步任务队列中已经存在 flushCallbacks 函数，等待其执行完成以后再放入下一个 flushCallbacks 函数。

• flushCallbacks 函数负责执行 callbacks 数组中的所有 flushSchedulerQueue 函数。

• flushSchedulerQueue 函数负责刷新 watcher 队列，即执行 queue 数组中每一个 watcher 的 run 方法，从而进入更新阶段，比如执行组件更新函数或者执行用户 watch 的回调函数。

13. $nextTick的理解 ★★★

用法：

在下次 DOM 更新循环结束之后执行延迟回调。在修改数据之后立即使用这个方法，获取更新后的 DOM。

Vue.nextTick( [callback, context] )

// 参数：
{Function} [callback]
{Object} [context]

为什么？

Vue 实现响应式并不是数据发生变化之后 DOM 立即变化，而是按一定的策略进行 DOM 的更新。Vue 在更新 DOM 时是异步执行的。只要侦听到数据变化，Vue 将开启一个队列，并缓冲在同一事件循环中发生的所有数据变更。如果同一个 watcher 被多次触发，只会被推入到队列中一次。这种在缓冲时去除重复数据对于避免不必要的计算和 DOM 操作是非常重要的。然后，在下一个的事件循环“tick”中，Vue 刷新队列并执行实际 (已去重的) 工作。

所以为了在数据变化之后等待 Vue 完成更新 DOM，可以在数据变化之后立即使用 Vue.nextTick(callback)。这样回调函数将在 DOM 更新完成后被调用。

使用场景

在你更新完数据后，需要及时操作渲染好的 DOM时

14. Vue.set 改变数组和对象中的属性

在一个组件实例中，只有在data里初始化的数据才是响应的，Vue不能检测到对象属性的添加或删除，没有在data里声明的属性不是响应的,所以数据改变了但是不会在页面渲染；

解决办法：

使用 Vue.set(object, key, value) 方法将响应属性添加到嵌套的对象上

15. vm.$set(obj, key, val) 做了什么？

由于 Vue 无法探测对象新增属性或者通过索引为数组新增一个元素，所以这才有了vm.set，它是Vue.set的别名。vm.set 用于向响应式对象添加一个新的 property，并确保这个新的 property 同样是响应式的，并触发视图更新。

• 为对象添加一个新的响应式数据：调用 defineReactive 方法为对象增加响应式数据，然后执行 dep.notify 进行依赖通知，更新视图
• 为数组添加一个新的响应式数据：通过 splice 方法实现

16. vue为什么在 HTML 中监听事件？

你可能注意到这种事件监听的方式违背了关注点分离 (separation of concern) 这个长期以来的优良传统。但不必担心，因为所有的 Vue.js 事件处理方法和表达式都严格绑定在当前视图的 ViewModel 上，它不会导致任何维护上的困难。实际上，使用 v-on 或 @ 有几个好处：

• 扫一眼 HTML 模板便能轻松定位在 JavaScript 代码里对应的方法。
• 因为你无须在 JavaScript 里手动绑定事件，你的 ViewModel 代码可以是非常纯粹的逻辑，和 DOM 完全解耦，更易于测试。
• 当一个 ViewModel 被销毁时，所有的事件处理器都会自动被删除。你无须担心如何清理它们。

二、vue属性

源码定义的initState函数内部执行的顺序：props>methods>data>computed>watch

1. data 数据对象

常见问题：

（1）vue中组件的data为什么是一个函数？而new Vue 实例里，data 可以直接是一个****对象

答案：

我们知道，Vue组件其实就是一个Vue实例。

JS中的实例是通过构造函数来创建的，每个构造函数可以new出很多个实例，那么每个实例都会继承原型上的方法或属性。

Vue的data数据其实是Vue原型上的属性，数据存在于内存当中。Vue为了保证每个实例上的data数据的独立性，规定了必须使用函数，而不是对象。

因为使用对象的话，每个实例（组件）上使用的data数据是相互影响的，这当然就不是我们想要的了。对象是对于内存地址的引用，直接定义一个对象的话组件之间都会使用这个对象，这样会造成组件之间数据相互影响。

使用函数后，使用的是data()函数，data()函数中的this指向的是当前实例本身，就不会相互影响了。

而 new Vue 的实例，是不会被复用的，因此不存在引用对象的问题。

（2） vue中data的属性可以和methods中方法同名吗，为什么？
答案：

同名，methods的方法名会被data的属性覆盖；调试台也会出现报错信息，但是不影响执行；

原因：源码定义的initState函数内部执行的顺序：props>methods>data>computed>watch

//initState部分源码
export function initState (vm: Component) {
  vm._watchers = []
  const opts = vm.$options
  if (opts.props) initProps(vm, opts.props)
  if (opts.methods) initMethods(vm, opts.methods)
  if (opts.data) {
    initData(vm)
  } else {
    observe(vm._data = {}, true /* asRootData */)
  }
  if (opts.computed) initComputed(vm, opts.computed)
  if (opts.watch && opts.watch !== nativeWatch) {
    initWatch(vm, opts.watch)
  }   
}

2. Directives 指令对象

a. 作用：当表达式的值改变时，将其产生的连带影响，响应式地作用于 DOM。
b. 构成：

• 参数：v-bind/on:href="url";
• 动态参数：v-bind/on:[eventName]="doSomething";
• 修饰符 (modifier) ：v-on:submit.prevent="onSubmit";
  常见修饰符：
  .prevent: 提交事件不再重载页面；
  .stop: 阻止单击事件冒泡；
  .self: 当事件发生在该元素本身而不是子元素的时候会触发；
  .capture: 事件侦听，事件发生的时候会调用
• 缩写：:href="url" @click="doSomething"
  c. 常见指令：v-for 、 v-if 、v-bind、v-on、v-show、v-else、v-model、v-once
  d. 自定义指令：
• 分类：
  1. 全局指令：通过 Vue.directive() 函数注册一个全局的指令。
  语法：Vue.directive(directiveName, 配置对象/回调函数)
  2. 局部指令：通过组件的 directives 对象属性，对该组件添加一个局部的指令。
  语法：directives: {directiveName: { }}
• 指令钩子函数：
  • 分类：
    1. bind：只调用一次，指令第一次绑定到元素时调用。在这里可以进行一次性的初始化设置。
    2. inserted：被绑定元素插入父节点时调用 (仅保证父节点存在，但不一定已被插入文档中)。
    3. update：所在组件的 VNode 更新时调用，但是可能发生在其子 VNode 更新之前。指令的值可能发生了改变，也可能没有。但是你可以通过比较更新前后的值来忽略不必要的模板更新 。
    4. componentUpdated：指令所在组件的 VNode 及其子 VNode 全部更新后调用。
    5. unbind：只调用一次，指令与元素解绑时调用。
  • 参数：
    1. el 绑定的元素*
    2. binding 对象
    a. name 指令名*，不包括 v- 前缀
    b. value 指令的绑定值*（作为表达式解析后的结果）
    c. oldvalue 指令绑定的前一个值，仅在 update 和 componentUpdated 钩子中可用，无论值是否改变都可用
    d. expression 指令绑定的表达式（字符串）
    e. arg 传给指令的参数，可选
    f. modifiers 传给指令的修饰符组成的对象，可选，每个修饰符对应一个布尔值
    3. vnode
    4. oldnode
  • 应用场景
    问题：你有写过自定义指令吗？自定义指令的应用场景有哪些？
    防抖、图片懒加载、拖拽功能、一键复制功能、处理失败图片、根据权限控制按钮的显示与隐藏、输入框自动聚焦、下拉菜单（点击下拉菜单本身不会隐藏菜单、点击下拉菜单以外的区域隐藏菜单）、相对时间转换（类似微博、朋友圈发布动态后的相对时间，比如刚刚、两分钟前等等）

常见问题：

1. v-if 和 v-show的区别

• 相同点：v-show和v-if都能控制元素的显示和隐藏。
• 不同点：
  • 实现本质方法不同:v-show本质就是通过设置css中的display设置为none;控制隐藏v-if是动态的向DOM树内添加或者删除DOM元素;
  • v-show都会编译，初始值为false，只是将display设为none，但它也编译了;v-if初始值为false，就不会编译了
    总结：v-show只编译一次，后面其实就是控制css，而v-if不停的销毁和创建，如果要频繁切换某节点时，故v-show性能更好一点。

2. 避免 v-if 和 v-for 一起使用，永远不要在一个元素上同时使用 v-if 和 v-for

• 优先级：vue2.x版本中， v-for 的优先级比 v-if 的高，所以每次渲染时都会先循环再进行条件判断，而又因为 v-if 会根据条件为 true 或 false来决定渲染与否的，所以如果将 v-if 和 v-for一起使用时会特别消耗性能，如果有语法检查，则会报语法的错误。
• 解决方案：

1. 将 v-if 放在外层嵌套 template （页面渲染不生成 DOM节点），在这一层进行 v-if 判断，然后在内部进行 v-for 循环
2. 如果条件出现在循环内部，不得不放在一起，可先对数据在计算属性数据中进行过滤，然后再进行遍历渲染；

vue2.x版本中，当 v-if 与 v-for 一起使用时，v-for 具有比 v-if 更高的优先级；
vue3.x版本中，当 v-if 与 v-for 一起使用时，v-if 具有比 v-for 更高的优先级。

3. 虚拟DOM中key的作用

• 简单的说：key是虚拟DOM对象的标识，在更新显示时key起着极其重要的作用。
• 复杂的说：当状态中的数据发生了变化时，react会根据【新数据】生成【新的虚拟DOM】，随后React进行【新虚拟DOM】与【旧虚拟DOM】的diff比较，比较规则如下：
• 在旧虚拟DOM中找到与新虚拟DOM相同的key
  • 内容没有变化，直接使用原来的真实DOM
  • 内容发生改变，替换掉之前旧的虚拟DOM,生成新的真实DOM
• 在旧虚拟DOM中未找到与新虚拟DOM相同的key
  • 直接生成新的真实DOM

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

• 若对数据进行：逆序添加/逆序删除等破坏顺序的操作，会产生没有必要的真实DOM更新，界面效果虽然没有问题，但是数据过多的话，会效率过低；
• 如果结构中还包含输入类的DOM，会产生错误DOM更新，界面有问题；
• 注意！如果不存在对数据的逆序操作，仅用于渲染表用于展示，使用index作为key是没有问题的。

3. computed 计算属性对象

1. 概念：计算属性是基于它们的响应式依赖进行缓存的。只在相关响应式依赖发生改变时它们才会重新求值。
2. 构成：
   1. getter
   2. setter

computed: {
  fullName: {
    // getter
    get: function () {
      return this.firstName + ' ' + this.lastName
    },
    // setter
    set: function (newValue) {
      var names = newValue.split(' ')
      this.firstName = names[0]
      this.lastName = names[names.length - 1]
    }
  }
}

3. 特点：
   1. 使得数据处理结构清晰；
   2. 依赖于数据，数据更新，处理结果自动更新；
   3. 计算属性内部this指向vm实例；
   4. 在template调用时，直接写计算属性名即可；
   5. 常用的是getter方法，获取数据，也可以使用set方法改变数据；
   6. 相较于methods，不管依赖的数据变不变，methods都会重新计算，但是依赖数据不变的时候computed从缓存中获取，不会重新计算。

4. methods 方法属性对象

5. watch 侦听属性对象

a. 在vue中，使用watch来监听数据的变化(监听机制+事件机制)；

• 1.监听的数据后面可以写成对象形式，包含handler方法，immediate和deep。
• 2.immediate表示在watch中首次绑定的时候，是否执行handler，值为true则表示在watch中声明的时候，就立即执行handler方法，值为false，则和一般使用watch一样，在数据发生变化的时候才执行handler。
• 3.当需要监听一个对象的改变时，普通的watch方法无法监听到对象内部属性的改变，只有data中的数据才能够监听到变化，此时就需要deep属性对对象进行深度监听。

b. 注销：unWatch(); // 手动注销watch

watch: {
  // 第一种方式：监听整个对象，每个属性值的变化都会执行handler
  // 注意：属性值发生变化后，handler执行后获取的 newVal 值和 oldVal 值是一样的
  food: {
    // 每个属性值发生变化就会调用这个函数
    handler(newVal, oldVal) {
      console.log('oldVal:', oldVal)
      console.log('newVal:', newVal)
    },
    // 立即处理 进入页面就触发
    immediate: true,
    // 深度监听 属性的变化
    deep: true
// 基本数据
// 对象和数组都是引用类型，引用类型变量存的是地址，地址没有变，所以不会触发watch。这时我们需要进行深度监听，就需要加上一个属性 deep，值为 true
            },
  // 第二种方式：监听对象的某个属性，被监听的属性值发生变化就会执行函数
  // 函数执行后，获取的 newVal 值和 oldVal 值不一样
  'food.name'(newVal, oldVal) {
      console.log('oldVal:', oldVal)   // 冰激凌
      console.log('newVal:', newVal)   // 棒棒糖
  }
}

// watch监听路由
watch: {
    changeShowType(value) {
      console.log("-----"+value);
    },
    '$route'(to,from){
      console.log(to);   //to表示去往的界面
      console.log(from); //from表示来自于哪个界面
      if(to.path=="/shop/detail"){
        console.log("商品详情");
      }
    }
  },

Watch和computed的区别

• computed支持缓存，只有依赖数据发生改变,才会重新进行计算; 而watch不支持缓存，数据变, 直接会触发相应的操作
• computed不支持异步，当computed内有异步操作时无效，无法监听数据的变化，而watch支持异步
• computed属性值会默认走缓存，计算属性是基于它们的响应式依赖进行缓存的，也就是基于data中声明过或者父组件传递的props中的数据通过计算得到的值; 而watch监听的函数接收两个参数，第一个参数是最新的值，第二个参数是输入之前的值
• 如果一个属性是由其它属性计算而来的，这个属性依赖其它属性，多对一（一个数据受多个数据影响）或者一对一，一般用computed；而当一个属性发生变化时，需要执行对应的操作，一对多（一个数据影响多个数据），一般用watch。

6. 生命周期钩子对象

a. 定义：生命周期通俗说就是Vue实例从创建到销毁的过程，就是生命周期。
b. 分类：创建-挂载-更新-销毁

• beforeCreate（创建前） ：组件实例被创建之初，组件的属性生效之前

  • 特点：beforeCreate生命周期执行的时候，data和methods中的数据都还没有初始化。不能在这个阶段使用data中的数据和methods中的方法
  • 应用：开启加载一个动画

• created（创建后）：组件实例已完成创建，属性也已绑定，但真实 dom 还没有生成，$el 还不可用。

  • 特点：data 和 methods都已被初始化，如要调用 methods 中的方法，或操作 data 中的数据，最早可在这个阶段中操作
  • 应用：网路请求，**注意：调用methods中的方法，完成网络请求，vue推荐的两种数据获取方式

  • 1、beforeRouteEnter 该路由加载之前请求数据，数据请求完成执行next（），显示目标路由（优点：保证页面显示时，一定可以拿到数据）

  • 2、created，在该时机发起请求，获取数据。

• beforeMount（挂载前）：在挂载开始之前被调用：相关的 render 函数首次被调用

  • 特点：执行到这个钩子的时候，在内存中已编译好模板，但还没有挂载到页面中，此时，页面还是旧的
  • 应用：开发中很少使用

• mounted（挂载后）：在el 被新创建的 vm.$el 替换，并挂载到实例上去之后调用该钩子

  • 特点：Vue实例已经初始化完成。此时组件脱离了创建阶段，进入到了运行阶段。 如要通过插件操作页面上的DOM节点，最早可以在和这个阶段中进行
  • 应用：操作dom**

• beforeUpdate（更新前）：组件数据更新之前调用，真实DOM还没被渲染

  • 特点：当执行这个钩子时，页面中显示的数据还是旧的，data中的数据是更新后的，页面还没有和最新的数据保持同步

• update（更新后） ：组件数据更新之后

  • 特点：页面显示的数据和data中的数据已保持同步，都是最新的
  • 应用：这些钩子的触发频率很高，极少操作。

• activated（激活前） ：keep-alive专属，组件被激活时调用

  • 特点：当组件被切回来时，再去缓存里找这个组件、触发 activated钩子函数。

• deactivated（激活后-没有被激活） ：keep-alive专属，组件被销毁时调用

  • 特点：当组件被换掉时，会被缓存到内存中、触发 deactivated 生命周期

• beforeDestory（销毁前） ：组件销毁前调用

  • 特点：Vue实例从运行阶段进入到销毁阶段，此时所有的 data 和 methods ， 指令， 过滤器 ……都处于可用状态。还没有真正被销毁

• destoryed（销毁后）：组件销毁前调用

  • 特点：此时所有的 data 和 methods ， 指令， 过滤器 ……都处于不可用状态。组件已经被销毁。
  • 应用：移除耗时操作，比如计时器等。

• errorCaptured(错误调用)：当捕获一个来自后代组件的错误时被调用

注意：面试官想听到的不只是你说出了以上八个钩子名称，而是每个阶段做了什么？可以收藏下图！

3. Vue子组件和父组件执行顺序

1. 加载渲染过程：beforeCreate(父) —> created(父)—>beforeMount(父)—>beforeCreate(子)—>created(子)—>beforeMount(子)—>mounted(子)—>mounted(父)
2. 更新过程：beforeUpdate(父) —> beforeUpdate(子) —> update(子) —> update(父)
3. 父组件更新：beforeUpdate(父) —> updated（父）
4. 销毁过程：beforeDestory(父) —> beforeDestory(子) —> destoryed(子) —> destoryed(父)
5. 常见问题：

a. 第一次页面加载会触发哪几个钩子？
b. vue中created与mounted区别以及各生命周期够级函数的特点和应用？

7. 组件通信

关键词：自定义事件、prop(camelCase)、单向数据流

分类：

• 父子通信：props/$emit、$parent / $children、ref、provide/inject API、$attrs/$listeners
• 兄弟通信：Bus（$on/$emit）；Vuex
• 跨级通信：Bus（$on/$emit）；Vuex；provide / inject API、$attrs/$listeners

a. 父传子：props对象

• 特点：父组件通过 props 向下传递数据给子组件。注：组件中的数据共有三种形式：data、props、computed。

//App.vue父组件
<template>
  <div id="app">
    <users v-bind:users="users"></users>
    // 前者自定义事件名便于子组件调用，后者要传递数据（简单类型）
    <blog-post v-bind="post"></blog-post>
    // 传入一个对象的所有 property
  </div>
</template>
<script>
import Users from "./components/Users"
export default {
  name: 'App',
  data(){
    return{
      users:["Henry","Bucky","Emily"]
    }
  },
  components:{
    "users":Users
  }
}

//users子组件
<template>
  <div class="hello">
    <ul>
      <li v-for="user in users">{{user}}</li>
      //遍历传递过来的值，然后呈现到页面
    </ul>
  </div>
</template>
<script>
export default {
  name: 'HelloWorld',
  props:{
    users:{  //这个就是父组件中子标签自定义事件名
      type:Array,
// String/Number/Boolean/Array/Object/Date/Function/Symbol
      // 数字/字符串等简单数据类型默认值
      default: 100，
      // 对象或数组默认值必须从一个工厂函数获取
      default: function () {
        return { message: 'hello' }
      },
      // 自定义验证函数
      propF: {
        validator: function (value) {
          // 这个值必须匹配下列字符串中的一个
          return ['success', 'warning', 'danger'].indexOf(value) !== -1
      },
      required:true
    }
  }
}
</script>

b. 子传父：通过事件形式

• 特点：子组件通过 $emit()给父组件发送消息，父组件通过v-on绑定事件接收数据。

// 子组件
<template>
  <header>
    <h1 @click="changeTitle">{{title}}</h1>//绑定一个点击事件
  </header>
</template>
<script>
export default {
  name: 'app-header',
  data() {
    return {
      title:"Vue.js Demo"
    }
  },
  methods:{
    changeTitle() {
      // 自定义事件  传递值 “子向父组件传值”
      // this.$emit("事件名","数据");
      this.$emit("titleChanged","子向父组件传值");
    }
  }
}
</script>

// 父组件
<template>
  <div id="app">
    //与子组件titleChanged自定义事件保持一致
    <app-header v-on:titleChanged="updateTitle" ></app-header>
    // updateTitle($event)接受传递过来的文字
    <h2>{{title}}</h2>
  </div>
</template>
<script>
import Header from "./components/Header"
export default {
  name: 'App',
  data(){
    return{
      title:"传递的是一个值"
    }
  },
  methods:{
    updateTitle(e){   //声明这个函数
      this.title = e;
    }
  },
  components:{
   "app-header":Header,
  }
}
</script>

c. 父子、兄弟、跨级：eventBus.js （$emit/$on)

• 特点：这种方法通过一个空的 Vue 实例作为中央事件总线（事件中心）,用它来（emit）触发事件和（on）监听事件，巧妙而轻量地实现了任何组件间的通信。

var Event=new Vue();
Event.$emit(事件名,数据);
Event.$on(事件名,data => {});

<div id="itany">
	<my-a></my-a>
	<my-b></my-b>
	<my-c></my-c>
</div>

<template id="a">
  <div>
    <h3>A组件：{{name}}</h3>
    <button @click="send">将数据发送给C组件</button>
  </div>
</template>

<template id="b">
  <div>
    <h3>B组件：{{age}}</h3>
    <button @click="send">将数组发送给C组件</button>
  </div>
</template>

<template id="c">
  <div>
    <h3>C组件：{{name}}，{{age}}</h3>
  </div>
</template>
<script>
var Event = new Vue();//定义一个空的Vue实例
var A = {
	template: '#a',
	data() {
	  return {
	    name: 'tom'
	  }
	},
	methods: {
	  send() {
	    Event.$emit('data-a', this.name);
	  }
	}
}
var B = {
	template: '#b',
	data() {
	  return {
	    age: 20
	  }
	},
	methods: {
	  send() {
	    Event.$emit('data-b', this.age);
	  }
	}
}
var C = {
	template: '#c',
	data() {
	  return {
	    name: '',
	    age: ""
	  }
	},
	mounted() {//在模板编译完成后执行
	 Event.$on('data-a',name => {
	     this.name = name;
//箭头函数内部不会产生新的this，这边如果不用=>,this指代Event
	 })
	 Event.$on('data-b',age => {
	     this.age = age;
	 })
	}
}
var vm = new Vue({
	el: '#itany',
	components: {
	  'my-a': A,
	  'my-b': B,
	  'my-c': C
	}
});	
</script>

e. vuex

• **特点：**vuex 是 vue 的状态管理器，存储的数据是响应式的。只需要把共享的值放到vuex中，其他需要的组件直接获取使用即可。
• 功能：传递数据+中间数据处理

f. 跨级组件（多级组件嵌套）通讯$attrs/$listeners

• $attrs：包含了父作用域中不被 prop 所识别 (且获取) 的特性绑定 (class 和 style 除外)。当一个组件没有声明任何 prop 时，这里会包含所有父作用域的绑定 (class 和 style 除外)，并且可以通过 v-bind=“$attrs” 传入内部组件。通常配合 inheritAttrs 选项一起使用。
• $listeners：包含了父作用域中的 (不含 .native 修饰器的) v-on 事件监听器。它可以通过 v-on=“$listeners” 传入内部组件

g. provide/inject父传子孙

Vue2.2.0新增API,这对选项需要一起使用，**以允许一个祖先组件向其所有子孙后代注入一个依赖，不论组件层次有多深，并在起上下游关系成立的时间里始终生效。

一言而蔽之：祖先组件中通过provider来提供变量，然后在子孙组件中通过inject来注入变量。

provide / inject API 主要解决了跨级组件间的通信问题，不过它的使用场景，主要是子组件获取上级组件的状态，跨级组件间建立了一种主动提供与依赖注入的关系。

需要注意的是：provide 和 inject 绑定并不是可响应的。这是刻意为之的。然而，如果你传入了一个可监听的对象，那么其对象的属性还是可响应的----vue官方文档 所以，上面 A.vue 的 name 如果改变了，B.vue 的 this.name 是不会改变的，仍然是 浪里行舟。

// A.vue
export default {
  provide: {
    name: '浪里行舟'
  }，
}
// B.vue
export default {
  inject: ['name'],
  mounted () {
    console.log(this.name);  // 浪里行舟
  }
}

// 非响应式
provide() {
  return {
    theme: {
      color: this.color //这种方式绑定的数据并不是可响应的
    } // 即A组件的color变化后，组件D、E、F不会跟着变
  }
}

//方法一：提供祖先组件的实例
 provide() {
    return {
      theme: this
    };
  },

// 方法二:使用2.6最新API Vue.observable 优化响应式 provide
provide() {
  this.theme = Vue.observable({
    color: "blue"
  });
  return {
    theme: this.theme
  };
},

// 响应式
Vue.observable(object）
让一个对象可响应。Vue 内部会用它来处理 data 函数返回的对象。
返回的对象可以直接用于渲染函数和计算属性内，并且会在发生变更时触发相应的更新。

Vue.defineReactive()

h. $parent / $children与 ref父子通信

• ref：如果在普通的 DOM 元素上使用，引用指向的就是 DOM 元素；如果用在子组件上，引用就指向组件实例（非响应式）
• $parent / $children：访问父 / 子实例（非响应式），访问组件的应急方法
  缺点：无法在跨级或兄弟间通信

// component-a 子组件
export default {
  data () {
    return {
      title: 'Vue.js'
    }
  },
  methods: {
    sayHello () {
      window.alert('Hello');
    }
  }
}

// 父组件
<template>
  <component-a ref="comA"></component-a>
</template>
<script>
  export default {
    mounted () {
      const comA = this.$refs.comA;
      console.log(comA.title);  // Vue.js
      comA.sayHello();  // 弹窗
    }
  }
</script>

解决单项数据流：

方法一 ：使用sync修饰符，它会被扩展为一个自动更新父组件属性的 v-on 监听器

//渲染时需要：要更改的props数据.sync
<son :sname.sync="name"> </son>     

updatedata:function () {
// 以this.$emit("update:你要更改的props数据",改变后的值)
// 这种方法修改数据，渲染时需要：要更改的props数据.sync
  this.$emit('update:sname','Tom')
}

方法二：可以将父组件中的数据包装成对象或数组，然后在子组件中修改对象的属性

<template class="thisfather">
    <div>
        <p>这是父组件的数据，名字：{{user.name}}</p>
        <son :suser="user"> </son> //传递json对象
    </div>
</template>

<script>
// import Son from './son.vue'
export default {
  components:{
    son: Son
  }
  data(){
    return {
// 将需要改变的数据放到json数组里，然后以json对象的方式进行传递数据，
// 就可以直接进行双向修改
      user:{   
          name: 'Jack',
       }
    }
  }
}
</script>

son.vue
<template class="thisson">
    <div>
        <p>这是子组件的数据，名字：{{suser.name}}</p>
        <button @click="updatedata">更新数据</button>
    </div>
</template>

<script>
export default {
  props:['suser'],
  data(){
    return {}
  },
  methods:{
    updatedata:function () {
      //直接进行双向修改   这个方法最为常用
      this.suser.name='Tom'  
    }
  }
}
</script>

!!! 我们是不允许直接修改父组件传过来的数据或对象的，而这种方法更改的是对象中的属性，因为对象是引用类型，指向同一内存空间，所以可以实现此效果。推荐使用该方式

8. ref（引用）/attrs

ref 对象

1. 定义：被用来给元素或子组件注册引用信息。引用信息将会注册在父组件的 $refs 对象上。如果在普通的 DOM 元素上使用，引用指向的就是 DOM 元素；如果用在子组件上，引用就指向组件实例
2. 重要说明：
   1. 因为 ref 本身是作为渲染结果被创建的，在初始渲染时不能被访问它们 - 不存在
   2. $refs 不是响应式的，不应该试图用它在模板中做数据绑定
3. 三种用法：
   1. ref 加在普通的元素上，用this.$ref.name 获取到的是dom元素
   2. ref 加在子组件上，用this.$ref.name 获取到的是组件实例，可以使用组件的所有方法。
   3. 如何利用 v-for 和 ref 获取一组数组或者dom 节点

<div ref="name"></div>
<component-a ref="name"></component-a>
<component-b v-for='item in list' ref="name" :key='item.id'></component-b>

attrs 对象
父子之间值传递，我们一般用的是在属性里设置，采用:prop="prop"的格式

在子级的props定义接受，然后可以直接使用，若props里没有定义，那么可以使用this.$attrs里获取没有定义的值（非响应式）

• 事件绑定，在props中可以用 事件名来接收
• v-model也是个特殊的属性，在props中可以用 value来接收

还有子孙
传递：v-bind="$attrs"
获取：this.$attrs

9. solt 插槽（占位）

1. 定义：槽用于决定将所携带的内容，插入到指定的某个位置，从而使模板分块，具有模块化的特质和更大的重用性。插槽显不显示、怎样显示是由父组件来控制的，而插槽在哪里显示就由子组件来进行控制
2. 作用：正常情况下,< Child>< span style=”color:red;”>hello world在组件标签Child中的span标签会被组件模板template内容替换掉，当想让组件标签Child中内容传递给组件时需要使用slot插槽；
3. 分类
   1. 单个插槽| 默认插槽| 匿名插槽

// 父组件
<template>
    <div class="father">
        <h3>这里是父组件</h3>
        <child>
           <span style=”color:red;”>hello world</span>
        </child>
    </div>
</template>

// 子组件
<template>
    <div class="child">
        <h3>这里是子组件</h3>
        <slot></slot>
        <slot style=”color:blue;” >这是在slot上添加了样式</slot>
        <slot name=”mySlot”>这是拥有命名的slot的默认内容</slot>
    </div>
</template>
// 输出：两个红色的hello world，以及一个使用slot的默认内容

//注意：在slot标签添加样式无效。拥有命名的插槽不能被不含slot属性的标签内容替换，
// 会显示slot的默认值（具名slot具有对应性）；

2. 具名插槽

// 父组件
<Child>
  <span slot="header">hello world</span>
  <span slot="main">hello world</span>
  <span slot="footer">hello world</span>
  <span slot="other">{{otherData}}</span>
</Child>

// 子组件
<template>
  <div>
    <slot  name=”header”>这是拥有命名的slot的默认内容</slot>
    <slot  name=”main”>这是拥有命名的slot的默认内容</slot>
    <slot  name=”footer”>这是拥有命名的slot的默认内容</slot>
    <slot  name=”other”>这是拥有命名的slot的默认内容</slot>
  </div>
</template>

3. 作用域插槽 | 带数据的插槽

定义：使用时候子组件标签中要有