react router @4 和 vue路由 详解

<template>
    <div class="home">
        <router-view></router-view>
        <Ibar></Ibar>
    </div>
</template>

<template>
    <div class="ibar">
        <router-link to="/ho/home" tag="span" active-class="active">首页</router-link>
        <router-link to="/ho/type" tag="span" active-class="active">类别</router-link>
        <router-link to="/ho/need" tag="span" active-class="active">需求</router-link>
        <router-link to="/ho/find" tag="span" active-class="active">发现</router-link>
        <router-link to="/ho/mine" tag="span" active-class="active">我的</router-link>
    </div>
</template>

//引入vue  

import Vue from ‘vue‘

//引入路由

import VueRouter from ‘vue-router‘

//把路由挂载到vue上

Vue.use(VueRouter)

//引入我各个路由对应的component组件

import Home from ‘pages/Home‘
import Map from ‘components/Map‘
import Home1 from ‘components/Home1‘
import Find from ‘components/Find‘
import Mine from ‘components/Mine‘
import Type from ‘components/Type‘
import Publish from ‘components/Publish‘
import Search from ‘components/Search‘
import Success from ‘components/Success‘
import Need from ‘components/Need‘
import Position0 from ‘components/Position‘
import Like from ‘components/scrollX/Like‘
import S1 from ‘components/scrollX/1‘
import S2 from ‘components/scrollX/2‘
import Listall from ‘components/mine/Listall‘
import Listone from ‘components/mine/Listone‘
import Listchange from ‘components/mine/Listchange‘

const routes = [
    {

　　　　 //path是路由的路径

        path:‘/‘,

　　　　 //redirect代表重定向，因为当前路径‘/‘并没有对应的组件，所以需要重定向到其他路由页面
　　　　
        redirect:‘/ho‘
    },

　　　　 //当不需要重定向的时候，需要component写上当前路由对应的组件页面

        component: Home,

　　　　 //有些路由还有子路由，需要用到children[],
　　　　 //当访问的时候，<router-link>的属性to的时候要把所有的父组件都带上
　　　　 //如:此处的/ho/home/like

        children: [
            {
                name: ‘home‘,component: Map
    }
]

const router = new VueRouter({

//此处设置mode为history，即不带#号，在处理数据的时候会更方便一些

    mode: ‘history‘,

//ES6的写法，即routes：routes的简写，当key和value名字一样时，可简写

    routes
})

//把你创建的路由暴露出去，使得main.js可以将其引入并使用

export default router

meta: {
      title: "HelloWorld",要现实的title
      show: true               设置导航隐藏显示
}

{
    path:"/two/:id",component:Two,}

{ 
    path: ‘/a‘,component: A,alias: ‘/b‘ 
}
//　　/a 的别名是 /b
//意味着，当用户访问 /b 时，URL 会保持为 /b，但是路由匹配则为 /a
//就像用户访问 /a 一样
//简单的说就是给 /a 起了一个外号叫做 /b,但是本质上还是 /a

//引入withRouter
import {
    Link,withRouter
} from ‘react-router-dom‘

//代码结尾暴露的时候，把要暴露的组件包裹在withRouter中，做成一个高阶组件，
//将react-router 的 history,location,match 三个对象传入
//将组件包一层withRouter，就可以拿到需要的路由信息
//获取路由信息的时候this.props.location

withRouter(GoodDetail)

withRouter(connect(mapState,mapDispatch)(GoodDetail))

export const Home = () => (
  <ul>
    <li>
      <NavLink to=‘/home‘ exact activeStyle ={selectedStyle}>首页</NavLink>
    </li>
    <li>
      <NavLink to=‘/about‘ activeStyle ={selectedStyle}>关于我们</NavLink>
    </li>
    <li>
      <NavLink to=‘/event‘ activeStyle ={selectedStyle}>企业事件</NavLink>
    </li>
    <li>
      <NavLink to=‘/product‘ activeStyle ={selectedStyle}>公司产品</NavLink>
    </li>
    <li>
      <NavLink to=‘/us‘ activeStyle ={selectedStyle}>联系我们</NavLink>
    </li>
  </ul>
)

      <Redirect exact from="/" to="/home"></Redirect>
      <Route path=‘/home‘ exact component={Home}/>
      <Route path=‘/about‘ component={About}/>
      <Route path=‘/event‘ component={Event}/>
      <Route path=‘/product‘ component={Product}/>    
      <Route path=‘/us‘ component={Us}/>    

export const AboutMenu = () => (
  <ul className="about-menu">
    <li>
      <NavLink to=‘/about‘ exact activeStyle ={selectedStyle}>公司简介</NavLink>
    </li>
    <li>
      <NavLink to=‘/about/history‘ activeStyle ={selectedStyle}>公司历史</NavLink>
    </li>
    <li>
      <NavLink to=‘/about/services‘ activeStyle ={selectedStyle}>公司服务</NavLink>
    </li>
    <li>
      <NavLink to=‘/about/location‘ activeStyle ={selectedStyle}>企业位置</NavLink>
    </li>
  </ul>
)

      <Route path=‘/about‘ exact component={Company}/>
      <Route path=‘/about/history‘ component={History}/>
      <Route path=‘/about/services‘ component={Services}/>
      <Route path=‘/about/location‘ component={Location}/>

const routes = [
    {

　　　　 //path是路由的路径

        path:‘/‘,　　　　 //redirect代表重定向，因为当前路径‘/‘并没有对应的组件，所以需要重定向到其他路由页面
　　　　
        redirect:‘/ho‘
    },　　　　 //当不需要重定向的时候，需要component写上当前路由对应的组件页面

        component: Home,　　　　 //有些路由还有子路由，需要用到children[],
　　　　 //当访问的时候，<router-link>的属性to的时候要把所有的父组件都带上
　　　　 //如:此处的/ho/home/like

        children: [

　　　　　　//子路由写在children数组里，仍旧以对象的形式


            {
                name: ‘home‘,component: Map
    }
]

const router = new VueRouter({

    //此处设置mode为history，即不带#号，在处理数据的时候会更方便一些
    mode: ‘history‘,//ES6的写法，即routes：routes的简写，当key和value名字一样时，可简写

    routes
})

//把你创建的路由暴露出去，使得main.js可以将其引入并使用

export default router

//在定义路由的时候

<Route path=‘/path/:自己起个名字‘ component={Path}/>


//在路由点击跳转的时候

<Link to="/path/你要传的参数">通配符</Link>


//另一个页面接收传来的参数

this.props.match.params.你起的名字

//路由定义

<Route path=‘/query‘ component={Query}/>

//跳转的时候
var query = {
        pathname: ‘/query‘,query: ‘我是通过query传值 ‘
}

<Link to={query}>query</Link>

//另一个页面使用的时候

this.props.location.query

这里的this.props.location.query === ‘我是通过query传值‘

//Route定义

<Link to={state}>state</Link>

//使用的时候

    var state = {
        pathname: ‘/state‘,state: ‘我是通过state传值‘
    }
    <Route path=‘/state‘ component={State}/>

//另一个页面获取值的时候

this.props.location.state

这里的this.props.location.state === ‘我是通过query传值‘

//在定义路由的时候

{
     path: ‘/describe/:id‘,name: ‘Describe‘,component: Describe
}

//在使用的时候

this.$router.push({
       path: `/describe/${id}`,})

//接收页面获取值

this.$route.params.id

//在定义路由的时候

{
     path: ‘/describe‘,component: Describe
}

//在使用的时候

this.$router.push({
      name: ‘Describe‘,params: {
            id: id
      }
})

//接收页面获取值

this.$route.params.id

//在定义路由的时候

   {
     path: ‘/describe‘,component: Describe
   }

//在使用的时候

 this.$router.push({
          path: ‘/describe‘,query: {
            id: id
          }
 })

//接收页面获取值
this.$route.query.id

//引入withRouter
import {
    Link,withRouter
} from ‘react-router-dom‘

//代码结尾暴露的时候，把要暴露的组件包裹在withRouter中，做成一个高阶组件，
//将react-router 的 history,match 三个对象传入
//将组件包一层withRouter，就可以拿到需要的路由信息
//获取路由信息的时候this.props.location
withRouter(GoodDetail)

withRouter(connect(mapState,mapDispatch)(GoodDetail))

//在使用的时候

 this.$router.push({
          path: ‘/describe‘,query: {
            id: id
          }
 })

//接收页面获取值
this.$route.query.id

//下面是我的实现方式，
//首先，准备一份路由表，
//包含了路由的地址，组件以及是否需要权限校验：

import { HomePage } from ‘../pages/home/home.page‘;
import { LoginPage } from ‘../pages/login/login.page‘;
import { ErrorPage } from ‘../pages/error/error.page‘;

interface routerConfigModel {
    path:string,component?:any,auth?:boolean
}

export const routerConfig:routerConfigModel[] = [
    {
        path:‘/‘,component:HomePage,auth:true,},{
        path:‘/home‘,{
        path:‘/login‘,component:LoginPage,{
        path:‘/404‘,component:ErrorPage
    }
];

//将 auth 设置为 true，表示该路由需要权限校验。
//然后，定义 Router 组件，该组件是经过高阶组件包装后的结果：

import * as React from ‘react‘;
import { HashRouter,Switch } from ‘react-router-dom‘;
import { FrontendAuth } from ‘../components/frontend-auth/frontend-auth.component‘
import { routerConfig } from ‘./router.config‘

export class Router extends React.Component{
    render(){
        return(
            <HashRouter>
                <Switch>
                    <FrontendAuth config={routerConfig} />
                </Switch>
            </HashRouter>
        );
    }
}


//所有的路由跳转，都交给 FrontendAuth 高阶组件代理完成。
//下面是 FrontendAuth 组件的实现：

import * as React from ‘react‘;
import { Route,Redirect } from ‘react-router-dom‘;
import { propsModel } from ‘./frontend-auth.model‘

export class FrontendAuth extends React.Component<any,propsModel>{
    render(){
        const { location,config } = this.props;
        const { pathname } = location;
        const isLogin = localStorage.getItem(‘__config_center_token‘)
        
        // 如果该路由不用进行权限校验，登录状态下登陆页除外
        // 因为登陆后，无法跳转到登陆页
        // 这部分代码，是为了在非登陆状态下，访问不需要权限校验的路由
        
        const targetRouterConfig = config.find((v:any) => v.path === pathname);
        if(targetRouterConfig && !targetRouterConfig.auth && !isLogin){
            const { component } = targetRouterConfig;
            return <Route exact path={pathname} component={component} />
        }

        if(isLogin){
            // 如果是登陆状态，想要跳转到登陆，重定向到主页
            if(pathname === ‘/login‘){
                return <Redirect to=‘/‘ />
            }else{
                // 如果路由合法，就跳转到相应的路由
                if(targetRouterConfig){
                    return <Route path={pathname} component={targetRouterConfig.component} />
                }else{
                    // 如果路由不合法，重定向到 404 页面
                    return <Redirect to=‘/404‘ />
                }
            }
        }else{
            // 非登陆状态下，当路由合法时且需要权限校验时，跳转到登陆页面，要求登陆
            if(targetRouterConfig && targetRouterConfig.auth){
                return <Redirect to=‘/login‘ />
            }else{
                // 非登陆状态下，路由不合法时，重定向至 404
                return <Redirect to=‘/404‘ />
            }
        }
    }
}

//以及对应的 Model：

export interface propsModel {
    config:any[],}

//页面上的路由跳转，都由 FrontendAuth 高阶组件代理了，
//在 Switch 组件内部，不再是 Route 组件，
//而只有一个 FrontendAuth 组件。


//FrontendAuth 组件接收一个名为 config 的 Props，这是一份路由表。
//同时，由于 FrontendAuth 组件放在了 Switch 组件内部，React Router 还自动为 FrontendAuth 注入了 location 属性，
//当地址栏的路由发生变化时，就会触发 location 属性对象上的 pathname 属性发生变化，
//从而触发 FrontendAuth 的更新（调用 render 函数）。

//FrontendAuth 的 render 函数中，
//根据 pathname 查找到路由表中的相关配置，
//如果该配置中指定了无需校验，就直接返回相应的 Route 组件。
//如果查找到的配置需要进行校验，再根据是否登陆进行处理，具体可以查看代码中的注释。

总结一下，实现路由守卫需要考虑到以下的问题：

未登录情况下，访问不需要权限校验的合法页面：允许访问
登陆情况下，访问登陆页面：禁止访问，跳转至主页
登陆情况下，访问除登陆页以外的合法页面：允许访问
登陆情况下，访问所有的非法页面：禁止访问，跳转至 404
未登录情况下，访问需要权限校验的页面：禁止访问，跳转至登陆页
未登录情况下，访问所有的非法页面：禁止访问，跳转至 404
    

const router = new VueRouter({ ... })

router.beforeEach((to,from,next) => {
  // ...
})

//每个守卫功能都有三个参数：
//to: Route：导航到的目标Route对象
//from: Route：当前路线被导航离开
//next: Function：必须调用此函数来解析钩子
//    next()：继续前进到管道中的下一个钩子。如果没有留下挂钩，则确认导航。

//    next(false)：中止当前导航。如果浏览器URL已更改（由用户手动或通过后退按钮），则会将其重置为from路径的URL 。

//    next(‘/‘)或next({ path: ‘/‘ })：重定向到其他位置。当前导航将中止，并将启动一个新导航。你可以通过任何位置对象next，它允许您指定类似的选项replace: true，name: ‘home‘在使用任何选项router-link的to道具或router.push

//    next(error)：（2.4.0+）如果传递给的参数next是一个实例Error，导航将被中止，错误将传递给通过注册的回调router.onError()。

`

import Vue from ‘vue‘;
import Router from ‘vue-router‘;
import LoginPage from ‘@/pages/login‘;
import HomePage from ‘@/pages/home‘;
import GoodsListPage from ‘@/pages/good-list‘;
import GoodsDetailPage from ‘@/pages/good-detail‘;
import CartPage from ‘@/pages/cart‘;
import ProfilePage from ‘@/pages/profile‘;

Vue.use(Router)

const router = new Router({
  routes: [
    {
      path: ‘/‘,// 默认进入路由
      redirect: ‘/home‘   //重定向
    },{
      path: ‘/login‘,name: ‘login‘,component: LoginPage
    },{
      path: ‘/home‘,name: ‘home‘,component: HomePage
    },{
      path: ‘/good-list‘,name: ‘good-list‘,component: GoodsListPage
    },{
      path: ‘/good-detail‘,name: ‘good-detail‘,component: GoodsDetailPage
    },{
      path: ‘/cart‘,name: ‘cart‘,component: CartPage
    },{
      path: ‘/profile‘,name: ‘profile‘,component: ProfilePage
    },{
      path: ‘**‘,// 错误路由
      redirect: ‘/home‘   //重定向
    },]
});

// 全局路由守卫
router.beforeEach((to,next) => {
  console.log(‘navigation-guards‘);
  // to: Route: 即将要进入的目标 路由对象
  // from: Route: 当前导航正要离开的路由
  // next: Function: 一定要调用该方法来 resolve 这个钩子。执行效果依赖 next 方法的调用参数。

  const nextRoute = [‘home‘,‘good-list‘,‘good-detail‘,‘cart‘,‘profile‘];
  let isLogin = global.isLogin;  // 是否登录
  // 未登录状态；当路由到nextRoute指定页时，跳转至login
  if (nextRoute.indexOf(to.name) >= 0) {  
    if (!isLogin) {
      console.log(‘what fuck‘);
      router.push({ name: ‘login‘ })
    }
  }
  // 已登录状态；当路由到login时，跳转至home 
  if (to.name === ‘login‘) {
    if (isLogin) {
      router.push({ name: ‘home‘ });
    }
  }
  next();
});

export default router;

和类似，区别是在导航被确认之前，同时在所有组件内守卫和异步路由组件被解析之后，解析守卫就被调用router.beforeEach

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

//不会接受next函数也
//也不会改变导航本身

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

//与全局前置守卫的方法参数是一样的

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

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

  beforeRouteLeave (to,next) {
    // 导航离开该组件的对应路由时调用
    // 可以访问组件实例 `this`
  }
}next(false)

//beforeRouteEnter守卫不能访问this，
//因为守卫在导航确认前被调用，因此即将登场的新组件还没被创建。

//不过，可以你传通过一个回调给next来访问组件实例。
//在导航被确认的时候执行回调，并且把组件实例作为回调方法的参数。

beforeRouteEnter (to,next) {
  next(vm => {
    // 通过 `vm` 访问组件实例
  })
}