Vue结合路由配置递归实现菜单栏

作者：小土豆biubiubiu

博客园：https://www.cnblogs.com/HouJiao/

掘金：https://juejin.im/user/58c61b4361ff4b005d9e894d

微信公众号：土豆妈的碎碎念（扫码关注，一起吸猫，一起听故事，一起学习前端技术）

作者文章的内容均来源于自己的实践，如果觉得有帮助到你的话，可以点赞给个鼓励或留下宝贵意见

前言

在日常开发中，项目中的菜单栏都是已经实现好了的。如果需要添加新的菜单，只需要在路由配置中新增一条路由，就可以实现菜单的添加。

相信大家和我一样，有时候会跃跃欲试自己去实现一个菜单栏。那今天我就将自己实现的菜单栏的整个思路和代码分享给大家。

本篇文章重在总结和分享菜单栏的一个递归实现方式，代码的优化、菜单权限等不在本篇文章范围之内，在文中的相关部分也会做一些提示，有个别不推荐的写法希望大家不要参考哦。

同时可能会存在一些细节的功能没有处理或者没有提及到，忘知晓。

最终的效果

本次实现的这个菜单栏包含有一级菜单、二级菜单和三级菜单这三种类型，基本上已经可以覆盖项目中不同的菜单需求。

后面会一步一步从易到难去实现这个菜单。

简单实现

我们都知道到element提供了 NavMenu 导航菜单组件，因此我们直接按照文档将这个菜单栏做一个简单的实现。

基本的布局架构图如下：

菜单首页-menuIndex

首先要实现的是菜单首页这个组件，根据前面的布局架构图并且参考官方文档，实现起来非常简单。

<!-- src/menu/menuIndex.vue -->
<template>
<div id="menu-index">
<el-container>
<el-header>
<TopMenu :logoPath="logoPath" :name="name"></TopMenu>
</el-header>
<el-container id="left-container">
<el-aside width="200px">
<LeftMenu></LeftMenu>
</el-aside>
<el-main>
<router-view/>
</el-main>
</el-container>
</el-container>
</div>
</template>
<script>
import LeftMenu from './leftMenu';
import TopMenu from './topMenu';
export default {
name: 'MenuIndex',
components: {LeftMenu, TopMenu},
data() {
return {
logoPath: require("../../assets/images/logo1.png"),
name: '员工管理系统'
}
}
}
</script>
<style lang="scss">
#menu-index{
.el-header{
padding: 0px;
}
}
</style>


顶部菜单栏-topMenu

顶部菜单栏主要就是一个logo和产品名称。

逻辑代码也很简单，我直接将代码贴上。

<!-- src/menu/leftMenu.vue -->
<template>
<div id="top-menu">
<img class="logo" :src="logoPath" />
<p class="name">{{name}}</p>
</div>
</template>
<script>
export default {
name: 'topMenu',
props: ['logoPath', 'name']
}
</script>
<style lang="scss" scoped>
$topMenuWidth: 80px;
$logoWidth: 50px;
$bg-color: #409EFF;
$name-color: #fff;
$name-size: 18px;
#top-menu{
height: $topMenuWidth;
text-align: left;
background-color: $bg-color;
padding: 20px 20px 0px 20px;
.logo {
width: $logoWidth;
display: inline-block;
}
.name{
display: inline-block;
vertical-align: bottom;
color: $name-color;
font-size: $name-size;
}
}
</style>


这段代码中包含了父组件传递给子组件的两个数据。

props: ['logoPath', 'name']


这个是父组件menuIndex传递给子组件topMenu的两个数据，分别是logo图标的路径和产品名称。

完成后的界面效果如下。

左侧菜单栏-leftMenu

首先按照官方文档实现一个简单的菜单栏。

<!-- src/menu/leftMenu.vue -->
<template>
<div id="left-menu">
<el-menu
:default-active="$route.path"
class="el-menu-vertical-demo"
:collapse="false">
<el-menu-item index="1">
<i class="el-icon-s-home"></i>
<span slot="title">首页</span>
</el-menu-item>
<el-submenu index="2">
<template slot="title">
<i class="el-icon-user-solid"></i>
<span slot="title">员工管理</span>
</template>
<el-menu-item index="2-1">员工统计</el-menu-item>
<el-menu-item index="2-2">员工管理</el-menu-item>
</el-submenu>
<el-submenu index="3">
<template slot="title">
<i class="el-icon-s-claim"></i>
<span slot="title">考勤管理</span>
</template>
<el-menu-item index="3-1">考勤统计</el-menu-item>
<el-menu-item index="3-2">考勤列表</el-menu-item>
<el-menu-item index="3-2">异常管理</el-menu-item>
</el-submenu>
<el-submenu index="4">
<template slot="title">
<i class="el-icon-location"></i>
<span slot="title">工时管理</span>
</template>
<el-menu-item index="4-1">工时统计</el-menu-item>
<el-submenu index="4-2">
<template slot="title">工时列表</template>
<el-menu-item index="4-2-1">选项一</el-menu-item>
<el-menu-item index="4-2-2">选项二</el-menu-item>
</el-submenu>
</el-submenu>
</el-menu>
</div>
</template>
<script>
export default {
name: 'LeftMenu'
}
</script>
<style lang="scss">
// 使左边的菜单外层的元素高度充满屏幕
#left-container{
position: absolute;
top: 100px;
bottom: 0px;
// 使菜单高度充满屏幕
#left-menu, .el-menu-vertical-demo{
height: 100%;
}
}
</style>


注意菜单的样式代码，设置了绝对定位，并且设置top、bottom使菜单高度撑满屏幕。

此时在看下界面效果。

基本上算是实现了一个简单的菜单布局。

不过在实际项目在设计的时候，菜单栏的内容有可能来自后端给我们返回的数据，其中包含菜单名称、菜单图标以及菜单之间的层级关系。

总而言之，我们的菜单是动态生成的，而不是像前面那种固定的写法。因此下面我将实现一个动态生成的菜单，菜单的数据来源于我们的路由配置。

结合路由配置实现动态菜单

路由配置

首先，我将项目的路由配置代码贴出来。

import Vue from 'vue';
import Router from "vue-router";// 菜单
import MenuIndex from '@/components/menu/menuIndex.vue';// 首页
import Index from '@/components/homePage/index.vue';// 人员统计
import EmployeeStatistics from '@/components/employeeManage/employeeStatistics.vue';
import EmployeeManage from '@/components/employeeManage/employeeManage.vue'// 考勤
// 考勤统计
import AttendStatistics from '@/components/attendManage/attendStatistics';
// 考勤列表
import AttendList from '@/components/attendManage/attendList.vue';
// 异常管理
import ExceptManage from '@/components/attendManage/exceptManage.vue';// 工时
// 工时统计
import TimeStatistics from '@/components/timeManage/timeStatistics.vue';
// 工时列表
import TimeList from '@/components/timeManage/timeList.vue';
Vue.use(Router)let routes = [
// 首页(仪表盘、快速入口)
{
path: '/index',
name: 'index',
component: MenuIndex,
redirect: '/index',
meta: {
title: '首页', // 菜单标题
icon: 'el-icon-s-home', // 图标
hasSubMenu: false, // 是否包含子菜单，false 没有子菜单；true 有子菜单 },
children:[
{
path: '/index',
component: Index
}
]
},
// 员工管理
{
path: '/employee',
name: 'employee',
component: MenuIndex,
redirect: '/employee/employeeStatistics',
meta: {
title: '员工管理', // 菜单标题
icon: 'el-icon-user-solid', // 图标
hasSubMenu: true, // 是否包含子菜单
},
children: [
// 员工统计
{
path: 'employeeStatistics',
name: 'employeeStatistics',
meta: {
title: '员工统计', // 菜单标题,
hasSubMenu: false // 是否包含子菜单
},
component: EmployeeStatistics,
},
// 员工管理(增删改查)
{
path: 'employeeManage',
name: 'employeeManage',
meta: {
title: '员工管理', // 菜单标题
hasSubMenu: false // 是否包含子菜单
},
component: EmployeeManage
}
]
},
// 考勤管理
{
path: '/attendManage',
name: 'attendManage',
component: MenuIndex,
redirect: '/attendManage/attendStatistics',
meta: {
title: '考勤管理', // 菜单标题
icon: 'el-icon-s-claim', // 图标
hasSubMenu: true, // 是否包含子节点，false 没有子菜单；true 有子菜单
},
children:[
// 考勤统计
{
path: 'attendStatistics',
name: 'attendStatistics',
meta: {
title: '考勤统计', // 菜单标题
hasSubMenu: false // 是否包含子菜单
},
component: AttendStatistics,
},
// 考勤列表
{
path: 'attendList',
name: 'attendList',
meta: {
title: '考勤列表', // 菜单标题
hasSubMenu: false // 是否包含子菜单
},
component: AttendList,
},
// 异常管理
{
path: 'exceptManage',
name: 'exceptManage',
meta: {
title: '异常管理', // 菜单标题
hasSubMenu: false // 是否包含子菜单
},
component: ExceptManage,
}
]
},
// 工时管理
{
path: '/timeManage',
name: 'timeManage',
component: MenuIndex,
redirect: '/timeManage/timeStatistics',
meta: {
title: '工时管理', // 菜单标题
icon: 'el-icon-message-solid', // 图标
hasSubMenu: true, // 是否包含子菜单，false 没有子菜单；true 有子菜单
},
children: [
// 工时统计
{
path: 'timeStatistics',
name: 'timeStatistics',
meta: {
title: '工时统计', // 菜单标题
hasSubMenu: false // 是否包含子菜单
},
component: TimeStatistics
},
// 工时列表
{
path: 'timeList',
name: 'timeList',
component: TimeList,
meta: {
title: '工时列表', // 菜单标题
hasSubMenu: true // 是否包含子菜单
},
children: [
{
path: 'options1',
meta: {
title: '选项一', // 菜单标题
hasSubMenu: false // 是否包含子菜单
},
},
{
path: 'options2',
meta: {
title: '选项二', // 菜单标题
hasSubMenu: false // 是否包含子菜单
},
},
]
}
]
},
];
export default new Router({
routes
})


在这段代码的最开始部分，我们引入了需要使用的组件，接着就对路由进行了配置。

此处使用了直接引入组件的方式，项目开发中不推荐这种写法，应该使用懒加载的方式

路由配置除了最基础的path、component以及children之外，还配置了一个meta数据项。

meta: {
title: '工时管理', // 菜单标题
icon: 'el-icon-message-solid', // 图标
hasSubMenu: true, // 是否包含子节点，false 没有子菜单；true 有子菜单
}


meta数据包含的配置有菜单标题(title)、图标的类名(icon)和是否包含子节点(hasSubMenu)。

根据title、icon这两个配置项，可以展示当前菜单的标题和图标。

hasSubMenu表示当前的菜单项是否有子菜单，如果当前菜单包含有子菜单(hasSubMenu为true)，那当前菜单对应的标签元素就是el-submenu；否则当前菜单对应的菜单标签元素就是el-menu-item。

是否包含子菜单是一个非常关键的逻辑，我在实现的时候是直接将其配置到了meta.hasSubMenu这个参数里面。

根据路由实现多级菜单

路由配置完成后，我们就需要根据路由实现菜单了。

获取路由配置

既然要根据路由配置实现多级菜单，那第一步就需要获取我们的路由数据。这里我使用简单粗暴的方式去获取路由配置数据：this.$router.options.routes。

这种方式也不太适用日常的项目开发，因为无法在获取的时候对路由做进一步的处理，比如权限控制。

我们在组件加载时打印一下这个数据。

// 代码位置：src/menu/leftMenu.vue
mounted(){
console.log(this.$router.options.routes);
}


打印结果如下。

可以看到这个数据就是我们在router.js中配置的路由数据。

为了方便使用，我将这个数据定义到计算属性中。

// 代码位置：src/menu/leftMenu.vue
computed: {
routesInfo: function(){
return this.$router.options.routes;
}
}


一级菜单

首先我们来实现一级菜单。

主要的逻辑就是循环路由数据routesInfo，在循环的时候判断当前路由route是否包含子菜单，如果包含则当前菜单使用el-submenu实现，否则当前菜单使用el-menu-item实现。

<!-- src/menu/leftMenu.vue -->
<el-menu
:default-active="$route.path"
class="el-menu-vertical-demo"
:collapse="false">
<!-- 一级菜单 -->
<!-- 循环路由数据 -->
<!-- 判断当前路由route是否包含子菜单 -->
<el-submenu
v-for="route in routesInfo"
v-if="route.meta.hasSubMenu"
:index="route.path">
<template slot="title">
<i :class="route.meta.icon"></i>
<span slot="title">{{route.meta.title}}</span>
</template>
</el-submenu>
<el-menu-item :index="route.path" v-else>
<i :class="route.meta.icon"></i>
<span slot="title">{{route.meta.title}}</span>
</el-menu-item>
</el-menu>


结果：

可以看到，我们第一级菜单已经生成了，员工管理、考勤管理、工时管理这三个菜单是有子菜单的，所以会有一个下拉按钮。

不过目前点开是没有任何内容的，接下来我们就来实现这三个菜单下的二级菜单。

二级菜单

二级菜单的实现和一级菜单的逻辑是相同的：循环子路由route.children，在循环的时候判断子路由childRoute是否包含子菜单，如果包含则当前菜单使用el-submenu实现，否则当前菜单使用el-menu-item实现。

那话不多说，直接上代码。

<!-- src/menu/leftMenu.vue -->
<el-menu
:default-active="$route.path"
class="el-menu-vertical-demo"
:collapse="false">
<!-- 一级菜单 -->
<!-- 循环路由数据 -->
<!-- 判断当前路由route是否包含子菜单 -->
<el-submenu
v-for="route in routesInfo"
v-if="route.meta.hasSubMenu"
:index="route.path">
<template slot="title">
<i :class="route.meta.icon"></i>
<span slot="title">{{route.meta.title}}</span>
</template>
<!-- 二级菜单 -->
<!-- 循环子路由`route.children` -->
<!-- 循环的时候判断子路由`childRoute`是否包含子菜单 -->
<el-submenu
v-for="childRoute in route.children"
v-if="childRoute.meta.hasSubMenu"
:index="childRoute.path">
<template slot="title">
<i :class="childRoute.meta.icon"></i>
<span slot="title">{{childRoute.meta.title}}</span>
</template>
</el-submenu>
<el-menu-item :index="childRoute.path" v-else>
<i :class="childRoute.meta.icon"></i>
<span slot="title">{{childRoute.meta.title}}</span>
</el-menu-item>
</el-submenu>
<el-menu-item :index="route.path" v-else>
<i :class="route.meta.icon"></i>
<span slot="title">{{route.meta.title}}</span>
</el-menu-item>
</el-menu>


结果如下：

可以看到二级菜单成功实现。

三级菜单

三级菜单就不用多说了，和一级、二级逻辑相同，这里还是直接上代码。

<!-- src/menu/leftMenu.vue -->
<el-menu
:default-active="$route.path"
class="el-menu-vertical-demo"
:collapse="false">
<!-- 一级菜单 -->
<!-- 循环路由数据 -->
<!-- 判断当前路由route是否包含子菜单 -->
<el-submenu
v-for="route in routesInfo"
v-if="route.meta.hasSubMenu"
:index="route.path">
<template slot="title">
<i :class="route.meta.icon"></i>
<span slot="title">{{route.meta.title}}</span>
</template>
<!-- 二级菜单 -->
<!-- 循环子路由`route.children` -->
<!-- 循环的时候判断子路由`childRoute`是否包含子菜单 -->
<el-submenu
v-for="childRoute in route.children"
v-if="childRoute.meta.hasSubMenu"
:index="childRoute.path">
<template slot="title">
<i :class="childRoute.meta.icon"></i>
<span slot="title">{{childRoute.meta.title}}</span>
</template>
<!-- 三级菜单 -->
<!-- 循环子路由`childRoute.children` -->
<!-- 循环的时候判断子路由`child`是否包含子菜单 -->
<el-submenu
v-for="child in childRoute.children"
v-if="child.meta.hasSubMenu"
:index="child.path">
<template slot="title">
<i :class="child.meta.icon"></i>
<span slot="title">{{child.meta.title}}</span>
</template>
</el-submenu>
<el-menu-item :index="child.path" v-else>
<i :class="child.meta.icon"></i>
<span slot="title">{{child.meta.title}}</span>
</el-menu-item>
</el-submenu>
<el-menu-item :index="childRoute.path" v-else>
<i :class="childRoute.meta.icon"></i>
<span slot="title">{{childRoute.meta.title}}</span>
</el-menu-item>
</el-submenu>
<el-menu-item :index="route.path" v-else>
<i :class="route.meta.icon"></i>
<span slot="title">{{route.meta.title}}</span>
</el-menu-item>
</el-menu>


可以看到工时列表下的三级菜单已经显示了。

总结

此时我们已经结合路由配置实现了这个动态的菜单。

不过这样的代码在逻辑上相关于三层嵌套的for循环，对应的是我们有三层的菜单。

假如我们有四层、五层甚至更多层的菜单时，那我们还得在嵌套更多层for循环。很显然这样的方式暴露了前面多层for循环的缺陷，所以我们就需要对这样的写法进行一个改进。

递归实现动态菜单

前面我们一直在说一级、二级、三级菜单的实现逻辑都是相同的：循环子路由，在循环的时候判断子路由是否包含子菜单，如果包含则当前菜单使用el-submenu实现，否则当前菜单使用el-menu-item实现。那这样的逻辑最适合的就是使用递归去实现。

所以我们需要将这部分共同的逻辑抽离出来作为一个独立的组件，然后递归的调用这个组件。

逻辑拆分

<!-- src/menu/menuItem.vue -->
<template>
<div>
<el-submenu
v-for="child in route"
v-if="child.meta.hasSubMenu"
:index="child.path">
<template slot="title">
<i :class="child.meta.icon"></i>
<span slot="title">{{child.meta.title}}</span>
</template>
</el-submenu>
<el-menu-item :index="child.path" v-else>
<i :class="child.meta.icon"></i>
<span slot="title">{{child.meta.title}}</span>
</el-menu-item>
</div>
</template>
<script>
export default {
name: 'MenuItem',
props: ['route']
}
</script>


需要注意的是，这次抽离出来的组件循环的时候直接循环的是route数据，那这个route数据是什么呢。

我们先看一下前面三层循环中循环的数据源分别是什么。

为了看得更清楚，我将前面代码中一些不相关的内容进行了删减。

<!-- src/menu/leftMenu.vue --><!-- 一级菜单 -->
<el-submenu
v-for="route in routesInfo"
v-if="route.meta.hasSubMenu">
<!-- 二级菜单 --> <el-submenu
v-for="childRoute in route.children"
v-if="childRoute.meta.hasSubMenu"> <!-- 三级菜单 -->
<el-submenu
v-for="child in childRoute.children"
v-if="child.meta.hasSubMenu"> </el-submenu> </el-submenu>
</el-submenu>


从上面的代码可以看到:

一级菜单循环的是`routeInfo`，即最初我们获取的路由数据`this.$router.options.routes`，循环出来的每一项定义为`route`二级菜单循环的是`route.children`，循环出来的每一项定义为`childRoute`三级菜单循环的是`childRoute.children`,循环出来的每一项定义为`child`


按照这样的逻辑，可以发现二级菜单、三级菜单循环的数据源都是相同的，即前一个循环结果项的children，而一级菜单的数据来源于this.$router.options.routes。

前面我们抽离出来的menuItem组件，循环的是route数据，即不管是一层菜单还是二层、三层菜单，都是同一个数据源，因此我们需要统一数据源。那当然也非常好实现，我们在调用组件的时候，为组件传递不同的值即可。

代码实现

前面公共组件已经拆分出来了，后面的代码就非常好实现了。

首先是抽离出来的meunItem组件，实现的是逻辑判断以及递归调用自身。

<!-- src/menu/menuItem.vue -->
<template>
<div>
<el-submenu
v-for="child in route"
v-if="child.meta.hasSubMenu"
:index="child.path">
<template slot="title">
<i :class="child.meta.icon"></i>
<span slot="title">{{child.meta.title}}</span>
</template>
<!--递归调用组件自身 -->
<MenuItem :route="child.children"></MenuItem>
</el-submenu>
<el-menu-item :index="child.path" v-else>
<i :class="child.meta.icon"></i>
<span slot="title">{{child.meta.title}}</span>
</el-menu-item>
</div>
</template>
<script>
export default {
name: 'MenuItem',
props: ['route']
}
</script>


接着是leftMenu组件，调用menuIndex组件，传递原始的路由数据routesInfo。

<!-- src/menu/leftMenu.vue -->
<template>
<div id="left-menu">
<el-menu
:default-active="$route.path"
class="el-menu-vertical-demo"
:collapse="false">
<MenuItem :route="routesInfo"></MenuItem>
</el-menu>
</div>
</template>
<script>
import MenuItem from './menuItem'
export default {
name: 'LeftMenu',
components: { MenuItem }
}
</script>
<style lang="scss">
// 使左边的菜单外层的元素高度充满屏幕
#left-container{
position: absolute;
top: 100px;
bottom: 0px;
// 使菜单高度充满屏幕
#left-menu, .el-menu-vertical-demo{
height: 100%;
}
}
</style>

最终的结果这里就不展示了，和我们需要实现的结果是一致的。

功能完善

到此，我们结合路由配置实现了菜单栏这个功能基本上已经完成了，不过这是一个缺乏灵魂的菜单栏，因为没有设置菜单的跳转，我们点击菜单栏还无法路由跳转到对应的组件，所以接下来就来实现这个功能。

菜单跳转的实现方式有两种，第一种是NavMenu组件提供的跳转方式。

第二种是在菜单上添加router-link实现跳转。

那本次我选择的是第一种方式实现跳转,这种实现方式需要两个步骤才能完成，第一步是启用el-menu上的router;第二步是设置导航的index属性。

那下面就来实现这两个步骤。

启用el-menu上的router

<!-- src/menu/leftMenu.vue -->
<!-- 省略其余未修改代码-->
<el-menu
:default-active="$route.path"
class="el-menu-vertical-demo"
router
:collapse="false">
<MenuItem :route="routesInfo">
</MenuItem>
</el-menu>


设置导航的index属性

首先我将每一个菜单标题对应需要设置的index属性值列出来。

index值对应的是每个菜单在路由中配置的path值

首页 员工管理
员工统计 index="/employee/employeeStatistics"
员工管理 index="/employee/employeeManage"考勤管理
考勤统计 index="/attendManage/attendStatistics"
考勤列表 index="/attendManage/attendList"
异常管理 index="/attendManage/exceptManage"员工统计
员工统计 index="/timeManage/timeStatistics"
员工统计 index="/timeManage/timeList"
选项一 index="/timeManage/timeList/options1"
选项二 index="/timeManage/timeList/options2"


接着在回顾前面递归调用的组件，导航菜单的index设置的是child.path，为了看清楚child.path的值，我将其添加菜单标题的右侧，让其显示到界面上。

<!-- src/menu/menuItem.vue -->
<!-- 省略其余未修改代码-->
<el-submenu
v-for="child in route"
v-if="child.meta.hasSubMenu"
:index="child.path">
<template slot="title">
<i :class="child.meta.icon"></i>
<span slot="title">{{child.meta.title}} | {{child.path}}</span>
</template>
<!--递归调用组件自身 -->
<MenuItem :route="child.children"></MenuItem>
</el-submenu>
<el-menu-item :index="child.path" v-else>
<i :class="child.meta.icon"></i>
<span slot="title">{{child.meta.title}} | {{child.path}}</span>
</el-menu-item>


同时将菜单栏的宽度由200px设置为400px。

<!-- src/menu/menuIndex.vue -->
<!-- 省略其余未修改代码-->
<el-aside width="400px">
<LeftMenu></LeftMenu>
</el-aside>


然后我们看一下效果。

可以发现，child.path的值就是当前菜单在路由中配置path值(router.js中配置的path值)。

那么问题就来了，前面我们整理了每一个菜单标题对应需要设置的index属性值，就目前来看,现在设置的index值是不符合要求的。不过仔细观察现在菜单设置的index值和正常值是有一点接近的，只是缺少了上一级菜单的path值，如果能将上一级菜单的path值和当前菜单的path值进行一个拼接，就能得到正确的index值了。

那这个思路实现的方式依然是在递归时将当前菜单的path作为参数传递给menuItem组件。

<!-- src/menu/menuIndex.vue -->
<!--递归调用组件自身 -->
<MenuItem
:route="child.children"
:basepath="child.path">
</MenuItem>


将当前菜单的path作为参数传递给menuItem组件之后，在下一级菜单实现时，就能拿到上一级菜单的path值。然后组件中将basepath的值和当前菜单的path值做一个拼接，作为当前菜单的index值。

<!-- src/menu/menuIndex.vue -->
<el-menu-item :index="getPath(child.path)" v-else> </el-menu-item>
<script>
import path from 'path'
export default {
name: 'MenuItem',
props: ['route','basepath'],
data(){
return { }
},
methods :{
// routepath 为当前菜单的path值
// getpath: 拼接 当前菜单的上一级菜单的path 和 当前菜单的path
getPath: function(routePath){
return path.resolve(this.basepath, routePath);
}
}
}
</script>


再看一下界面。

我们可以看到二级菜单的index值已经没问题了，但是仔细看，发现工时管理-工时列表下的两个三级菜单index值还是有问题，缺少了工时管理这个一级菜单的path。

那这个问题是因为我们在调用组件自身是传递的basepath有问题。

<!--递归调用组件自身 -->
<MenuItem
:route="child.children"
:basepath="child.path">
</MenuItem>


basepath传递的只是上一级菜单的path，在递归二级菜单时，index的值是一级菜单的path值+二级菜单的path值;那当我们递归三级菜单时，index的值就是二级菜单的path值+三级菜单的path值，这也就是为什么工时管理-工时列表下的两个三级菜单index值存在问题。

所以这里的basepath值在递归的时候应该是累积的，而不只是上一级菜单的path值。因此借助递归算法的优势，basepath的值也需要通过getPath方法进行处理。

<MenuItem
:route="child.children"
:basepath="getPath(child.path)">
</MenuItem>


最终完整的代码如下。

<!-- src/menu/menuIndex.vue -->
<template>
<div>
<el-submenu
v-for="child in route"
v-if="child.meta.hasSubMenu"
:key="child.path"
:index="getPath(child.path)">
<template slot="title">
<i :class="child.meta.icon"></i>
<span slot="title">
{{child.meta.title}}
</span>
</template>
<!--递归调用组件自身 -->
<MenuItem
:route="child.children"
:basepath="getPath(child.path)">
</MenuItem>
</el-submenu>
<el-menu-item :index="getPath(child.path)" v-else>
<i :class="child.meta.icon"></i>
<span slot="title">
{{child.meta.title}}
</span>
</el-menu-item> </div>
</template>
<script>
import path from 'path'
export default {
name: 'MenuItem',
props: ['route','basepath'],
data(){
return { }
},
methods :{
// routepath 为当前菜单的path值
// getpath: 拼接 当前菜单的上一级菜单的path 和 当前菜单的path
getPath: function(routePath){
return path.resolve(this.basepath, routePath);
}
}
}
</script>


删除其余用来调试的代码

最终效果

文章的最后呢，将本次实现的最终效果在此展示一下。

选项一和选项二这两个三级菜单在路由配置中没有设置component，这两个菜单只是为了实现三级菜单，在最后的结果演示中，我已经删除了路由中配置的这两个三级菜单

此处在leftMenu组件中为el-menu开启了unique-opened

在menuIndex组件中，将左侧菜单栏的宽度改为200px

关于

作者

小土豆biubiubiu

一个努力学习的前端小菜鸟，知识是无限的。坚信只要不停下学习的脚步，总能到达自己期望的地方

同时还是一个喜欢小猫咪的人，家里有一只美短小母猫，名叫土豆

博客园

https://www.cnblogs.com/HouJiao/

掘金

https://juejin.im/user/58c61b4361ff4b005d9e894d

微信公众号

土豆妈的碎碎念

微信公众号的初衷是记录自己和身边的一些故事，同时会不定期更新一些技术文章

欢迎大家扫码关注，一起吸猫，一起听故事，一起学习前端技术

作者寄语

小小总结，欢迎大家指导~