前端知识总结之VUE-ROUTER

1.嵌套路由怎么定义

嵌套也就是路由中的路由的意思，组件中可以有自己的路由导航和路由容器（router-link、router-view），通过配置children可实现多层嵌套，在vue组件中使用就可以了。

1.嵌套路由的使用场景：
应用最多的就是选项卡，在选项卡中，顶部有多个导航栏，中间的主体显示的是内容；这个时候，整个页面是一个路由，然后点击选项卡切换不同的路由来展示不同的内容，就是中间的主体显示的是内容就是页面路由下的子路由，这就是路由中嵌套路由

在组件中：

是用来渲染通过路由映射过来的组件，当路径更改时， 中的内容也会发生更改

<template>
    <div class="standard">
        <headerBack title="嵌套路由"></headerBack>
        <div>
            <div class="tab">
                <router-link to="/standard/a">
                    <div class="children">我是a组件</div>
                </router-link>
                <router-link to="/standard/b">
                    <div class="children">我是b组件</div>
                </router-link>
                <router-link to="/standard/c">
                    <div class="children">我是c组件</div>
                </router-link>
            </div>
            <router-view/>
        </div>
    </div>
</template>
//在router的index中子路由配置：
{
      path: '/standard',
      name: 'standard',
      component: resolve => require(['@/pages/template/standard'], resolve),
      children: [
        {
          path: 'a',
          component: resolve => require(['@/pages/practice/a'], resolve),
        },
        {
          path: 'b',
          component: resolve => require(['@/pages/practice/b'], resolve),
        },
        {
          path: 'c',
          component: resolve => require(['@/pages/practice/c'], resolve),
        },
      ]
    },

子路由组件中的class样式被覆盖，当需要用到路由嵌套时，clas命名时注意不要相同

2.路由之间跳转

第一种：
使用js编程的方式进行页面跳转

goPage(url){
this.KaTeX parse error: Expected 'EOF', got '}' at position 25: …sh({path:url}) }̲ 再简单来说就是this.router.push({path:’/xx/xxx/’})

第二种：
通过router-link实现跳转

点这里跳转
方法一：to里填写的是跳转的路径，即定义路由时的path路径

方法二：to里使用路由名称name跳转

3. 懒加载（按需加载路由） ,为什么需要懒加载？

像vue这种单页面应用，如果没有应用懒加载，运用webpack打包后的文件将会异常的大，造成进入首页时，需要加载的内容过多，时间过长，会出啊先长时间的白屏，即使做了loading也是不利于用户体验，而运用懒加载则可以将页面进行划分，需要的时候加载页面，可以有效的分担首页所承担的加载压力，减少首页加载用时

vue异步组件
es提案的import()
webpack的require,ensure()
vue异步组件技术 ==== 异步加载
vue-router配置路由 , 使用vue的异步组件技术 , 可以实现按需加载 .
但是,这种情况下一个组件生成一个js文件

/* vue异步组件技术 */
{
  path: '/home',
  name: 'home',
  component: resolve => require(['@/components/home'],resolve)
},{
  path: '/index',
  name: 'Index',
  component: resolve => require(['@/components/index'],resolve)
},{
  path: '/about',
  name: 'about',
  component: resolve => require(['@/components/about'],resolve)
} 

组件懒加载方案二 路由懒加载(使用import)

// 下面2行代码，没有指定webpackChunkName，每个组件打包成一个js文件。

/* const Home = () => import('@/components/home')
const Index = () => import('@/components/index')
const About = () => import('@/components/about') */
// 下面2行代码，指定了相同的webpackChunkName，会合并打包成一个js文件。 把组件按组分块
const Home =  () => import(/* webpackChunkName: 'ImportFuncDemo' */ '@/components/home')
const Index = () => import(/* webpackChunkName: 'ImportFuncDemo' */ '@/components/index')
const About = () => import(/* webpackChunkName: 'ImportFuncDemo' */ '@/components/about')
{
  path: '/about',
  component: About
}, {
  path: '/index',
  component: Index
}, {
  path: '/home',
  component: Home
}

webpack提供的require.ensure()
vue-router配置路由，使用webpack的require.ensure技术，也可以实现按需加载。
这种情况下，多个路由指定相同的chunkName，会合并打包成一个js文件。

/* 组件懒加载方案三: webpack提供的require.ensure() */
{
  path: '/home',
  name: 'home',
  component: r => require.ensure([], () => r(require('@/components/home')), 'demo')
}, {
  path: '/index',
  name: 'Index',
  component: r => require.ensure([], () => r(require('@/components/index')), 'demo')
}, {
  path: '/about',
  name: 'about',
  component: r => require.ensure([], () => r(require('@/components/about')), 'demo-01')
}

4.vue-router如何响应 路由参数 的变化？

问题：当使用路由参数时，例如从 /content?id=1 到 content?id=2，此时原来的组件实例会被复用。这也意味着组件的生命周期钩子不会再被调用，此时vue应该如何响应路由参数 的变化？

复用组件时，想对路由参数的变化作出响应的话， 可以watch (监测变化) $route 对象

const User = {
template: ‘…’,
watch: {
‘$route’ (to, from) {
// 对路由变化作出响应…
}
}
}

或者使用 2.2 中引入的 beforeRouteUpdate 守卫：

const User = {
template: ‘…’,
beforeRouteUpdate (to, from, next) {
// react to route changes…
// don’t forget to call next()
}
}

5.完整的 vue-router 导航解析流程

1、导航被触发。

2、在失活的组件里调用离开守卫。

3、调用全局的 beforeEach守卫。

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

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

6、解析异步路由组件。

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

8、调用全局的 beforeResole 守卫 (2.5+)。

9、导航被确认。

10、调用全局的afterEach 钩子。

11、触发 DOM 更新。

12、用创建好的实例调用beforeRouteEnter 守卫中传给 next 的回调函数。

6.vue-router有哪几种导航钩子（ 导航守卫 ）？

1、全局守卫： router.beforeEach

2、全局解析守卫： router.beforeResolve

3、全局后置钩子： router.afterEach

4、路由独享的守卫： beforeEnter

5、组件内的守卫： beforeRouteEnter、beforeRouteUpdate (2.2 新增)、beforeRouteLeave

导航表示路由正在发生改变，vue-router 提供的导航守卫主要用来:通过跳转或取消的方式守卫导航。有多种机会植入路由导航过程中：全局的, 单个路由独享的, 或者组件级的。

注意：参数或查询的改变并不会触发进入/离开的导航守卫。 你可以通过 观察 $route 对象 来应对这些变化，或使用 beforeRouteUpdate的组件内守卫。

1、全局守卫：
使用 router.beforeEach 注册一个全局前置守卫：

const router = new VueRouter({ … })
router.beforeEach((to, from, next) => {
// …
})

当一个导航触发时，全局前置守卫按照创建顺序调用。守卫是异步解析执行，此时导航在所有守卫 resolve 完之前一直处于等待中。

每个守卫方法接收三个参数：

to: Route:即将要进入的目标 路由对象

from: Route: 当前导航正要离开的路由

next: Function:一定要调用该方法来resolve这个钩子。执行效果依赖 next 方法的调用参数。

next(): 进行管道中的下一个钩子。如果全部钩子执行完了，则导航的状态就是confirmed (确认的)。

next(false): 中断当前的导航。如果浏览器的 URL 改变了 (可能是用户手动或者浏览器后退按钮)，那么 URL 地址会重置到 from 路由对应的地址。

next(’/’) 或者 next({ path: ‘/’ }): 跳转到一个不同的地址。当前的导航被中断，然后进行一个新的导航。你可以向 next 传递任意位置对象，且允许设置诸如 replace: true、name: ‘home’ 之类的选项以及任何用在router-link的 to prop或 router.push中的选项。

next(error): (2.4.0+) 如果传入 next 的参数是一个 Error 实例，则导航会被终止且该错误会被传递给 router.onError()注册过的回调。

确保要调用 next方法，否则钩子就不会被 resolved

2、全局解析守卫：
2.5.0 新增

在 2.5.0+ 你可以用 router.beforeResolve 注册一个全局守卫。这和 router.beforeEach 类似，区别是：在导航被确认之前，同时在所有组件内守卫和异步路由组件被解析之后，解析守卫就被调用。
3、全局后置钩子
你也可以注册全局后置钩子，然而和守卫不同的是，这些钩子不会接受 next 函数也不会改变导航本身：

router.afterEach((to, from) => {
// …
})

4、路由独享的守卫
你可以在路由配置上直接定义 beforeEnter 守卫：

const router = new VueRouter({
routes: [
{
path: ‘/foo’,
component: Foo,
beforeEnter: (to, from, next) => {
// …
}
}
]
})

这些守卫与全局前置守卫的方法参数是一样的。

5、组件内的守卫
最后，你可以在路由组件内直接定义以下路由导航守卫：
beforeRouteEnter

beforeRouteUpdate (2.2 新增)

beforeRouteLeave

const Foo = {
template: ...,
beforeRouteEnter (to, from, next) {
// 在渲染该组件的对应路由被 confirm 前调用
// 不！能！获取组件实例 this
// 因为当守卫执行前，组件实例还没被创建
},
//不过，你可以通过传一个回调给 next来访问组件实例。
//在导航被确认的时候执行回调，并且把组件实例作为回调方法的参数。
beforeRouteEnter (to, from, next) {
next(vm => {
// 通过 vm 访问组件实例
})
},
beforeRouteUpdate (to, from, next) {
// 在当前路由改变，但是该组件被复用时调用
// 举例来说，对于一个带有动态参数的路径 /foo/:id，在 /foo/1 和 /foo/2 之间跳转的时候，
// 由于会渲染同样的 Foo 组件，因此组件实例会被复用。而这个钩子就会在这个情况下被调用。
// 可以访问组件实例 this
},
beforeRouteLeave (to, from, next) {
// 导航离开该组件的对应路由时调用
// 可以访问组件实例 this
}
}

注意：beforeRouteEnter 是支持给next 传递回调的唯一守卫。对于beforeRouteUpdate 和 beforeRouteLeave 来说，this 已经可用了，所以不支持传递回调，因为没有必要了:

beforeRouteUpdate (to, from, next) {
// just use this
this.name = to.params.name
next()
}

离开守卫beforeRouteLeave：通常用来禁止用户在还未保存修改前突然离开。该导航可以通过 next(false) 来取消：

beforeRouteLeave (to, from , next) {
const answer = window.confirm(‘Do you really want to leave? you have unsaved changes!’)
if (answer) {
next()
} else {
next(false)
}
}