Comment passer d'une page à l'autre en réaction

Comment implémenter des sauts entre plusieurs pages dans React : 1. Introduisez "React-Router" ; 2. Utilisez Link sur la page d'accueil pour ajouter des liens pour accéder à d'autres pages ; 3. Mettez plusieurs itinéraires dans un seul fichier et exportez simplement plusieurs ; tableaux.

L'environnement d'exploitation de ce tutoriel : système Windows 10, React version 18.0.0, ordinateur Dell G3.

Comment sauter entre plusieurs pages en réaction ?

react multi-page jump, en utilisant React-Router pour réaliser l'authentification de routage frontal

React-Router est une partie très importante de l'écosystème React, et maintenant le seul- Le routage de l'application de page est essentiellement géré par le front-end lui-même, contrairement au routage back-end auparavant. La bibliothèque la plus couramment utilisée par React pour gérer le routage est React-Router. Cet article veut parler de l'utilisation de React-Router, mais le simple fait de présenter l'API est trop simple et la documentation officielle est déjà bien écrite. Je vais utiliser un scénario de développement commun pour y jeter un œil. React-Router ? Nos systèmes généraux ont des restrictions sur les autorisations d'accès des utilisateurs, et certaines pages peuvent exiger que les utilisateurs disposent de certaines autorisations d'accès. Cet article utilise React-Router pour implémenter un modèle d'authentification frontale. React-Router是React生态里面很重要的一环，现在React的单页应用的路由基本都是前端自己管理的，而不像以前是后端路由，React管理路由的库常用的就是就是React-Router。本文想写一下React-Router的使用，但是光介绍API又太平淡了，而且官方文档已经写得很好了，我这里就用一个常见的开发场景来看看React-Router是怎么用的吧。而我们一般的系统都会有用户访问权限的限制，某些页面可能需要用户具有一定的权限才能访问。本文就是用React-Router来实现一个前端鉴权模型。

应用示例

本文要实现的功能是大家经常遇到的场景，就是要控制不同的用户角色来访问不同的页面，这里总共有四个页面：

/index
/login
/backend
/admin

另外还有三种角色：

• 未登录用户 ：只能访问网站首页 /index 和登录页 /login

• 普通用户 ：可以访问网站首页 /index ，登录页 /login 和后台页面 /backend

• 管理员 ：可以访问管理页面 /admin 和其他所有页面

引入React-Router

要实现路由鉴权，我们还得一步一步来，我们先用React-Router搭建一个简单的带有这几个页面的项目。我们直接用 create-react-app 创建一个新项目，然后建了一个 pages 文件夹，里面放入我们前面说的那几个页面：

我们页面先写简单点，先写个标题吧，比如这样：

import React from 'react';

function Admin() {
  return (
    <h1>管理员页面</h1>
  );
}

其他几个页面也是类似的。

然后我们就可以在App.js里面引入React-Router做路由跳转了，注意我们在浏览器上使用的是react-router-dom，新版的React-Router将核心逻辑层和展示层分开了，核心逻辑会处理路由匹配等，展示层会处理实际的跳转和路由变化的监听，之所以这么分，是因为React-Router不仅仅需要支持浏览器，还需要支持React Native，这两个平台的监听和跳转是不一样的，所以现在React-Router下面有好几个包了：

react-router ：核心逻辑处理，提供一些公用的基类

react-router-dom ：具体实现浏览器相关的路由监听和跳转

react-router-native ：具体实现RN相关的路由监听和跳转

在实际使用时，我们一般不需要引用 react-router ，而是直接用 react-router-dom 就行，因为它自己会去引用 react-router 。下面我们在项目里面引入 react-router-dom 。

import React from 'react';
import {
  BrowserRouter as Router,
  Switch,
  Route,
} from "react-router-dom";
import Home from './pages/Home';
import Login from './pages/Login';
import Backend from './pages/Backend';
import Admin from './pages/Admin';

function App() {
  return (
    <Router>
      <Switch>
        <Route path="/login" component={Login}/>
        <Route path="/backend" component={Backend}/>
        <Route path="/admin" component={Admin}/>
        <Route path="/" component={Home}/>
      </Switch>
    </Router>
  );
}

export default App;

然后可以在 Home 页面用 Link

Exemple d'application

La fonction à implémenter dans cet article est un scénario que tout le monde rencontre souvent, qui consiste à contrôler différents rôles d'utilisateur pour accéder à différentes pages. Il y a un total de quatre pages ici :

import React from 'react';
import { Link } from 'react-router-dom';

function Home() {
  return (
    <>
      <h1>首页</h1>
      <ul>
        <li><Link to="/login">登录</Link></li>
        <li><Link to="/backend">后台</Link></li>
        <li><Link to="/admin">管理员</Link></li>
      </ul>
    </>
  );
}

export default Home;

🎜. Il existe trois autres rôles : 🎜

• 🎜Utilisateur non connecté : ne peut accéder qu'à la page d'accueil du site Web /index et la page de connexion /login🎜
• 🎜Utilisateurs ordinaires : Vous pouvez visiter la page d'accueil du site /index et la page de connexion la page /login et la page backend <code>/backend🎜
• 🎜admin : Peut accéder à la page de gestion / admin et toutes les autres pages🎜

🎜Présentation de React-Router🎜

🎜Pour implémenter l'authentification de route, nous devons procéder étape par étape. Nous utilisons d'abord React-. Routeur pour construire un routeur simple avec ce projet sur plusieurs pages. Nous utilisons directement create-react-app pour créer un nouveau projet, puis créons un dossier pages et y mettons les pages que nous avons mentionnées plus tôt : 🎜🎜🎜 🎜Notre page est écrite en premier Pour faire c'est simple, écrivez d'abord un titre, comme ceci : 🎜🎜

公共页面
普通页面
管理员页面

🎜🎜Plusieurs autres pages sont similaires. 🎜🎜Ensuite, nous pouvons introduire React-Router dans App.js pour effectuer des sauts de routage. Notez que nous utilisons react-router sur le navigateur -domcode>, la nouvelle version de <code>React-Router sépare la couche logique principale et la couche de présentation. La logique principale gérera la correspondance de route, etc., et la couche de présentation gérera les sauts réels et la surveillance de la route. changements, la raison pour laquelle il est si divisé est que React-Router doit non seulement prendre en charge les navigateurs, mais doit également prendre en charge React Native. La surveillance et le saut de ces deux plates-formes sont différents, il existe donc maintenant plusieurs packages sous React-. Routeur : 🎜🎜react-router : traitement logique de base, fournissant quelques classes de base communes🎜🎜react-router-dom : implémentation spécifique de la surveillance et du saut de routage liés au navigateur🎜 🎜react-router-native : implémente spécifiquement la surveillance et le saut de routage liés au RN🎜🎜En utilisation réelle, nous n'avons généralement pas besoin de référencer react-router, mais directement utilisez react-router-dom, car il fera référence à react-router lui-même. Ensuite, nous introduisons react-router-dom dans le projet. 🎜🎜

import Login from '../pages';
import Home from '../pages/Home';

const publicRoutes = [
  {
    path: '/login',
    component: Login,
    exact: true,
  },
  {
    path: '/',
    component: Home,
    exact: true,
  },
];

export default publicRoutes;

🎜🎜Ensuite, vous pouvez utiliser Lien sur la page Accueil pour ajouter des liens permettant d'accéder à d'autres pages, afin de pouvoir accéder : 🎜🎜

import publicRoutes from './routes/publicRoutes';

function App() {
  return (
    <Router>
      <Switch>
        {publicRoutes.map(
          ({path, component, ...routes}) => 
            <Route key={path} path={path} component={component} {...routes}/>
        )}
        <Route path="/backend" component={Backend}/>
        <Route path="/admin" component={Admin}/>
      </Switch>
    </Router>
  );
}

🎜🎜 Jusqu'à présent, notre l'application fonctionne comme ceci : 🎜🎜🎜🎜

模块划分

虽然我们的跳转实现了，但是所有人都可以访问任何页面，我们前面的需求是要根据登录的角色限制访问的页面的，在写代码前，我们先来思考下应该怎么做这个。当然最直观最简单的方法就是每个页面都检测下当前用户的角色，匹配不上就报错或者跳回首页。我们现在只有几个页面，这样做好像也还好，但是如果我们的应用变大了，页面变多了，每个页面都来一次检测就显得很重复了，所以我们应该换个角度来思考这个问题。

仔细一看，其实我们总共就三种角色，对应三种不同的权限，这三个权限还有层级关系，高级别的权限包含了低级别的权限，所以我们的页面也可以按照这些权限分为三种：

公共页面
普通页面
管理员页面

为了好管理这三种页面，我们可以将他们抽取成三个文件，放到一个独立的文件夹 routes 里面，三个文件分别命名为 publicRoutes.js ， privateRoutes.js ， adminRoutes.js ：

对于每个路由文件，我们可以将这类路由组织成数组，然后 export 出去给外面调用，比如 publicRoutes.js ：

import Login from '../pages';
import Home from '../pages/Home';

const publicRoutes = [
  {
    path: '/login',
    component: Login,
    exact: true,
  },
  {
    path: '/',
    component: Home,
    exact: true,
  },
];

export default publicRoutes;

然后我们外面使用的地方直接改为：

import publicRoutes from './routes/publicRoutes';

function App() {
  return (
    <Router>
      <Switch>
        {publicRoutes.map(
          ({path, component, ...routes}) => 
            <Route key={path} path={path} component={component} {...routes}/>
        )}
        <Route path="/backend" component={Backend}/>
        <Route path="/admin" component={Admin}/>
      </Switch>
    </Router>
  );
}

这样我们的 App.js 里面就不会有冗长的路由路由列表了，而是只需要循环一个数组就行了。但是对于需要登录才能访问的页面和管理员页面我们不能直接渲染 Route 组件，我们最好再封装一个高级组件，将鉴权的工作放到这个组件里面去，这样我们普通的页面在实现时就不需要关心怎么鉴权了。

封装高级组件

要封装这个鉴权组件思路也很简单，前面我们将 publicRoutes 直接拿来循环渲染了 Route 组件，我们的鉴权组件只需要在这个基础上再加一个逻辑就行了：在渲染真正的 Route 组件前先检查一下当前用户是否有对应的权限，如果有就直接渲染 Route 组件，如果没有就返回某个页面，可以是登录页或者后台首页，具体根据自己项目需求来。所以我们的路由配置文件 privateRoutes.js ， adminRoutes.js 里面的路由会比 publicRoutes.js 的多两个参数：

// privateRoutes.js
import Backend from '../pages/Backend';

const privateRoutes = [
  {
    path: '/backend',
    component: Backend,
    exact: true,
    role: 'user',       // 当前路由需要的角色权限
    backUrl: '/login'   // 不满足权限跳转的路由
  },
];

export default privateRoutes;

adminRoutes.js 是类似的写法：

// adminRoutes.js
import Admin from '../pages/Admin';

const adminRoutes = [
  {
    path: '/admin',
    component: Admin,
    exact: true,
    role: 'admin',       // 需要的权限是admin
    backUrl: '/backend'  // 不满足权限跳回后台页面
  },
];

export default adminRoutes;

然后就可以写我们的高级组件了，我们将它命名为 AuthRoute 吧，注意我们这里假设的用户登录时后端API会返回给我们当前用户的角色，一个用户可能有多个角色，比如普通用户的角色是 ['user'] ，管理员的角色是 ['user', 'admin'] ，具体的权限验证逻辑要看自己项目权限的设计，这里只是一个例子：

// AuthRoute.js
import React from 'react';
import { Route, Redirect } from 'react-router-dom';

function AuthRoute(props) {
  const {
    user: {
      role: userRole
    },
    role: routeRole,
    backUrl,
    ...otherProps
  } = props;

  // 如果用户有权限，就渲染对应的路由
  if (userRole && userRole.indexOf(routeRole) > -1) {
    return <Route {...otherProps} />
  } else {
    // 如果没有权限，返回配置的默认路由
    return <Redirect to={backUrl} />
  }
}

export default AuthRoute;

然后用我们的 AuthRoute 的渲染 adminRoutes 和 privateRoutes :

// ... 省略其他代码 ...

{privateRoutes.map(
  (route) => <AuthRoute key={route.path} {...route}/>
)}
{adminRoutes.map(
  (route) => <AuthRoute key={route.path} {...route}/>
)}

登录设置权限

在我们的 AuthRoute 里面用到了 user: { role } 这个变量，但是我们还没设置它。真实项目中一般是登录的时候后端API会返回当前用户的角色，然后前端将这个权限信息保存在一些状态管理工具里面，比如 Redux 。我们这里直接在 Login 页面写死两个按钮来模拟这个权限了，用户的配置就用根组件的 state 来管理了， Login 页面的两个按钮会改变对应的 state ：

import React from 'react';
import { Link } from 'react-router-dom';

function Login(props) {
  const {loginAsUser, loginAsAdmin, history} = props;

  const userLoginHandler = () => {
    loginAsUser();      // 调用父级方法设置用户权限
    history.replace('/backend');     // 登录后跳转后台页面
  }

  const adminLoginHandler = () => {
    loginAsAdmin();     // 调用父级方法设置管理员权限
    history.replace('/admin');     // 登录后跳转管理员页面
  }

  return (
    <>
      <h1>登录页</h1>
      <button onClick={userLoginHandler}>普通用户登录</button>
      <br/><br/>
      <button onClick={adminLoginHandler}>管理员登录</button>
      <br/><br/>
      <Link to="/">回首页</Link>
    </>
  );
}

export default Login;

到这里我们这个简单的路由鉴权就完成了，具体跑起来效果如下：

Résumé

• React-Router peut être utilisé pour gérer les sauts de routage front-end. C'est une bibliothèque très importante dans l'écosystème React. React-Router 可以用来管理前端的路由跳转，是 React 生态里面很重要的一个库。

• React-Router 为了同时支持浏览器和 React-Native ，他分拆成了三个包 react-router 核心包， react-router-dom 浏览器包， react-router-native 支持 React-Native 。使用时不需要引入 react-router ，只需要引入需要的平台包就行。

• 对于需要不同权限的路由，我们可以将他们拎出来分好类，单独建成一个文件，如果路由不多，放在一个文件导出多个数组也行。

• 对于需要鉴权的路由，我们可以用一个高级组件将权限校验的逻辑封装在里面，其他页面只需要加好配置，完全不用关心鉴权的问题。

本文内容偏简单，作为熟悉React-Router

React-Router Afin de prendre en charge à la fois les navigateurs et React-Native, il a été divisé en trois packages react-router code> package de base, package de navigateur react-router-dom, react-router-native prend en charge React-Native. Il n'est pas nécessaire d'introduire react-router lors de son utilisation. Il vous suffit d'introduire les packages de plate-forme requis.

Pour les itinéraires qui nécessitent des autorisations différentes, nous pouvons les séparer en catégories et les créer dans un fichier séparé. S'il n'y a pas beaucoup d'itinéraires, nous pouvons les mettre dans un seul fichier et exporter plusieurs tableaux.

🎜🎜Pour les itinéraires qui nécessitent une authentification, nous pouvons utiliser un composant avancé pour encapsuler la logique de vérification des autorisations. Les autres pages doivent simplement être configurées, et il n'y a pas du tout besoin de s'inquiéter des problèmes d'authentification. 🎜🎜Le contenu de cet article est relativement simple En tant que personne familiarisée avec l'utilisation de React-Router, ce n'est pas mal, mais nous ne pouvons pas nous contenter de l'utiliser, nous devons également connaître ses principes. Si vous l'aimez, vous pouvez l'aimer et le suivre ! 🎜🎜Apprentissage recommandé : "🎜Tutoriel vidéo React🎜"🎜🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!