प्रतिक्रिया राउटर का उपयोग करके प्रोग्रामेटिक रूप से नेविगेट करें


1427

के साथ react-routerमैं का उपयोग कर सकते हैंLink लिंक बनाने के तत्व का जो मूल रूप से प्रतिक्रिया रूटर द्वारा नियंत्रित किया जाता है।

मैं आंतरिक रूप से इसे देखता हूं this.context.transitionTo(...)

मैं एक नेविगेशन करना चाहता हूं। लिंक से नहीं, बल्कि ड्रॉपडाउन चयन से (उदाहरण के रूप में)। मैं इसे कोड में कैसे कर सकता हूं? क्या है this.context?

मैंने Navigationमिक्सचर देखा , लेकिन क्या मैं इसके बिना कर सकता हूं mixins?


26
@SergioTapia ध्यान रखें कि यह प्रश्न प्रतिक्रिया-राउटर की एक बड़ी रिलीज़, प्रतिक्रिया की एक बड़ी रिलीज़, और जावास्क्रिप्ट की एक प्रमुख रिलीज़
जॉर्ज मौएर

5
यहाँ प्रतिक्रिया रूटर v4 के आधिकारिक डॉक्स में ट्यूटोरियल का लिंक दिया गया है: reacttraining.com/react-router/web/guides/scroll-restoration
chitzui

4
आप इस उत्तर की जांच कर सकते हैं stackoverflow.com/questions/44127739/…
शुभम खत्री

4
मुझे खुशी है कि आपको इसका उत्तर मिल गया है, लेकिन मुझे दुख है कि यह जटिल होना चाहिए। एक वेब ऐप के भीतर नेविगेट करना आसान और अच्छी तरह से प्रलेखित होना चाहिए। VueJS इसे तुच्छ बनाता है। प्रत्येक घटक को राउटर इंस्टेंस स्वचालित रूप से इंजेक्ट किया जाता है। उनके डॉक्स में इसके लिए स्पष्ट रूप से परिभाषित खंड है। router.vuejs.org/guide/essentials/navigation.html मुझे बहुत सारी चीजों के लिए रिएक्ट पसंद है, लेकिन यह कभी-कभी इतना जटिल होता है। </ rant>
colefner

7
@GeorgeMauer तुम सही हो। यह इस समुदाय के बारे में नहीं है। यह सवालों के जवाब देने के बारे में है, न कि चौखटों पर छींटाकशी करने पर। याद दिलाने के लिए शुक्रिया।
colefner

जवाबों:


1427

हुक के साथ राउटर v5.1.0

useHistoryयदि आप रिएक्ट> 16.8.0 और कार्यात्मक घटकों का उपयोग कर रहे हैं तो रिएक्टर राउटर> 5.1.0 में एक नया हुक है।

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

function HomeButton() {
  const history = useHistory();

  function handleClick() {
    history.push("/home");
  }

  return (
    <button type="button" onClick={handleClick}>
      Go home
    </button>
  );
}

अभिक्रिया राउटर v4

रिएक्ट राउटर के v4 के साथ, तीन दृष्टिकोण हैं जिन्हें आप घटकों के भीतर प्रोग्रामेटिक रूटिंग में ले जा सकते हैं।

  1. withRouterउच्च-क्रम घटक का उपयोग करें ।
  2. रचना का उपयोग करें और एक प्रस्तुत करना <Route>
  3. का प्रयोग करें context

रिएक्ट राउटर ज्यादातर historyलाइब्रेरी के आसपास एक आवरण है । अपने ब्राउज़र और हैश इतिहास के साथ historyब्राउज़र के window.historyलिए बातचीत को संभालता है । यह एक स्मृति इतिहास भी प्रदान करता है जो उन वातावरणों के लिए उपयोगी है जिनका वैश्विक इतिहास नहीं है। यह विशेष रूप से मोबाइल ऐप डेवलपमेंट में उपयोगी है (react-native नोड के साथ ) और यूनिट टेस्टिंग ।

एक historyउदाहरण में नेविगेट करने के दो तरीके हैं: pushऔर replace। यदि आप historyविज़िट किए गए स्थानों की एक सरणी के रूप में सोचते हैं, तो सरणी में pushएक नया स्थान जोड़ replaceदेगा और सरणी में वर्तमान स्थान को नए के साथ बदल देगा। आमतौर पर आप इसका उपयोग करना चाहेंगेpush विधि जब आप नेविगेट कर रहे हों।

रूटर प्रतिक्रिया के पिछले संस्करणों में, आप अपने खुद के बनाने के लिए किया था historyउदाहरण है, लेकिन v4 में <BrowserRouter>, <HashRouter>है, और <MemoryRouter>घटकों आपके लिए एक ब्राउज़र, हैश, और स्मृति उदाहरण बना होगा। रिएक्ट राउटर ऑब्जेक्ट के historyमाध्यम से आपके राउटर से जुड़े इंस्टेंस के गुणों और तरीकों को संदर्भ के माध्यम से उपलब्ध कराता है router

1. withRouterउच्च-क्रम घटक का उपयोग करें

withRouterउच्च क्रम घटक इंजेक्षन जाएगा historyघटक के एक आधार के रूप में वस्तु। यह आपको pushऔर replaceनिपटने के तरीकों के बिना उपयोग करने की अनुमति देता है context

import { withRouter } from 'react-router-dom'
// this also works with react-router-native

const Button = withRouter(({ history }) => (
  <button
    type='button'
    onClick={() => { history.push('/new-location') }}
  >
    Click Me!
  </button>
))

2. संरचना का उपयोग करें और रेंडर करें <Route>

<Route>घटक बस मिलान स्थानों के लिए नहीं है। आप एक मार्गहीन मार्ग प्रस्तुत कर सकते हैं और यह हमेशा वर्तमान स्थान से मेल खाएगा<Route>घटक के रूप में एक ही रंगमंच की सामग्री से गुजरता है withRouter, तो आप का उपयोग करने के लिए सक्षम हो जाएगा historyके माध्यम से तरीकों historyप्रोप।

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

const Button = () => (
  <Route render={({ history}) => (
    <button
      type='button'
      onClick={() => { history.push('/new-location') }}
    >
      Click Me!
    </button>
  )} />
)

3. संदर्भ का उपयोग करें *

लेकिन आपको शायद नहीं करना चाहिए

अंतिम विकल्प वह है जिसका उपयोग आपको केवल तभी करना चाहिए जब आप रिएक्ट के संदर्भ मॉडल (रिएक्ट का संदर्भ एपीआई v16 के रूप में स्थिर हो) के साथ काम करने में सहज महसूस करें ।

const Button = (props, context) => (
  <button
    type='button'
    onClick={() => {
      // context.history.push === history.push
      context.history.push('/new-location')
    }}
  >
    Click Me!
  </button>
)

// you need to specify the context type so that it
// is available within the component
Button.contextTypes = {
  history: React.PropTypes.shape({
    push: React.PropTypes.func.isRequired
  })
}

1 और 2 लागू करने के लिए सबसे सरल विकल्प हैं, इसलिए अधिकांश उपयोग के मामलों के लिए, वे आपके सबसे अच्छे दांव हैं।


24
मैंने विधि 1 का उपयोग इस तरह से करने की कोशिश की, जैसे कि राउटर (({इतिहास}) => {कंसोल.लॉग ("hhhhhhhhh"); इतिहास.पश ('/' दांव ')}); लेकिन यह
दिमित्री मालुगिन

57
क्या!? मैं बस अपने सभी घटकों के माध्यम से नीचे withRouterजाने के बजाय उपयोग कर सकता historyहूं ?? Gahh मुझे डॉक्स पढ़ने में अधिक समय बिताने की आवश्यकता है ...
hellojeffhall

18
आप history.push('/new-location')उस व्यवहार को बटन या अन्य DOM तत्व में संलग्न किए बिना कैसे चला सकते हैं ?
नील

4
त्रुटि के रूप में फेंकUnexpected use of 'history' no-restricted-globals
परदीप जैन

18
contextअब प्रायोगिक प्रतिक्रिया के रूप में 16 नहीं है।
ट्राइसेप्स

920

प्रतिक्रिया-राउटर 5.1.0+ उत्तर (हुक और प्रतिक्रिया का उपयोग करके> 16.8)

आप useHistoryकार्यात्मक घटकों पर नए हुक का उपयोग कर सकते हैं और प्रोग्रामेटिक रूप से नेविगेट कर सकते हैं:

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

function HomeButton() {
  let history = useHistory();
  // use history.push('/some/path') here
};

प्रतिक्रिया-राउटर 4.0.0+ उत्तर

4.0 और इसके बाद के संस्करण में, अपने घटक के एक प्रारूप के रूप में इतिहास का उपयोग करें।

class Example extends React.Component {
   // use `this.props.history.push('/some/path')` here
};

ध्यान दें: यह। मामले में आपके घटक द्वारा प्रस्तुत नहीं किए जाने की स्थिति में मौजूद नहीं है <Route>। आपको <Route path="..." component={YourComponent}/>YourComponent में इस .props.history का उपयोग करना चाहिए

प्रतिक्रिया-राउटर 3.0.0+ उत्तर

3.0 और इसके बाद के संस्करण में, अपने घटक के एक प्रोप के रूप में राउटर का उपयोग करें।

class Example extends React.Component {
   // use `this.props.router.push('/some/path')` here
};

प्रतिक्रिया-राउटर 2.4.0+ उत्तर

2.4 और इसके बाद के संस्करण में, अपने कंपोनेंट के प्रॉप के रूप में राउटर प्राप्त करने के लिए एक उच्च ऑर्डर कंपोनेंट का उपयोग करें।

import { withRouter } from 'react-router';

class Example extends React.Component {
   // use `this.props.router.push('/some/path')` here
};

// Export the decorated class
var DecoratedExample = withRouter(Example);

// PropTypes
Example.propTypes = {
  router: React.PropTypes.shape({
    push: React.PropTypes.func.isRequired
  }).isRequired
};

प्रतिक्रिया-राउटर 2.0.0+ उत्तर

यह संस्करण 1.x के साथ पीछे की ओर संगत है, इसलिए अपग्रेड गाइड की कोई आवश्यकता नहीं है। केवल उदाहरणों के माध्यम से जाना काफी अच्छा होना चाहिए।

यदि आप नए पैटर्न पर स्विच करना चाहते हैं, तो कहा कि, राउटर के अंदर एक ब्राउज़रहिस्टर मॉड्यूल है जिसे आप एक्सेस कर सकते हैं

import { browserHistory } from 'react-router'

अब आपके पास अपने ब्राउज़र इतिहास तक पहुंच है, इसलिए आप पुश, रिप्लेस, आदि जैसी चीजें कर सकते हैं ... जैसे:

browserHistory.push('/some/path')

आगे पढ़ने: इतिहास और नेविगेशन


प्रतिक्रिया-राउटर 1.xx उत्तर

मैं उन्नयन के विवरण में नहीं जाऊंगा। आप इस बारे में अपग्रेड गाइड में पढ़ सकते हैं

यहां प्रश्न के बारे में मुख्य परिवर्तन नेविगेशन मिक्सिन से इतिहास में परिवर्तन है। अब यह मार्ग बदलने के लिए ब्राउज़र हिस्ट्रीएपीआई का उपयोग कर रहा है इसलिए हम pushState()अभी से उपयोग करेंगे ।

यहां मिक्सिन का उपयोग करने की छूट है:

var Example = React.createClass({
  mixins: [ History ],
  navigateToHelpPage () {
    this.history.pushState(null, `/help`);
  }
})

ध्यान दें कि यह रैक्ट / इतिहास परियोजना Historyसे आता है । रिएक्ट-राउटर से ही नहीं।

यदि आप किसी कारण के लिए (शायद ES6 वर्ग के कारण) मिक्सिन का उपयोग नहीं करना चाहते हैं, तो आप उस इतिहास तक पहुंच सकते हैं जो आपको राउटर से मिलता है this.props.history। यह केवल आपके राउटर द्वारा प्रस्तुत किए गए घटकों के लिए सुलभ होगा। इसलिए, यदि आप इसे किसी भी बाल घटक में उपयोग करना चाहते हैं तो इसे एक विशेषता के रूप में नीचे पारित करने की आवश्यकता है props

आप उनके 1.0.x प्रलेखन में नई रिलीज़ के बारे में अधिक पढ़ सकते हैं

यहां आपके घटक के बाहर नेविगेट करने के बारे में विशेष रूप से एक सहायता पृष्ठ है

यह एक संदर्भ को हथियाने history = createHistory()और replaceStateउस पर कॉल करने की सिफारिश करता है।

प्रतिक्रिया-रूटर 0.13.x उत्तर

मैं एक ही समस्या में पड़ गया और केवल नेविगेशन मिक्सिन के साथ समाधान पा सकता था जो प्रतिक्रिया-राउटर के साथ आता है।

यहाँ है कि मैं यह कैसे किया

import React from 'react';
import {Navigation} from 'react-router';

let Authentication = React.createClass({
  mixins: [Navigation],

  handleClick(e) {
    e.preventDefault();

    this.transitionTo('/');
  },

  render(){
    return (<div onClick={this.handleClick}>Click me!</div>);
  }
});

मैं transitionTo()एक्सेस करने की आवश्यकता के बिना कॉल करने में सक्षम था.context

या आप फैंसी ES6 की कोशिश कर सकते हैं class

import React from 'react';

export default class Authentication extends React.Component {
  constructor(props) {
    super(props);
    this.handleClick = this.handleClick.bind(this);
  }

  handleClick(e) {
    e.preventDefault();

    this.context.router.transitionTo('/');
  }

  render(){
    return (<div onClick={this.handleClick}>Click me!</div>);
  }
}

Authentication.contextTypes = {
  router: React.PropTypes.func.isRequired
};

प्रतिक्रिया-रूटर-Redux

नोट: यदि आप Redux का उपयोग कर रहे हैं, तो एक और परियोजना है, जिसे React-Router-Redux कहा जाता है, जो आपको ReactRouter के लिए Redux बाइंडिंग देता है, कुछ उसी दृष्टिकोण का उपयोग करके जो कि React-Redux करता है

रिएक्ट-राउटर-रेडक्स में कुछ तरीके उपलब्ध हैं जो एक्शन क्रिएटर्स के अंदर से सरल नेविगेट करने की अनुमति देते हैं। ये उन लोगों के लिए विशेष रूप से उपयोगी हो सकते हैं जिनके पास रिएक्ट नेटिव में मौजूदा आर्किटेक्चर है, और वे कम से कम बायलरप्लेट ओवरहेड के साथ रिएक्ट वेब में समान पैटर्न का उपयोग करना चाहते हैं।

निम्नलिखित विधियों का अन्वेषण करें:

  • push(location)
  • replace(location)
  • go(number)
  • goBack()
  • goForward()

यहां एक उदाहरण उपयोग है, Redux-Thunk के साथ :

./actioncreators.js

import { goBack } from 'react-router-redux'

export const onBackPress = () => (dispatch) => dispatch(goBack())

./viewcomponent.js

<button
  disabled={submitting}
  className="cancel_button"
  onClick={(e) => {
    e.preventDefault()
    this.props.onBackPress()
  }}
>
  CANCEL
</button>

3
मैं उपयोग कर रहा हूं v2.4.0लेकिन उल्लिखित दृष्टिकोण मेरे लिए काम नहीं करता है, मेरा ऐप बिल्कुल भी प्रस्तुत नहीं करता है और कंसोल आउटपुट: Uncaught TypeError: (0 , _reactRouter.withRouter) is not a functionमेरी एसओ पोस्ट का लिंक यहां है: stackoverflow.com/questions/37306166/…
nburk

7
यह स्वीकृत उत्तर होना चाहिए, स्वीकार किया गया एक गड़बड़ है और बहुत पुराना है। @GiantElk मेरे पास यह काम कर रहा है जैसा कि संस्करण के लिए उत्तर में वर्णित है 2.6.0
JMac

2
क्या यह दृष्टिकोण अभी भी संस्करण के लिए अनुशंसित तरीका है 3.0.x? बहुत से लोग contextरास्ते का उपयोग करने लगते हैं ।
velop

6
4.0 में, यह .props.history मौजूद नहीं है। क्या हो रहा है?
निकोलस S.Xu

4
@ NicolasS.Xu this.props.historyआपके घटक द्वारा प्रस्तुत नहीं किए जाने के मामले में मौजूद नहीं है <Route>। आप का उपयोग करना चाहिए <Route path="..." component={YourComponent}/>करने के लिए this.props.historyमें YourComponent
वोग्डब

508

प्रतिक्रिया-राउटर v2

सबसे हालिया रिलीज ( v2.0.0-rc5) के लिए, अनुशंसित नेविगेशन विधि सीधे इतिहास सिंगलटन पर जोर दे रही है। आप देख सकते हैं कि घटक के बाहर नेविगेट करने की क्रिया में doc

प्रासंगिक अंश:

import { browserHistory } from 'react-router';
browserHistory.push('/some/path');

यदि नए प्रतिक्रिया-राउटर एपीआई का उपयोग करते हैं, तो आपको घटकों के अंदर historyसे इसका उपयोग करने की आवश्यकता होती है this.props:

this.props.history.push('/some/path');

यह भी प्रदान करता है, pushStateलेकिन प्रति लॉग इन चेतावनियों को हटा दिया गया है।

यदि उपयोग किया जाता है react-router-redux, तो यह एक pushफ़ंक्शन प्रदान करता है जिसे आप इस तरह भेज सकते हैं:

import { push } from 'react-router-redux';
this.props.dispatch(push('/some/path'));

हालाँकि इसका उपयोग केवल URL को बदलने के लिए किया जा सकता है, न कि वास्तव में पेज पर नेविगेट करने के लिए।


15
यह मत भूलो कि नया एपीआई उपयोग नहीं करता है import { browserHistory } from './react-router'बल्कि इसके बजाय इतिहास का उपयोग करता है import createBrowserHistory from 'history/lib/createBrowserHistory'। बाद में, आप historyघटक प्रॉप्स से पहुंच सकते हैं :this.props.history('/some/path')
रिकार्डो पेड्रोनी

7
var browserHistory = require('react-router').browserHistory; browserHistory.goBack();
बॉबी

7
प्रतिक्रिया-राउटर-रिडक्स pushकेवल URL बदलता है, वास्तव में पृष्ठ नहीं बदलता है। दोनों आयात करने के लिए, browserHistoryसे react-routerऔर उपयोग browserHistory.push('/my-cool-path')। दुर्भाग्य से, यह खोजने के लिए सुपर आसान नहीं है। github.com/reactjs/react-router/blob/master/docs/guides/…
एंड्रयू सैम्यूल्सन

4
मैं इसका उपयोग कर रहा हूं। Props.history.push ('/') लेकिन केवल URL बदल जाता है ... यहां कोई वास्तविक रूटिंग नहीं चल रही है। मैं क्या खो रहा हूँ?
rgcalsaverini

2
मैंने अभी अपना react-router
लेटर

56

यहाँ आप कैसे के साथ ऐसा है react-router v2.0.0साथ ES6react-routerमिश्रण से दूर चला गया है।

import React from 'react';

export default class MyComponent extends React.Component {
  navigateToPage = () => {
    this.context.router.push('/my-route')
  };

  render() {
    return (
      <button onClick={this.navigateToPage}>Go!</button>
    );
  }
}

MyComponent.contextTypes = {
  router: React.PropTypes.object.isRequired
}

5
मेरा मानना ​​है कि वर्तमान अनुशंसा historyएकलिंग का उपयोग करने के लिए है जैसा कि @ बॉबी ने कहा है। आप सकता का उपयोग context.router, लेकिन आप instantiating के रूप में उन घटकों इकाई परीक्षण करने के लिए यह वास्तव में मुश्किल बना रहे हैं सिर्फ घटक संदर्भ में इस की ज़रूरत नहीं होगी कि।
जॉर्ज मौएर

2
@GeorgeMauer मुझे लगता है कि यह इस बात पर निर्भर करता है कि कोड कहां चल रहा है। डॉक्स के अनुसार, यदि सर्वर पर इसे चलाया जाता है, तो संदर्भ। संदर्भ उपयोग की सिफारिश की जाती है। github.com/reactjs/react-router/blob/master/upgrad-guides/…
KumarM

50

प्रतिक्रिया-राउटर 4.x उत्तर:

अपने अंत में, मुझे एक एकल इतिहास वस्तु पसंद है जिसे मैं बाहर के घटकों में भी ले जा सकता हूं। मुझे जो करना पसंद है वह है एक एकल इतिहास। जेएस फाइल जो मैं मांग पर आयात करता हूं, और बस इसे हेरफेर करता हूं।

आपको बस BrowserRouterराउटर में बदलना होगा, और इतिहास के प्रारूप को निर्दिष्ट करना होगा। यह आपके लिए कुछ भी नहीं बदलता है सिवाय इसके कि आपके पास अपना इतिहास वस्तु है जिसे आप अपनी इच्छानुसार हेरफेर कर सकते हैं।

आपको इतिहास , लाइब्रेरी का उपयोग करने की आवश्यकता है react-router

उदाहरण उपयोग, ES6 अंकन:

History.js

import createBrowserHistory from 'history/createBrowserHistory'
export default createBrowserHistory()

BasicComponent.js

import React, { Component } from 'react';
import history from './history';

class BasicComponent extends Component {

    goToIndex(e){
        e.preventDefault();
        history.push('/');
    }

    render(){
        return <a href="#" onClick={this.goToIndex}>Previous</a>;
    }
}

EDIT 16 अप्रैल, 2018:

यदि आपको एक घटक से नेविगेट करना है जो वास्तव में एक Routeघटक से प्रदान किया गया है, तो आप उस तरह से भी इतिहास को एक्सेस कर सकते हैं:

BasicComponent.js

import React, { Component } from 'react';

class BasicComponent extends Component {

    navigate(e){
        e.preventDefault();
        this.props.history.push('/url');
    }

    render(){
        return <a href="#" onClick={this.navigate}>Previous</a>;
    }
}

2
सिवाय प्रतिक्रिया रूटर डॉक्स हमें बताएं कि आप नहीं करना चाहिए, ज्यादातर मामलों के लिए, उपयोग करने की आवश्यकता Routerके बजाय BrowserRouter। आपके लिए ऑब्जेक्ट BrowserRouterबनाता और बनाए रखता है history। आपको अपना स्वयं का निर्माण करने के लिए डिफ़ॉल्ट नहीं होना चाहिए, केवल अगर आपको ["Redux जैसे राज्य प्रबंधन उपकरणों के साथ गहन एकीकरण की आवश्यकता है।"] reacttraining.com/react-router/web/api/Router
bobbyz

2
यह कुछ ऐसा है जिसे मैंने समय और अनुभव के साथ सीखा है। हालांकि यह आमतौर पर डिफ़ॉल्ट का उपयोग करने के लिए एक अच्छा अभ्यास है this.props.history, मुझे अभी तक एक समाधान नहीं मिला है जो मुझे कक्षा में ऐसा काम करने में मदद कर सकता है जो एक घटक या कोई अन्य उपकरण नहीं है जो कि रिएक्ट घटक के रूप में नहीं बनाया गया है आप नीचे सहारा पास कर सकते हैं। आपकी प्रतिक्रिया के लिए धन्यवाद :)
एरिक मार्टिन

44

इसके लिए, जो सर्वर साइड को नियंत्रित नहीं करता है और इस वजह से हैश राउटर v2 का उपयोग कर रहा है:

अपना इतिहास अलग फ़ाइल में रखें (जैसे app_history.js ES6):

import { useRouterHistory } from 'react-router'
import { createHashHistory } from 'history'
const appHistory = useRouterHistory(createHashHistory)({ queryKey: false });

export default appHistory;

और हर जगह इसका उपयोग करें!

प्रतिक्रिया-राउटर के लिए आपका प्रवेश बिंदु (app.js ES6):

import React from 'react'
import { render } from 'react-dom'
import { Router, Route, Redirect } from 'react-router'
import appHistory from './app_history'
...
const render((
  <Router history={appHistory}>
  ...
  </Router>
), document.querySelector('[data-role="app"]'));

किसी भी घटक (ES6) के अंदर आपका नेविगेशन:

import appHistory from '../app_history'
...
ajaxLogin('/login', (err, data) => {
  if (err) {
    console.error(err); // login failed
  } else {
    // logged in
    appHistory.replace('/dashboard'); // or .push() if you don't need .replace()
  }
})

1
धन्यवाद। शायद मुझे कुछ याद आ रहा है। क्या यह शीर्ष दो उत्तरों के समान नहीं है?
जॉर्ज मौअर

2
जब आप "हैश" नेविगेशन का उपयोग कर रहे हैं, तो "प्रतिक्रिया-राउटर" v2 में आपको अतिरिक्त मॉड्यूल "इतिहास" स्थापित करने की आवश्यकता है (यदि आप अजीब हैश प्रश्नों से बचना चाहते हैं), और ब्राउज़रहिस्ट्री का उपयोग करने के बजाय आपको useRouterHistory (createHashHistory) का उपयोग करने की आवश्यकता है ( {क्वेरीके: झूठा})। यही मुख्य कारण है कि मैंने यह पोस्ट किया है। मैंने दिखाया कि कैसे हैश इतिहास के साथ नेविगेट करना है।
अलेक्सी वोलोडको

1
ओह, मैं देख रहा हूँ, तुम सही हो। मैं अब उस प्रोजेक्ट पर नहीं हूं, लेकिन मुझे लगता है कि पसंदीदा तरीका historyअब या तो दृष्टिकोण के लिए उपयोग करना है
जॉर्ज माउर

4
यह उत्तर सबसे अच्छा क्यों नहीं है? कॉन्‍टेक्‍ट या एचओसी या ईवेंट प्रोटोटाइप के साथ सभी समस्‍याओं में क्‍यों जाएं, क्‍यों न केवल इतिहास को आयात करें और कहीं भी उपयोग करें जहां हम कृपया? बस
ट्रेडऑफ

@storm_buster कोई ट्रेडऑफ़ नहीं है। हमारे पास ईएस 6 मॉड्यूल हैं और हमें उनका उपयोग करना चाहिए! यह सब कुछ के लिए अपने उपकरण (इस मामले में प्रतिक्रिया) का उपयोग करने का एक ऐसा विशिष्ट प्रदर्शन है-यहां तक ​​कि उन चीजों के लिए जो आप वास्तव में उनके लिए उपयोग नहीं करना चाहते हैं।
कैपज

40

अभिक्रिया राउटर V4

tl: डॉ;

if (navigate) {
  return <Redirect to="/" push={true} />
}

सरल और घोषणात्मक उत्तर यह है कि आपको इसके <Redirect to={URL} push={boolean} />साथ संयोजन में उपयोग करने की आवश्यकता हैsetState()

पुश: बूलियन - जब सही होता है, तो पुनर्निर्देशन वर्तमान को बदलने के बजाय इतिहास पर एक नई प्रविष्टि को आगे बढ़ाएगा।


import { Redirect } from 'react-router'

class FooBar extends React.Component {
  state = {
    navigate: false
  }

  render() {
    const { navigate } = this.state

    // here is the important part
    if (navigate) {
      return <Redirect to="/" push={true} />
    }
   // ^^^^^^^^^^^^^^^^^^^^^^^

    return (
      <div>
        <button onClick={() => this.setState({ navigate: true })}>
          Home
        </button>
      </div>
    )
  }
}

पूरा उदाहरण यहां । और अधिक पढ़ें यहाँ

पुनश्च। उदाहरण स्थिति को इनिशियलाइज़ करने के लिए ES7 + प्रॉपर्टी इनिशियलाइज़र का उपयोग करता है । देखो यहाँ के रूप में अच्छी तरह से, अगर आप रुचि रखते हैं।


यह मुझे मिला सबसे अच्छा जवाब है। withRouterजब पहले से लोड किए जा रहे रूट पर काम नहीं कर रहा था, तब उपयोग करना । हमारे मामले में, हम चुनिंदा या तो करना ही था setState(के कारण return <Redirect>) यदि पहले से ही मार्ग पर या history.push()कहीं और से।
कर्मकज

बहुत, बहुत चालाक। और फिर भी बहुत सरल है। टी.के.एस। मैंने इसका उपयोग ReactRouterTable के अंदर किया क्योंकि मैं पूरी लाइन पर क्लिक को हैंडल करना चाहता था। राज्य सेट करने के लिए onRow पर क्लिक करें। setState ({travelTo: "/ path /" + row.uuid});
लोवाटो

यह बुलेट प्रूफ उत्तर है।
नितिन जाधव

31

चेतावनी: यह उत्तर 1.0 से पहले केवल रीक्रिएट राउटर संस्करणों को शामिल करता है

मैं इस उत्तर को 1.0.0-rc1 उपयोग मामलों के बाद अपडेट करूंगा!

आप इसे मिक्सी के बिना भी कर सकते हैं।

let Authentication = React.createClass({
  contextTypes: {
    router: React.PropTypes.func
  },
  handleClick(e) {
    e.preventDefault();
    this.context.router.transitionTo('/');
  },
  render(){
    return (<div onClick={this.handleClick}>Click me!</div>);
  }
});

संदर्भों के साथ गेटा यह है कि यह तब तक सुलभ नहीं है जब तक कि आप contextTypesवर्ग को परिभाषित न करें ।

जैसा कि संदर्भ के लिए है, यह एक वस्तु है, जैसे प्रॉप्स, जो कि माता-पिता से बच्चे तक पारित हो जाते हैं, लेकिन इसे हर बार बदल दिया जाता है। Https://www.tildedave.com/2014/11/15/introduction-to-contexts-in-react-js.html देखें


26

मैंने कुछ करने से पहले सही तरीके से काम करने के कम से कम 10 तरीके आज़माए!

@ फेलिप स्किनर का withRouterजवाब मेरे लिए थोड़ा भारी था, और मुझे यकीन नहीं था कि मैं नए "ExportedWithRouter" वर्ग के नाम बनाना चाहता हूं।

यहाँ यह करने के लिए सबसे सरल और साफ तरीका है, लगभग मौजूदा रिएक्ट-राउटर 3.0.0 और ES6:

रिएक्ट-राउटर 3.xx ES6 के साथ:

import { withRouter } from 'react-router';

class Example extends React.Component {
   // use `this.props.router.push('/some/path')` here
};

// Export the decorated class
export default withRouter(Example);

या, यदि यह आपका डिफ़ॉल्ट वर्ग नहीं है, तो निर्यात करें:

withRouter(Example);
export { Example };

ध्यान दें कि 3.xx में, <Link>घटक स्वयं का उपयोग कर रहा है router.push, इसलिए आप इसे कुछ भी पास कर सकते हैं जो आप <Link to=टैग को पास करेंगे , जैसे:

   this.props.router.push({pathname: '/some/path', query: {key1: 'val1', key2: 'val2'})'

1
यह पूरी तरह से ठीक काम करता है। लेकिन कोड के 200 OKबजाय प्रतिक्रिया करता है 30x। मैं इस समस्या को कैसे हल कर सकता हूं?
मुहम्मद अतीक आज़म

1
निश्चित नहीं। यह मेरे लिए कभी नहीं आया क्योंकि यह कोई बाहरी अनुरोध नहीं है - यह पृष्ठ पर क्या है इसे बदलने के लिए पेज के स्वयं के कोड का उपयोग करके सिर्फ आपका ब्राउज़र है। यदि आप चाहें तो आप हमेशा एक मैनुअल जावास्क्रिप्ट रीडायरेक्ट कर सकते हैं।
बेन व्हीलर

1
इसे @ डेथ राउटर के साथ क्लास डेकोरेटर के रूप में भी इस्तेमाल किया जा सकता है ... मोबाइल फोन के साथ बढ़िया चलता है
Dan

21

नेविगेशन को प्रोग्रामिक रूप से करने के लिए, आपको अपने में एक नए इतिहास को props.history पर धकेलना होगा component, इसलिए ऐसा कुछ आपके लिए काम कर सकता है:

//using ES6
import React from 'react';

class App extends React.Component {

  constructor(props) {
    super(props)
    this.handleClick = this.handleClick.bind(this)
  }

  handleClick(e) {
    e.preventDefault()
    /* Look at here, you can add it here */
    this.props.history.push('/redirected');
  }

  render() {
    return (
      <div>
        <button onClick={this.handleClick}>
          Redirect!!!
        </button>
      </div>
    )
  }
}

export default App;

कृपया प्रतिक्रिया-राउटर का संस्करण लिखें
ऐश

19

ES6 + रिएक्ट घटकों के लिए, निम्न समाधान ने मेरे लिए काम किया।

मैंने फेल्पी स्किनर का पालन किया, लेकिन मेरे जैसे शुरुआती लोगों की मदद करने के लिए अंत समाधान के लिए एक अंत जोड़ा।

नीचे मेरे द्वारा उपयोग किए गए संस्करण हैं:

"प्रतिक्रिया-राउटर": "^ 2.7.0"

"प्रतिक्रिया": "^ 15.3.1"

नीचे मेरी प्रतिक्रिया घटक है जहां मैंने प्रतिक्रिया-राउटर का उपयोग करके प्रोग्रामेटिक नेविगेशन का उपयोग किया है:

import React from 'react';

class loginComp extends React.Component {
   constructor( context) {
    super(context);
    this.state = {
      uname: '',
      pwd: ''
    };
  }

  redirectToMainPage(){
        this.context.router.replace('/home');
  }

  render(){
    return <div>
           // skipping html code 
             <button onClick={this.redirectToMainPage.bind(this)}>Redirect</button>
    </div>;
  }
};

 loginComp.contextTypes = {
    router: React.PropTypes.object.isRequired
 }

 module.exports = loginComp;

नीचे मेरे राउटर के लिए विन्यास है:

 import { Router, Route, IndexRedirect, browserHistory } from 'react-router'

 render(<Router history={browserHistory}>
          <Route path='/' component={ParentComp}>
            <IndexRedirect to = "/login"/>
            <Route path='/login' component={LoginComp}/>
            <Route path='/home' component={HomeComp}/>
            <Route path='/repair' component={RepairJobComp} />
            <Route path='/service' component={ServiceJobComp} />
          </Route>
        </Router>, document.getElementById('root'));

19

सबसे अच्छा तरीका नहीं हो सकता है लेकिन ... प्रतिक्रिया-राउटर v4 का उपयोग करना, निम्नलिखित टाइपस्क्रिप्ट कुछ के लिए एक विचार दे सकता है।

नीचे दिए गए घटक में, उदाहरण के लिए LoginPage, routerवस्तु सुलभ है और router.transitionTo('/homepage')नेविगेट करने के लिए बस कॉल करें।

नेविगेशन कोड लिया गया था से

"react-router": "^4.0.0-2", "react": "^15.3.1",

import Router from 'react-router/BrowserRouter';
import { History } from 'react-history/BrowserHistory';
import createHistory from 'history/createBrowserHistory';
const history = createHistory();

interface MatchWithPropsInterface {
  component: typeof React.Component,
  router: Router,
  history: History,
  exactly?: any,
  pattern: string
}

class MatchWithProps extends React.Component<MatchWithPropsInterface,any> {
  render() {
    return(
      <Match {...this.props} render={(matchProps) => (
             React.createElement(this.props.component, this.props)

        )}
       />
    )
  }
}

ReactDOM.render(
    <Router>
      {({ router }) => (
        <div>
          <MatchWithProps exactly pattern="/" component={LoginPage} router={router} history={history} />
          <MatchWithProps pattern="/login" component={LoginPage} router={router} history={history} />
          <MatchWithProps pattern="/homepage" component={HomePage} router={router} history={history} />
          <Miss component={NotFoundView} />
        </div>
      )}
    </Router>,

   document.getElementById('app')
);


1
आपRRouter और BrowserHistory का उपयोग क्यों नहीं करते हैं?
एरविन मेयर

1
@Erwin एपीआई v4 में अलग है। इस github.com/ReactTraining/react-router/issues/3847 देखें ।
mcku

1
@mcku आपको प्रतिक्रिया-राउटर v4 के लिए अपनी टाइपस्क्रिप्ट dts फ़ाइल कहां मिली?
जम्मूतवी

1
@jmathew के पास प्रतिक्रिया-राउटर v4 के लिए किसी भी प्रकार की परिभाषा नहीं है
mcku

16

में प्रतिक्रिया-रूटर v4 और ES6

आप उपयोग कर सकते हैं withRouterऔर this.props.history.push

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

class Home extends Component {

    componentDidMount() {
        this.props.history.push('/redirect-to');
    }
}

export default withRouter(Home);

2
पहले से ही कई अन्य उत्तरों (शीर्ष उत्तर में लंबाई सहित) में उल्लेख किया गया है
जॉर्ज माउर

13

withRouterक्लास-आधारित घटक के साथ उपयोग करने के लिए , नीचे कुछ इस तरह का प्रयास करें। उपयोग करने के लिए निर्यात विवरण बदलने के लिए मत भूलना withRouter:

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

class YourClass extends React.Component {
  yourFunction = () => {
    doSomeAsyncAction(() =>
      this.props.history.push('/other_location')
    )
  }

  render() {
    return (
      <div>
        <Form onSubmit={ this.yourFunction } />
      </div>
    )
  }
}

export default withRouter(YourClass);

11


जोस एंटोनियो पोस्टिगो और बेन व्हीलर
की नवीनता के पिछले उत्तर के आधार पर ? टाइपस्क्रिप्ट
और डेकोरेटर
या स्थिर संपत्ति / क्षेत्र के उपयोग में लिखा जाना है

import * as React from "react";
import Component = React.Component;
import { withRouter } from "react-router";

export interface INavigatorProps {
    router?: ReactRouter.History.History;
}

/**
 * Note: goes great with mobx 
 * @inject("something") @withRouter @observer
 */
@withRouter
export class Navigator extends Component<INavigatorProps, {}>{
    navigate: (to: string) => void;
    constructor(props: INavigatorProps) {
        super(props);
        let self = this;
        this.navigate = (to) => self.props.router.push(to);
    }
    render() {
        return (
            <ul>
                <li onClick={() => this.navigate("/home")}>
                    Home
                </li>
                <li onClick={() => this.navigate("/about")}>
                    About
                </li>
            </ul>
        )
    }
}

/**
 * Non decorated 
 */
export class Navigator2 extends Component<INavigatorProps, {}> {

    static contextTypes = {
        router: React.PropTypes.object.isRequired,
    };

    navigate: (to: string) => void;
    constructor(props: INavigatorProps, context: any) {
        super(props, context);
        let s = this;
        this.navigate = (to) =>
            s.context.router.push(to);
    }
    render() {
        return (
            <ul>
                <li onClick={() => this.navigate("/home")}>
                    Home
                </li>
                <li onClick={() => this.navigate("/about")}>
                    About
                </li>
            </ul>
        )
    }
}

आज जो भी npm स्थापित किया गया है। "प्रतिक्रिया-राउटर": "^ 3.0.0" और
"@ प्रकार / प्रतिक्रिया-राउटर": "^ 2.0.41"


11

क्षितिज पर रिएक्ट-राउटर v4 के साथ, अब ऐसा करने का एक नया तरीका है।

import { MemoryRouter, BrowserRouter } from 'react-router';

const navigator = global && global.navigator && global.navigator.userAgent;
const hasWindow = typeof window !== 'undefined';
const isBrowser = typeof navigator !== 'undefined' && navigator.indexOf('Node.js') === -1;
const Router = isBrowser ? BrowserRouter : MemoryRouter;

<Router location="/page-to-go-to"/>

प्रतिक्रिया-लेगो एक उदाहरण ऐप है जो दिखाता है कि प्रतिक्रिया-राउटर का उपयोग / अपडेट कैसे करें और इसमें उदाहरण कार्यात्मक परीक्षण शामिल हैं जो ऐप को नेविगेट करते हैं।


5
यह रेंडर फ़ंक्शन से नेविगेट करने के लिए बहुत अच्छा है, हालांकि मुझे आश्चर्य है कि जीवनचक्र हुक, या रिडक्स जैसी किसी चीज़ से नेविगेट कैसे करें?
रुबेन मार्टिनेज जूनियर

11

प्रतिक्रिया में राउटर v4। मैं प्रोग्रामेटिक तरीके से रूट करने के लिए इस दो तरीके का पालन करता हूं।

1. this.props.history.push("/something/something")
2. this.props.history.replace("/something/something")

नंबर दो

इतिहास स्टैक पर वर्तमान प्रविष्टि को बदलता है

प्रॉप्स में इतिहास पाने के लिए आपको अपने कंपोनेंट को लपेटना पड़ सकता है

withRouter


धन्यवाद!! सर्वश्रेष्ठ उत्तर
ताहा फारूकी

9

यदि आप हैश या ब्राउज़र इतिहास का उपयोग कर रहे हैं तो आप कर सकते हैं

hashHistory.push('/login');
browserHistory.push('/login');

2
hashHistory.push, अपरिभाषित की संपत्ति "पुश" नहीं पढ़ सकता है। आप इन्हें कहां से आयात करते हैं?
आर्कनोबा

"प्रतिक्रिया-राउटर" से {hashHistory} आयात करें; आप इसे इस तरह से शीर्ष पर आयात कर सकते हैं।
ज़मां अफजल

मैं अपनी redux गाथा फ़ाइल से आपके कोड नमूने का उपयोग कर रहा हूं, जैसे आपने कहा था उसका आयात कर रहा हूं और उसका उपयोग करता हूं, लेकिन मुझे वह TypeError मिलती रहती है।
आर्कनोबा

8

वर्तमान प्रतिक्रिया संस्करण (15.3) के साथ, this.props.history.push('/location');मेरे लिए काम किया, लेकिन इसने निम्नलिखित चेतावनी दी:

browser.js: 49 चेतावनी: [प्रतिक्रिया-रूटर] props.historyऔर context.historyपदावनत किए जाते हैं। कृपया उपयोग करें context.router

और मैंने इसे context.routerइस तरह से हल किया :

import React from 'react';

class MyComponent extends React.Component {

    constructor(props) {
        super(props);
        this.backPressed = this.backPressed.bind(this);
    }

    backPressed() {
        this.context.router.push('/back-location');
    }

    ...
}

MyComponent.contextTypes = {
    router: React.PropTypes.object.isRequired
};

export default MyComponent;

1
यह V4 के लिए काम कर रहा है। अच्छी तरह से ... करीब ... यह वास्तव में यह होने की जरूरत है ।context.router.history.push ('/ back-location');
velohomme

7

प्रतिक्रिया-राउटर V4

यदि आप संस्करण 4 का उपयोग कर रहे हैं, तो आप मेरी लाइब्रेरी (बेशर्म प्लग) का उपयोग कर सकते हैं, जहां आप बस एक कार्रवाई भेजते हैं और सब कुछ बस काम करता है!

dispatch(navigateTo("/aboutUs"));

trippler


5

जो प्रतिक्रिया-राउटर v4 पर इसे लागू करने में समस्याओं का सामना कर रहे हैं।

यहाँ redux क्रियाओं से प्रतिक्रिया ऐप के माध्यम से नेविगेट करने के लिए एक कार्यशील समाधान है।

History.js

import createHistory from 'history/createBrowserHistory'

export default createHistory()

App.js / Route.jsx

import { Router, Route } from 'react-router-dom'
import history from './history'
...
<Router history={history}>
 <Route path="/test" component={Test}/>
</Router>

अन्य_फाइल.जेएस या रिडक्स फ़ाइल

import history from './history' 

history.push('/test') // this should change the url and re-render Test component

इस टिप्पणी के लिए सभी धन्यवाद: ReactTraining मुद्दों टिप्पणी


4

यदि प्रतिक्रिया-राउटर- रेडक्स के माध्यम से आरआर 4 डब्ल्यू / रिडक्स को पेयर करने के लिए होता है , तो रूटिंग एक्शन क्रिएटर्स का उपयोग react-router-reduxएक विकल्प भी है।

import { push, replace, ... } from 'react-router-redux'

class WrappedComponent extends React.Component {
  handleRedirect(url, replaceState = true) { 
    replaceState 
      ? this.props.dispatch(replace(url)) 
      : this.props.dispatch(push(url)) 
  }
  render() { ... }
}

export default connect(null)(WrappedComponent)

यदि async फ्लो को प्रबंधित करने के लिए redux thunk / saga का उपयोग करते हैं, तो redux क्रियाओं में उपरोक्त एक्शन क्रिएटर्स को आयात करें और mapDispatchToProps का उपयोग करके घटकों पर प्रतिक्रिया करने के लिए हुक बेहतर हो सकता है।


1
react-router-reduxएक लंबे समय के लिए पदावनत / संग्रहित किया गया है
oligofren

4

आप useHistoryहुक का उपयोग एक स्टेटलेस घटक में भी कर सकते हैं । डॉक्स से उदाहरण।

import { useHistory } from "react-router"

function HomeButton() {
  const history = useHistory()

  return (
    <button type="button" onClick={() => history.push("/home")}>
      Go home
    </button>
  )
}

नोट: हुक को react-router@5.1.0आवश्यकता के अनुसार जोड़ा गया थाreact@>=16.8


1
अच्छा कॉल, क्या आप नोट कर सकते हैं कि प्रतिक्रिया-राउटर और प्रतिक्रिया के किस संस्करण को संदर्भित करता है? यह एक नया बदलाव है जो हमेशा उपलब्ध नहीं था
जॉर्ज माउर

3

लेखन के समय मेरे लिए सही उत्तर था

this.context.router.history.push('/');

लेकिन आपको अपने घटक में PropTypes जोड़ने की आवश्यकता है

Header.contextTypes = {
  router: PropTypes.object.isRequired
}
export default Header;

PropTypes आयात करना न भूलें

import PropTypes from 'prop-types';

कृपया प्रतिक्रिया-राउटर के संस्करण को लिखें, और आपने प्रतिक्रिया-राउटर से क्या आयात किया
ऐश

आयात करने के लिए कुछ भी नहीं है और यह "प्रतिक्रिया-राउटर" संस्करण है: "^ 4.2.0"
वेबमास्टर

3

शायद सबसे अच्छा समाधान नहीं है, लेकिन यह काम हो जाता है:

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

// create functional component Post
export default Post = () => (
    <div className="component post">

        <button className="button delete-post" onClick={() => {
            // ... delete post
            // then redirect, without page reload, by triggering a hidden Link
            document.querySelector('.trigger.go-home').click();
        }}>Delete Post</button>

        <Link to="/" className="trigger go-home hidden"></Link>

    </div>
);

मूल रूप से, एक तर्क एक कार्रवाई (इस मामले में एक पोस्ट विलोपन) से जुड़ा हुआ है, पुनर्निर्देशित के लिए एक ट्रिगर को समाप्त करेगा। यह आदर्श नहीं है क्योंकि आप अपने मार्कअप में एक डोम नोड 'ट्रिगर' जोड़ देंगे, ताकि जरूरत पड़ने पर आप आसानी से इसे कॉल कर सकें। इसके अलावा, आप सीधे DOM के साथ बातचीत करेंगे, जो एक रिएक्ट घटक में वांछित नहीं हो सकता है।

फिर भी, इस प्रकार के पुनर्निर्देशन की आवश्यकता नहीं होती है जो अक्सर होती है। इसलिए आपके घटक मार्कअप में एक या दो अतिरिक्त, छिपे हुए लिंक से इतना नुकसान नहीं होगा, खासकर यदि आप उन्हें सार्थक नाम दें।


क्या आप बता सकते हैं कि आप कभी भी स्वीकृत समाधान पर इसका उपयोग क्यों करेंगे?
जॉर्ज मौअर

यह चर्चा की गई समस्या का एक वैकल्पिक समाधान है। जैसा कि पहले ही कहा गया है, आदर्श नहीं है, लेकिन यह प्रोग्रामेटिक रीडायरेक्ट के लिए ठीक काम करता है।
neatsu

2

यह मेरे लिए काम करता है, किसी विशेष आयात की आवश्यकता नहीं है:

<input 
  type="button" 
  name="back" 
  id="back" 
  class="btn btn-primary" 
  value="Back" 
  onClick={() => { this.props.history.goBack() }} 
/>

बेशक इसके लिए विशेष आयात की आवश्यकता है - आपके घटक historyने propsकेवल अपने आप को नहीं जोड़ा है। यह एक HoC से आता है जिसका उपयोग करने के लिए आपको आयात करने की आवश्यकता होगी (सीधे भेजे गए घटकों Routeको स्वचालित रूप से उस HoC द्वारा लपेटा जाता है लेकिन फिर आपको इसके लिए एक आयात की आवश्यकता होती है Route...)
जॉर्ज मौअर

2

इसके बजाय हुकर्र्टर का उपयोग करें, प्रतिक्रिया-राउटर का आधुनिक विकल्प

https://www.npmjs.com/package/hookrouter

import { useRoutes, usePath, A} from "hookrouter";

आप कर सकते हैं चुनिंदा बॉक्स के माध्यम से जोड़ने के बारे में ओपी सवाल का जवाब देने के लिए:

navigate('/about');

FYI करें। लेखक स्वयं इस पुस्तकालय को "अवधारणा का प्रमाण" कहता है और इसकी लगभग एक वर्ष (जून 2019) तक कोई गतिविधि नहीं हुई है।
शाम

@ मेकमार्क ऐसा इसलिए है क्योंकि यह पहले से ही सही है
स्टेफेनबोक

खैर, 38 खुले मुद्दे, इस तथ्य के साथ कि संस्करण 2.0 ऑटेर के अनुसार पूर्ण पुनर्लेखन होगा, अन्यथा कहता है।
MEMark

1

प्रतिक्रिया के लिए रूटर v4 +

यह मानते हुए कि आपको प्रारंभिक रेंडर के दौरान नेविगेट करने की आवश्यकता नहीं होगी (जिसके लिए आप <Redirect>घटक का उपयोग कर सकते हैं ), यह वही है जो हम अपने ऐप में कर रहे हैं।

एक खाली मार्ग को परिभाषित करें जो अशक्त देता है, इससे आपको इतिहास ऑब्जेक्ट तक पहुंच प्राप्त करने की अनुमति मिलेगी। आपको यह शीर्ष स्तर पर करने की आवश्यकता है जहां आपकाRouter परिभाषित किया गया है।

अब आप वे सभी काम कर सकते हैं जो इतिहास पर किए जा सकते हैं history.push(), जैसे history.replace(), history.go(-1)आदि!

import React from 'react';
import { HashRouter, Route } from 'react-router-dom';

let routeHistory = null;

export function navigateTo(path) {
  if(routeHistory !== null) {
    routeHistory.push(path);
  }
}

export default function App(props) {
  return (
    <HashRouter hashType="noslash">
      <Route
        render={({ history }) => {
          routeHistory = history;
          return null;
        }}
      />
      {/* Rest of the App */}
    </HashRouter>
  );
}

1

प्रतिक्रिया-राउटर-डोम: 5.1.2

  • इस साइट में 3 पृष्ठ हैं, जो सभी ब्राउज़र में गतिशील रूप से प्रस्तुत किए जाते हैं।

  • हालाँकि पृष्ठ कभी ताज़ा नहीं होता है, फिर भी नोटिस करें कि साइट के माध्यम से नेविगेट करते समय रिएक्ट राउटर URL को कैसे अद्यतित रखता है। यह ब्राउज़र के इतिहास को सुरक्षित रखता है, जिससे बैक बटन और बुकमार्क जैसी चीजें ठीक से काम करती हैं

  • एक स्विच अपने सभी बच्चों के तत्वों के माध्यम से दिखता है और पहले वाले को प्रस्तुत करता है जिसका पथ वर्तमान URL से मेल खाता है। किसी भी समय आप कई मार्गों का उपयोग करें, लेकिन आप उनमें से केवल एक समय में प्रस्तुत करना चाहते हैं

import React from "react";
import {
  BrowserRouter as Router,
  Switch,
  Route,
  Link
} from "react-router-dom";



export default function BasicExample() {
  return (
    <Router>
      <div>
        <ul>
          <li>
            <Link to="/">Home</Link>
          </li>
          <li>
            <Link to="/about">About</Link>
          </li>
          <li>
            <Link to="/dashboard">Dashboard</Link>
          </li>
        </ul>

        <hr />

        <Switch>
          <Route exact path="/">
            <Home />
          </Route>
          <Route path="/about">
            <About />
          </Route>
          <Route path="/dashboard">
            <Dashboard />
          </Route>
        </Switch>
      </div>
    </Router>
  );
}

// You can think of these components as "pages"
// in your app.

function Home() {
  return (
    <div>
      <h2>Home</h2>
    </div>
  );
}

function About() {
  return (
    <div>
      <h2>About</h2>
    </div>
  );
}

function Dashboard() {
  return (
    <div>
      <h2>Dashboard</h2>
    </div>
  );
}```

एसओ में आपका स्वागत है! जब आप किसी प्रश्न का इतने उत्तर के साथ उत्तर देते हैं, तो आप के लाभों को दिखाने का प्रयास करें।
डेविड गार्सिया बोडेगो

यह भी इस सवाल का जवाब नहीं देता है कि यह कैसे अनिवार्य जेएस से प्रोग्राम किया जाता है, मार्कअप के साथ नहीं।
जॉर्ज मौअर

1

तो मेरे जवाब में एक मार्ग पर प्रोग्रामेटिक रूप से रीडायरेक्ट करने के 3 अलग-अलग तरीके हैं। कुछ समाधान पहले से ही प्रस्तुत किए गए हैं, लेकिन निम्नलिखित लोगों ने केवल एक अतिरिक्त डेमो एप्लिकेशन के साथ कार्यात्मक घटकों के लिए ध्यान केंद्रित किया है ।

निम्नलिखित संस्करणों का उपयोग करना:

प्रतिक्रिया: 16.13.1

प्रतिक्रिया-डोम: 16.13.1

प्रतिक्रिया-राउटर: 5.2.0

प्रतिक्रिया-राउटर-डोम: 5.2.0

टाइपस्क्रिप्ट: 3.7.2

विन्यास:

तो सबसे पहले समाधान का उपयोग कर रहा है HashRouter, निम्नानुसार कॉन्फ़िगर किया गया है:

<HashRouter>
    // ... buttons for redirect

    <Switch>
      <Route exact path="/(|home)" children={Home} />
      <Route exact path="/usehistory" children={UseHistoryResult} />
      <Route exact path="/withrouter" children={WithRouterResult} />
      <Route exact path="/redirectpush" children={RedirectPushResult} />
      <Route children={Home} />
    </Switch>
</HashRouter>

से प्रलेखन के बारे में <HashRouter>:

एक <Router>यूआरएल (यानी की हैश भाग का उपयोग करता है window.location.hash) यूआरएल के साथ सिंक में अपने यूआई रखने के लिए।

समाधान:

  1. का उपयोग <Redirect>कर धक्का का उपयोग कर useState:

एक कार्यात्मक घटक ( RedirectPushActionमेरे भंडार से घटक) का उपयोग useStateकरके हम रीडायरेक्ट को संभालने के लिए उपयोग कर सकते हैं । मुश्किल हिस्सा एक बार पुनर्निर्देशन के बाद हम redirectराज्य वापस सेट करने की जरूरत है false। देरी के setTimeOutसाथ उपयोग करके 0हम तब तक इंतजार कर रहे हैं जब तक कि रिएक्ट शुरू न हो जाएRedirect DOM पर न आ जाए, तब अगली बार उपयोग करने के लिए बटन वापस लेना।

कृपया मेरा उदाहरण नीचे देखें:

const [redirect, setRedirect] = useState(false);
const handleRedirect = useCallback(() => {
    let render = null;
    if (redirect) {
        render = <Redirect to="/redirectpush" push={true} />

        // in order wait until commiting to the DOM
        // and get back the button for clicking next time
        setTimeout(() => setRedirect(false), 0);
    }
    return render;
}, [redirect]);

return <>
    {handleRedirect()}
    <button onClick={() => setRedirect(true)}>
        Redirect push
    </button>
</>

से <Redirect>प्रलेखन:

रेंडरिंग एक <Redirect>नए स्थान पर नेविगेट करेगा। नया स्थान इतिहास स्टैक में वर्तमान स्थान को ओवरराइड करेगा, जैसे सर्वर-साइड रीडायरेक्ट (HTTP 3xx) करते हैं।

  1. useHistoryहुक का उपयोग करना :

मेरे समाधान में एक घटक है जिसे UseHistoryActionनिम्नलिखित कहा जाता है :

let history = useHistory();

return <button onClick={() => { history.push('/usehistory') }}>
    useHistory redirect
</button>

useHistoryहुक हमें इतिहास वस्तु जो हमें प्रोग्राम के रूप में नेविगेट या बदलने के मार्गों में मदद करता है करने के लिए पहुँच देता है।

  1. का उपयोग करते हुए withRouter, मिल historyसे props:

नामक एक घटक बनाया WithRouterAction, नीचे प्रदर्शित करता है:

const WithRouterAction = (props:any) => {
    const { history } = props;

    return <button onClick={() => { history.push('/withrouter') }}>
        withRouter redirect
    </button>
}

export default withRouter(WithRouterAction);

withRouterप्रलेखन से पढ़ना :

आप historyऑब्जेक्ट के गुणों और उच्च-क्रम घटक के <Route>माध्यम से निकटतम मिलान तक पहुंच प्राप्त कर सकते हैं withRouterwithRouterअद्यतन होगा पारित match, locationऔर historyलिपटे घटक को रंगमंच की सामग्री जब भी यह बना देता है।

डेमो:

बेहतर प्रतिनिधित्व के लिए मैंने इन उदाहरणों के साथ GitHub रिपॉजिटरी का निर्माण किया है, कृपया इसे नीचे देखें:

https://github.com/norbitrial/react-router-programmatically-redirect-examples

आशा है कि ये आपकी मदद करेगा!

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.