react-router 返回一个页面你如何配置历史记录？

Question

谁能告诉我如何返回上一页而不是特定路线？

使用此代码时：

var BackButton = React.createClass({

 mixins: [Router.Navigation],
  render: function() {
    return (
        <button
            className="button icon-left"
            onClick={this.navigateBack}>
            Back
        </button>
    );
  },

  navigateBack: function(){
    this.goBack();
  }
});

得到这个错误， goBack()被忽略，因为没有路由器历史记录

这是我的路线：

// Routing Components
Route = Router.Route;
RouteHandler = Router.RouteHandler;
DefaultRoute = Router.DefaultRoute;

var routes = (
 <Route name="app" path="/" handler={OurSchoolsApp}>
     <DefaultRoute name="home" handler={HomePage} />
     <Route name="add-school" handler={AddSchoolPage}  />
     <Route name="calendar" handler={CalendarPage}  />
     <Route name="calendar-detail" path="calendar-detail/:id" handler={CalendarDetailPage} />
     <Route name="info-detail" path="info-detail/:id" handler={InfoDetailPage} />
     <Route name="info" handler={InfoPage} />
     <Route name="news" handler={NewsListPage} />
     <Route name="news-detail" path="news-detail/:id" handler={NewsDetailPage} />
     <Route name="contacts" handler={ContactPage} />
     <Route name="contact-detail" handler={ContactDetailPage} />
     <Route name="settings" handler={SettingsPage} />
 </Route>
 );

 Router.run(routes, function(Handler){
   var mountNode = document.getElementById('app');
   React.render(<Handler /> , mountNode);
 });

Answer 1

更新 React v16 和 ReactRouter v4.2.0（2017 年 10 月）：

class BackButton extends Component {
  static contextTypes = {
    router: () => true, // replace with PropTypes.object if you use them
  }

  render() {
    return (
      <button
        className="button icon-left"
        onClick={this.context.router.history.goBack}>
          Back
      </button>
    )
  }
}

更新 React v15 和 ReactRouter v3.0.0（2016 年 8 月）：

var browserHistory = ReactRouter.browserHistory;

var BackButton = React.createClass({
  render: function() {
    return (
      <button
        className="button icon-left"
        onClick={browserHistory.goBack}>
        Back
      </button>
    );
  }
});

创建了一个带有嵌入式 iframe 的更复杂示例的小提琴： https : //jsfiddle.net/kwg1da3a/

React v14 和 ReacRouter v1.0.0（2015 年 9 月 10 日）

你可以这样做：

var React = require("react");
var Router = require("react-router");

var SomePage = React.createClass({
  ...

  contextTypes: {
    router: React.PropTypes.func
  },
  ...

  handleClose: function () {
    if (Router.History.length > 1) {
      // this will take you back if there is history
      Router.History.back();
    } else {
      // this will take you to the parent route if there is no history,
      // but unfortunately also add it as a new route
      var currentRoutes = this.context.router.getCurrentRoutes();
      var routeName = currentRoutes[currentRoutes.length - 2].name;
      this.context.router.transitionTo(routeName);
    }
  },
  ...

你需要小心，你有必要的历史回去。 如果您直接点击页面然后回击，它会将您带回到应用程序之前的浏览器历史记录中。

此解决方案将处理这两种情况。 但是，它不会处理可以使用后退按钮在页面内导航（并添加到浏览器历史记录）的 iframe。 坦率地说，我认为这是反应路由器中的一个错误。 问题在这里创建： https : //github.com/rackt/react-router/issues/1874

Answer 2

使用 React 钩子

进口：

import { useHistory } from "react-router-dom";

在无状态组件中：

let history = useHistory();

调用事件：

history.goBack()

在事件按钮中使用的示例：

<button onClick={history.goBack}>Back</button>

或者

<button onClick={() => history.goBack()}>Back</button>

Answer 3

我认为你只需要通过像这样初始化它来在你的路由器上启用 BrowserHistory ： <Router history={new BrowserHistory}> 。

在此之前，你应该要求BrowserHistory从'react-router/lib/BrowserHistory'

我希望有帮助！

更新：ES6 中的示例

const BrowserHistory = require('react-router/lib/BrowserHistory').default;

const App = React.createClass({
    render: () => {
        return (
            <div><button onClick={BrowserHistory.goBack}>Go Back</button></div>
        );
    }
});

React.render((
    <Router history={BrowserHistory}>
        <Route path="/" component={App} />
    </Router>
), document.body);

Answer 4

用withRouter导入

import { withRouter } from 'react-router-dom';

将您的组件导出为：
```
 export withRouter(nameofcomponent)
```

例如，单击按钮时，调用goBack ：

 <button onClick={this.props.history.goBack}>Back</button>

在react-router-dom v4.3 上测试

Answer 5

this.context.router.goBack()

无需导航混合！

Answer 6

使用 react-router 的无混合 ES6 方法，无状态功能。

import React from 'react'
import { browserHistory } from 'react-router'

export const Test = () => (
  <div className="">
    <button onClick={browserHistory.goBack}>Back</button>
  </div>
)

Answer 7

返回特定页面：

  import { useHistory } from "react-router-dom";

  const history = useHistory();
  
  const routeChange = () => {
    let path = '/login';
    history.push(path);
  };

返回上一页：

  import { useHistory } from "react-router-dom";

  const history = useHistory();
  
  const routeChange = () => {
    history.goBack()
  };

Answer 8

这适用于浏览器和哈希历史记录。

this.props.history.goBack();

Answer 9

查看我使用 React 16.0 和 React-router v4 的工作示例。 查看代码Github

使用withRouter和history.goBack()

这是我正在实施的想法......

历史.js

import React, { Component } from 'react';
import { withRouter } from 'react-router-dom'
import './App.css'


class History extends Component {

  handleBack = () => {
    this.props.history.goBack()
  }

  handleForward = () => {
    console.log(this.props.history)
    this.props.history.go(+1)
  }

  render() {
    return <div className="container">
      <div className="row d-flex justify-content-between">
        <span onClick={this.handleBack} className="d-flex justify-content-start button">
          <i className="fas fa-arrow-alt-circle-left fa-5x"></i>
        </span>
        <span onClick={this.handleForward} className="d-flex justify-content-end button">
          <i className="fas fa-arrow-alt-circle-right fa-5x"></i>
        </span>
      </div>
    </div>
  }
}

export default withRouter(History)

PageOne.js

import React, { Fragment, Component } from 'react'

class PageOne extends Component {

   componentDidMount(){
      if(this.props.location.state && this.props.location.state.from != '/pageone')
      this.props.history.push({
         pathname: '/pageone',
         state: { 
             from: this.props.location.pathname
         }
       });
   }

   render() {
      return (
         <Fragment>
            <div className="container-fluid">
               <div className="row d-flex justify-content-center">
                  <h2>Page One</h2>
               </div>
            </div>
         </Fragment>
      )
   }
}

export default PageOne

ps 抱歉，代码太大了，无法将其全部发布在这里

Answer 10

这是一个可用的 BackButton 组件（React 0.14）：

var React = require('react');
var Router = require('react-router');

var History = Router.History;

var BackButton = React.createClass({
  mixins: [ History ],
  render: function() {
    return (
      <button className="back" onClick={this.history.goBack}>{this.props.children}</button>
    );
  }
});

module.exports = BackButton;

如果没有历史，你当然可以做这样的事情：

<button className="back" onClick={goBack}>{this.props.children}</button>

function goBack(e) {
  if (/* no history */) {
    e.preventDefault();
  } else {
    this.history.goBack();
  }
}

Answer 11

对于 react-router v2.x，这已经改变了。 这是我为 ES6 所做的：

import React from 'react';
import FontAwesome from 'react-fontawesome';
import { Router, RouterContext, Link, browserHistory } from 'react-router';

export default class Header extends React.Component {

  render() {
    return (
      <div id="header">
        <div className="header-left">
          {
            this.props.hasBackButton &&
            <FontAwesome name="angle-left" className="back-button" onClick={this.context.router.goBack} />
          }
        </div>
        <div>{this.props.title}</div>
      </div>
    )
  }
}

Header.contextTypes = {
  router: React.PropTypes.object
};

Header.defaultProps = {
  hasBackButton: true
};

Header.propTypes = {
  title: React.PropTypes.string
};

Answer 12

在 react-router v4.x 中，您可以使用history.goBack ，它相当于history.go(-1) 。

应用程序.js

import React from "react";
import { render } from "react-dom";
import { BrowserRouter as Router, Route, Link } from "react-router-dom";
import Home from "./Home";
import About from "./About";
import Contact from "./Contact";
import Back from "./Back";

const styles = {
  fontFamily: "sans-serif",
  textAlign: "left"
};

const App = () => (
  <div style={styles}>
    <Router>
      <div>
        <ul>
          <li><Link to="/">Home</Link></li>
          <li><Link to="/about">About</Link></li>
          <li><Link to="/contact">Contact</Link></li>
        </ul>

        <hr />

        <Route exact path="/" component={Home} />
        <Route path="/about" component={About} />
        <Route path="/contact" component={Contact} />

        <Back />{/* <----- This is component that will render Back button */}
      </div>
    </Router>
  </div>
);

render(<App />, document.getElementById("root"));

返回.js

import React from "react";
import { withRouter } from "react-router-dom";

const Back = ({ history }) => (
  <button onClick={history.goBack}>Back to previous page</button>
);

export default withRouter(Back);

演示： https : //codesandbox.io/s/ywmvp95wpj

请记住，通过使用history您的用户可以离开，因为history.goBack()可以在打开您的应用程序之前加载访问者访问过的页面。

为了防止上述情况，我创建了一个简单的库react-router-last-location来监视用户的最后位置。

使用非常简单。 首先，您需要从npm安装react-router-dom和react-router-last-location 。

npm install react-router-dom react-router-last-location --save

然后使用LastLocationProvider如下：

应用程序.js

import React from "react";
import { render } from "react-dom";
import { BrowserRouter as Router, Route, Link } from "react-router-dom";
import { LastLocationProvider } from "react-router-last-location";
//              ↑
//              |
//              |
//
//       Import provider
//
import Home from "./Home";
import About from "./About";
import Contact from "./Contact";
import Back from "./Back";

const styles = {
  fontFamily: "sans-serif",
  textAlign: "left"
};

const App = () => (
  <div style={styles}>
    <h5>Click on About to see your last location</h5>
    <Router>
      <LastLocationProvider>{/* <---- Put provider inside <Router> */}
        <div>
          <ul>
            <li><Link to="/">Home</Link></li>
            <li><Link to="/about">About</Link></li>
            <li><Link to="/contact">Contact</Link></li>
          </ul>

          <hr />

          <Route exact path="/" component={Home} />
          <Route path="/about" component={About} />
          <Route path="/contact" component={Contact} />

          <Back />
        </div>
      </LastLocationProvider>
    </Router>
  </div>
);

render(<App />, document.getElementById("root"));

返回.js

import React from "react";
import { Link } from "react-router-dom";
import { withLastLocation } from "react-router-last-location";
//              ↑
//              |
//              |
//
//    `withLastLocation` higher order component
//    will pass `lastLocation` to your component               
//
//                   |
//                   |
//                   ↓
const Back = ({ lastLocation }) => (
  lastLocation && <Link to={lastLocation || '/'}>Back to previous page</Link>
);


//          Remember to wrap
//   your component before exporting
//
//                   |
//                   |
//                   ↓
export default withLastLocation(Back);

演示： https : //codesandbox.io/s/727nqm99jj

Answer 13

反应路由器 v6

useNavigate Hook 是现在返回的推荐方式：

import { useNavigate } from 'react-router-dom';

function App() {
  const navigate = useNavigate();

  return (
    <>
      <button onClick={() => navigate(-1)}>go back</button>
      <button onClick={() => navigate(1)}>go forward</button>
    </>
  );
}

代码沙盒示例

后退/前进多个历史堆栈条目：

 <button onClick={() => navigate(-2)}>go two back</button> <button onClick={() => navigate(2)}>go two forward</button>

前往具体路线：

 navigate("users") // go to users route, like history.push navigate("users", { replace: true }) // go to users route, like history.replace navigate("users", { state }) // go to users route, pass some state in

useNavigate 替换了useHistory以更好地支持即将到来的 React Suspense/Concurrent 模式。

Answer 14

对我有用的是在我的文件顶部导入 withRouter ；

import { withRouter } from 'react-router-dom'

然后用它把导出的函数包装在我的文件底部；

export default withRouter(WebSitePageTitleComponent)

然后允许我访问路由器的历史记录道具。 完整示例代码如下！

import React, { Component } from 'react'
import { withRouter } from 'react-router-dom'

import PropTypes from 'prop-types'

class TestComponent extends Component {
  constructor(props) {
    super(props)
    this.handleClick = this.handleClick.bind(this)
  }

  handleClick() {
    event.preventDefault()
    this.props.history.goBack()
  }

  render() {
    return (
      <div className="page-title">
        <a className="container" href="/location" onClick={this.handleClick}>
          <h1 className="page-header">
            { this.props.title }
          </h1>
        </a>
      </div>
    )
  }
}

const { string, object } = PropTypes

TestComponent.propTypes = {
  title: string.isRequired,
  history: object
}

export default withRouter(TestComponent)

Answer 15

import { withRouter } from 'react-router-dom'

this.props.history.goBack();

我正在使用这些版本

"react": "^15.6.1",
"react-dom": "^15.6.1",
"react-router": "^4.2.0",
"react-router-dom": "^4.2.2",

Answer 16

还原

您还可以使用具有goBack()和push() react-router-redux 。

这是一个示例包：

在您的应用程序的入口点中，您需要ConnectedRouter ，而有时需要ConnectedRouter棘手连接是history对象。 Redux 中间件监听历史变化：

import React from 'react'
import { render } from 'react-dom'
import { ApolloProvider } from 'react-apollo'
import { Provider } from 'react-redux'
import { ConnectedRouter } from 'react-router-redux'
import client from './components/apolloClient'
import store, { history } from './store'
import Routes from './Routes'
import './index.css'

render(
  <ApolloProvider client={client}>
    <Provider store={store}>
      <ConnectedRouter history={history}>
        <Routes />
      </ConnectedRouter>
    </Provider>
  </ApolloProvider>,
  document.getElementById('root'),
)

我将向您展示一种连接history 。 请注意历史记录是如何导入到商店中并作为单例导出的，以便它可以在应用程序的入口点中使用：

import { createStore, applyMiddleware, compose } from 'redux'
import { routerMiddleware } from 'react-router-redux'
import thunk from 'redux-thunk'
import createHistory from 'history/createBrowserHistory'
import rootReducer from './reducers'

export const history = createHistory()

const initialState = {}
const enhancers = []
const middleware = [thunk, routerMiddleware(history)]

if (process.env.NODE_ENV === 'development') {
  const { devToolsExtension } = window
  if (typeof devToolsExtension === 'function') {
    enhancers.push(devToolsExtension())
  }
}

const composedEnhancers = compose(applyMiddleware(...middleware), ...enhancers)
const store = createStore(rootReducer, initialState, composedEnhancers)

export default store

上面的示例块显示了如何加载完成设置过程的react-router-redux中间件助手。

我认为下一部分完全是额外的，但我会包括它，以防将来有人发现好处：

import { combineReducers } from 'redux'
import { routerReducer as routing } from 'react-router-redux'

export default combineReducers({
  routing, form,
})

我一直使用routerReducer因为它允许我强制重新加载通常不会由于shouldComponentUpdate引起的shouldComponentUpdate 。 一个明显的例子是当你有一个导航栏，当用户按下一个NavLink按钮时它应该更新。 如果你沿着这条路走下去，你会了解到 Redux 的 connect 方法使用shouldComponentUpdate 。 使用routerReducer ，您可以使用mapStateToProps将路由更改映射到导航栏，这将在历史对象更改时触发它更新。

像这样：

const mapStateToProps = ({ routing }) => ({ routing })

export default connect(mapStateToProps)(Nav)

请原谅我为人们添加了一些额外的关键字：如果您的组件没有正确更新， shouldComponentUpdate通过删除连接功能来调查shouldComponentUpdate并查看它是否解决了问题。 如果是这样，拉入routerReducer ，组件会在 URL 更改时正确更新。

最后，完成所有这些之后，您可以随时调用goBack()或push() ！

现在在一些随机组件中尝试：

在connect()导入
你甚至不需要mapStateToProps或mapDispatchToProps
导入 goBack 并从react-router-redux推送
调用this.props.dispatch(goBack())
调用this.props.dispatch(push('/sandwich'))
体验积极情绪

如果您需要更多采样，请查看： https : //www.npmjs.com/package/react-router-redux

Answer 17

唯一对我有用的解决方案是最简单的。 不需要额外的进口。

<a href="#" onClick={() => this.props.history.goBack()}>Back</a>

Tks, IamMHussain

Answer 18

像这样调用以下组件：

<BackButton history={this.props.history} />

这是组件：

import React, { Component } from 'react'
import PropTypes from 'prop-types'
class BackButton extends Component {
  constructor() {
    super(...arguments)

    this.goBack = this.goBack.bind(this)
  }

  render() {
    return (
      <button
        onClick={this.goBack}>
          Back
      </button>
    )
  }

  goBack() {
    this.props.history.goBack()
  }
}

BackButton.propTypes = {
  history: PropTypes.object,
}

export default BackButton

我正在使用：

"react": "15.6.1"
"react-router": "4.2.0"

Answer 19

只需像这样使用

<span onClick={() => this.props.history.goBack()}>Back</span>

Answer 20

React Router 使用 HTML5 History API，它建立在浏览器历史 API 之上，提供了一个我们可以在 React 应用程序中轻松使用的界面。历史 API 。 因此无需导入任何内容（useHistory 等）

对于功能组件：

<button onClick={()=>{ window.history.back() }}> Back </button>

对于类组件：

<button onClick={()=>{ this.window.history.back() }}> Back </button>

Answer 21

如果你使用的是 react-router v6，当你想返回上一页时，你可以使用Link来实现：

第 1 步：您需要从react-router-dom导入Link

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

第 2 步：像这样用Link包裹按钮。 它工作得很好。

<Link to='..'>
  <Button type='button'>Go Back</Button>
</Link>

Answer 22

这段代码将为您解决问题。

this.context.router.history.goBack()

Answer 23

第1步

import { useHistory } from "react-router-dom";`

第2步

let history = useHistory();

步骤 3

const goToPreviousPath = (e) => {
   e.preventDefault();
   history.goBack()
}

第四步

<Button
  onClick={goToPreviousPath}
>
  Back
</Button>

Answer 24

在`react-router-dom` v6 上

import { useNavigate } from 'react-router-dom';

function goBack() {
  const navigate = useNavigate();

  return <button onClick={() => navigate(-1)}>go back</button>
}

Answer 25

我想稍微更新一下以前的答案。 如果您使用的是react-router >v6.0<\/code> ，那么useHistory()<\/code>不是返回的正确方法。你会得到一个错误，因为我猜useHistory()<\/code>在最新版本中不存在。所以这是更新的答案

// This is a React Router v6 app
import { useNavigate } from "react-router-dom";

function App() {
  const navigate = useNavigate();

  return (
    <>
      <button onClick={() => navigate(-2)}>
        Go 2 pages back
      </button>
      <button onClick={() => navigate(-1)}>Go back</button>
      <button onClick={() => navigate(1)}>
        Go forward
      </button>
      <button onClick={() => navigate(2)}>
        Go 2 pages forward
      </button>
    </>
  );
}

Answer 26

在 react-router v6 中，当您想要 go 回到最后一页时，您应该使用（导航）

例如：第 1 步：

import { useNavigate } from "react-router-dom";

第2步：

  const navigate = useNavigate();

第 3 步：如果您希望 go 返回最后一页，请使用：

  <button onClick={() => navigate(-1)}> back </button>

Answer 27

如果您在应用程序中使用 react-native drawer navigation 作为主路由器，并且想要控制后退按钮行为并返回历史记录，您可以使用它来控制后退按钮。

 <NavigationContainer> <Drawer.Navigator backBehavior="history"> // your screens come here </Drawer.Navigator> </NavigationContainer>

Answer 28

根据https://reacttraining.com/react-router/web/api/history

对于"react-router-dom": "^5.1.2", ,

const { history } = this.props;
<Button onClick={history.goBack}>
  Back
</Button>

YourComponent.propTypes = {
  history: PropTypes.shape({
    goBack: PropTypes.func.isRequired,
  }).isRequired,
};

react-router 返回一个页面你如何配置历史记录？

问题描述

28 个解决方案

解决方案1
117 2015-09-10 19:06:20

更新 React v16 和 ReactRouter v4.2.0（2017 年 10 月）：

更新 React v15 和 ReactRouter v3.0.0（2016 年 8 月）：

React v14 和 ReacRouter v1.0.0（2015 年 9 月 10 日）

解决方案2
85 2019-11-16 18:50:28

解决方案3
63 已采纳 2015-06-19 13:05:48

解决方案4
62 2018-03-06 11:53:48

解决方案5
45 2015-11-22 00:38:29

解决方案6
34 2016-08-05 19:25:56

解决方案7
23 2020-05-16 23:38:33

解决方案8
12 2017-09-05 01:33:00

解决方案9
12 2018-08-06 21:42:09

解决方案10
9 2015-10-09 07:10:58

解决方案11
8 2016-05-09 01:12:26

解决方案12
8 2017-10-16 19:10:27

解决方案13
8 2020-06-12 09:06:25

反应路由器 v6

解决方案14
6 2018-11-01 18:26:17

解决方案15
4 2018-02-02 11:35:03

解决方案16
2 2018-05-05 23:51:38

解决方案17
2 2020-02-05 19:34:49

解决方案18
1 2017-11-28 15:06:32

解决方案19
1 2018-07-07 08:08:37

解决方案20
1 2021-05-12 14:31:02

解决方案21
1 2022-12-08 20:52:59

解决方案22
0 2018-10-04 09:06:44

解决方案23
0 2021-06-01 03:05:24

解决方案24
0 2022-01-23 11:04:36

在`react-router-dom` v6 上

解决方案25
0 2022-01-31 23:34:57

解决方案26
0 2022-08-30 07:27:35

解决方案27
0 2022-10-13 09:31:42

解决方案28
-1 2020-03-31 09:44:31

react-router 返回一个页面 你如何配置历史记录？

问题描述

28 个解决方案

解决方案1 117 2015-09-10 19:06:20

更新 React v16 和 ReactRouter v4.2.0（2017 年 10 月）：

更新 React v15 和 ReactRouter v3.0.0（2016 年 8 月）：

React v14 和 ReacRouter v1.0.0（2015 年 9 月 10 日）

解决方案2 85 2019-11-16 18:50:28

解决方案3 63 已采纳 2015-06-19 13:05:48

解决方案4 62 2018-03-06 11:53:48

解决方案5 45 2015-11-22 00:38:29

解决方案6 34 2016-08-05 19:25:56

解决方案7 23 2020-05-16 23:38:33

解决方案8 12 2017-09-05 01:33:00

解决方案9 12 2018-08-06 21:42:09

解决方案10 9 2015-10-09 07:10:58

解决方案11 8 2016-05-09 01:12:26

解决方案12 8 2017-10-16 19:10:27

解决方案13 8 2020-06-12 09:06:25

反应路由器 v6

解决方案14 6 2018-11-01 18:26:17

解决方案15 4 2018-02-02 11:35:03

解决方案16 2 2018-05-05 23:51:38

解决方案17 2 2020-02-05 19:34:49

解决方案18 1 2017-11-28 15:06:32

解决方案19 1 2018-07-07 08:08:37

解决方案20 1 2021-05-12 14:31:02

解决方案21 1 2022-12-08 20:52:59

解决方案22 0 2018-10-04 09:06:44

解决方案23 0 2021-06-01 03:05:24

解决方案24 0 2022-01-23 11:04:36

在react-router-dom v6 上

解决方案25 0 2022-01-31 23:34:57

解决方案26 0 2022-08-30 07:27:35

解决方案27 0 2022-10-13 09:31:42

解决方案28 -1 2020-03-31 09:44:31

react-router 返回一个页面你如何配置历史记录？

解决方案1
117 2015-09-10 19:06:20

解决方案2
85 2019-11-16 18:50:28

解决方案3
63 已采纳 2015-06-19 13:05:48

解决方案4
62 2018-03-06 11:53:48

解决方案5
45 2015-11-22 00:38:29

解决方案6
34 2016-08-05 19:25:56

解决方案7
23 2020-05-16 23:38:33

解决方案8
12 2017-09-05 01:33:00

解决方案9
12 2018-08-06 21:42:09

解决方案10
9 2015-10-09 07:10:58

解决方案11
8 2016-05-09 01:12:26

解决方案12
8 2017-10-16 19:10:27

解决方案13
8 2020-06-12 09:06:25

解决方案14
6 2018-11-01 18:26:17

解决方案15
4 2018-02-02 11:35:03

解决方案16
2 2018-05-05 23:51:38

解决方案17
2 2020-02-05 19:34:49

解决方案18
1 2017-11-28 15:06:32

解决方案19
1 2018-07-07 08:08:37

解决方案20
1 2021-05-12 14:31:02

解决方案21
1 2022-12-08 20:52:59

解决方案22
0 2018-10-04 09:06:44

解决方案23
0 2021-06-01 03:05:24

解决方案24
0 2022-01-23 11:04:36

在`react-router-dom` v6 上

解决方案25
0 2022-01-31 23:34:57

解决方案26
0 2022-08-30 07:27:35

解决方案27
0 2022-10-13 09:31:42

解决方案28
-1 2020-03-31 09:44:31