ප්‍රතික්‍රියා රවුටරය භාවිතයෙන් ක්‍රමලේඛනය කරන්න


1488

සමග react-routerමම භාවිතා කළ හැකිය Linknatively රවුටරය ප්රතික්රියා විසින් සිදු කරන ලද සබැඳි නිර්මාණය කිරීමට අංගයක්.

මම එය අභ්‍යන්තරව දකිනවා this.context.transitionTo(...).

මට සංචාලනයක් කිරීමට අවශ්‍යයි. සබැඳියකින් නොව, පතන තේරීමකින් (උදාහරණයක් ලෙස). කේතයෙන් මෙය කරන්නේ කෙසේද? කුමක්ද this.context?

මම Navigationමික්සින් දුටුවෙමි , නමුත් මට මෙය නොමැතිව කළ mixinsහැකිද?


26
Question සර්ජියෝ ටැපියා මතක තබා ගන්න මෙම ප්‍රශ්නය ප්‍රතික්‍රියා-රවුටරයේ විශාල නිකුතුවක්, ප්‍රධාන ප්‍රතික්‍රියා නිකුතුවක් සහ ප්‍රධාන ජාවාස්ක්‍රිප්ට් එකක්
ජෝර්ජ් මවර්

5
ප්‍රතික්‍රියා රවුටරයේ නිල ලේඛනයේ
chitzui

4
ඔබ මෙම පිළිතුර පරීක්ෂා කළ හැකි stackoverflow.com/questions/44127739/...
Shubham Khatri

4
ඔබට මෙම පිළිතුර ලැබීම ගැන මට සතුටුයි, නමුත් මට කණගාටුයි එය මෙය සංකීර්ණ වීම. වෙබ් යෙදුමක් තුළ සැරිසැරීම පහසු සහ හොඳින් ලේඛනගත කළ යුතුය. VueJS එය සුළුපටු කරයි. සෑම සංරචකයක්ම ස්වයංක්‍රීයව රවුටරයේ අවස්ථාව ලබා ගනී. ඔවුන්ගේ ලේඛනයේ ඒ සඳහා පැහැදිලිව අර්ථ දක්වා ඇති කොටසක් තිබේ. router.vuejs.org/guide/essentials/navigation.html මම බොහෝ දේ සඳහා ප්‍රතික්‍රියා කිරීමට කැමතියි, නමුත් සමහර විට එය ඕනෑවට වඩා සංකීර්ණ වේ. </
rant

7
E ජෝර්ජ්මවර් ඔබ හරි. මෙම ප්‍රජාව ගැන එය නොවේ. එය ප්‍රශ්න වලට පිළිතුරු සැපයීම මිස රාමු ගැන විහිළු කිරීම නොවේ. මතක් කිරීමට ස්තූතියි.
colefner

Answers:


1522

රවුටරය 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. සංයුතිය භාවිතා කර විදැහුම්කරණය a <Route>
  3. භාවිතා කරන්න context.

ප්‍රතික්‍රියා රවුටරය බොහෝ දුරට historyපුස්තකාලය වටා එතීමකි . බ්‍රව්සරයේ බ්‍රව්සරය සහ හැෂ් ඉතිහාසය historyසමඟ අන්තර්ක්‍රියාකාරිත්වය හසුරුවයි window.history. ගෝලීය ඉතිහාසයක් නොමැති පරිසරයන් සඳහා ප්‍රයෝජනවත් වන මතක ඉතිහාසයක් ද එය සපයයි. ජංගම යෙදුම් සංවර්ධනය ( react-native) සහ නෝඩ් සමඟ ඒකක පරීක්ෂණ සඳහා මෙය විශේෂයෙන් ප්‍රයෝජනවත් වේ .

historyඅවස්ථාවේ සංචලනය සඳහා ක්රම දෙකක් ඇත: pushහා replace. ඔබ historyසංචාරය කළ ස්ථාන සමූහයක් ලෙස සිතන්නේ නම්, අරාව වෙත pushනව ස්ථානයක් එක් කරන අතර අරාවෙහි replaceවත්මන් ස්ථානය නව ස්ථානය සමඟ ප්‍රතිස්ථාපනය කරයි. සාමාන්‍යයෙන් ඔබ pushසැරිසැරීමේදී මෙම ක්‍රමය භාවිතා කිරීමට අවශ්‍ය වනු ඇත .

Router ක්රියාත්මක වෙන්න පෙර වෙළුම් සඳහා, ඔබ ඔබේ ම නිර්මාණය කිරීමට ඇති 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. සංයුතිය භාවිතා කර විදැහුම්කරණය a <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. සන්දර්භය භාවිතා කරන්න *

නමුත් ඔබ බොහෝ විට එසේ නොකළ යුතුය

අවසාන විකල්පය වන්නේ ඔබ භාවිතා කළ යුත්තේ ප්‍රතික්‍රියා සන්දර්භය ආකෘතිය සමඟ වැඩ කිරීමට ඔබට පහසුවක් නම් පමණි (ප්‍රතික්‍රියා සන්දර්භය API 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 ක්‍රියාත්මක කිරීම සඳහා සරලම තේරීම් වේ, එබැවින් බොහෝ භාවිත අවස්ථා සඳහා ඒවා ඔබේ හොඳම ඔට්ටු වේ.


25
රවුටර් (({ඉතිහාසය}) => {console.log ("hhhhhhh"); history.push ('/ bets')}) සමඟ මම මේ ආකාරයෙන් 1 ක්‍රමය භාවිතා කිරීමට උත්සාහ කළෙමි; නමුත් එය කිසි විටෙකත් රවුටරය 4 සමඟ වැඩ කළේ නැත
දිමිත්‍රි මාලුගින්

60
මොනවාද!? මගේ සියලු සංරචක withRouterපසුකර historyයාම වෙනුවට මට භාවිතා කළ හැකිද ?? මට ඩොක්ස් කියවීමට වැඩි කාලයක් ගත කිරීමට අවශ්‍යයි ...
hellojeffhall

18
history.push('/new-location')එම හැසිරීම බොත්තමක් හෝ වෙනත් DOM මූලද්‍රව්‍යයකට සම්බන්ධ නොකර ඔබට ධාවනය කළ හැක්කේ කෙසේද ?
නීල්

4
විසි කිරීමේ දෝෂය ලෙසUnexpected use of 'history' no-restricted-globals
පර්දීප් ජේන්

18
contextප්‍රතික්‍රියා 16 වන විට තවදුරටත් පර්යේෂණාත්මක නොවේ.
trysis

934

ප්‍රතික්‍රියා-රවුටරය 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
};

සටහන: ඔබේ සංරචකය විදැහුම් නොකළ අවස්ථාවකදී this.props.history නොපවතී <Route>. <Route path="..." component={YourComponent}/>YourComponent හි this.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 පිළිතුර

මම එකම ගැටලුවකට පැටලී ඇති අතර විසඳුම සොයා ගත හැකි වූයේ ප්‍රතික්‍රියා-රවුටරය සමඟ එන Navigation mixin සමඟ පමණි.

මෙන්න මම එය කළ ආකාරය

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
};

ප්‍රතික්‍රියා-රවුටරය-රෙඩක්ස්

සටහන: ඔයා තමයි රංගනයක් භාවිතා කරන්නේ නම්, නමින් තවත් ව්යාපෘතියක් ඇති ReactRouter-රංගනයක් ඔබ ReactRouter සඳහා සබඳතා රංගනයක් ලබා දෙන බව, තරමක් එම ක්රමය යොදා බව ප්රතිචාර දක්වයි-රංගනයක් බවක්

React-Router-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මෙන්න මගේ SO පෝස්ටයට සබැඳිය: stackoverflow.com/questions/37306166/…
nburk

7
මෙය පිළිගත් පිළිතුර විය යුතුය, පිළිගත් තැනැත්තා ටිකක් අවුල් සහගත වන අතර එය ඉතා පැරණි ය. IantGiantElk අනුවාදය සඳහා පිළිතුරෙහි විස්තර කර ඇති පරිදි මම එය ක්‍රියාත්මක කරමි 2.6.0.
ජේමැක්

2
මෙම ප්‍රවේශය තවමත් අනුවාදය සඳහා නිර්දේශිත ක්‍රමයද 3.0.x? බොහෝ අය contextමාර්ගය භාවිතා කරන බව පෙනේ .
velop

6
4.0 හි, this.props.history නොපවතී. මොනවද වෙන්නේ?
නිකොලස් එස්. Xu

4
this.props.historyComponent ඔබේ සංරචකය විදහා නොදැක්වූ අවස්ථාවකදී නිකොලාස් එස්.ක්සු නොපවතී <Route>. ඇතුළට <Route path="..." component={YourComponent}/>යාමට ඔබ භාවිතා කළ යුතුය . this.props.historyYourComponent
vogdb

511

ප්‍රතික්‍රියා-රවුටරය v2

නවතම නිකුතුව සඳහා ( v2.0.0-rc5), නිර්දේශිත සංචාලන ක්‍රමය වන්නේ ඉතිහාස ඒකකය වෙත කෙලින්ම තල්ලු කිරීමයි. සංරචක ලේඛනයෙන් පිටත සැරිසැරීමේදී ඔබට එය දැක ගත හැකිය .

අදාළ උපුටා ගැනීම:

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

නවතම ප්‍රතික්‍රියා-රවුටරය API භාවිතා කරන්නේ නම් , සංරචක ඇතුළත 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
නවතම API භාවිතා නොකරන 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යූආර්එල් පමණක් වෙනස් කරයි, ඇත්ත වශයෙන්ම පිටුව වෙනස් නොකරයි. දෙකම කිරීමට, ආනයනය browserHistoryකර react-routerභාවිතා කරන්න browserHistory.push('/my-cool-path'). අවාසනාවට, මෙය සොයා ගැනීම පහසු නැත. github.com/reactjs/react-router/blob/master/docs/guides/…
සැමුවෙල්සන්

4
මම භාවිතා කරන්නේ this.props.history.push ('/') නමුත් URL එක පමණක් වෙනස් වේ ... මෙහි සත්‍ය මාර්ගගත කිරීමක් සිදු නොවේ. මට නැති වී ඇත්තේ කුමක්ද?
rgcalsaverini


57

මෙන්න ඔබ ES6react-router v2.0.0 සමඟ මෙය කරන ආකාරය . react-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
EGeorgeMauer මම හිතන්නේ එය කේතය ක්‍රියාත්මක වන ස්ථානය මත රඳා පවතී. ප්‍රතික්‍රියා ලේඛනයට අනුව, context.router භාවිතය සේවාදායකයේ ක්‍රියාත්මක වන්නේ නම් එය නිර්දේශ කෙරේ. github.com/reactjs/react-router/blob/master/upgrade-guides/…
කුමාර් එම්

52

ප්‍රතික්‍රියා-රවුටරය 4.x පිළිතුර:

මගේ කෙළවරේ, බාහිර කොටස් පවා රැගෙන යා හැකි තනි ඉතිහාස වස්තුවක් තිබීමට මම කැමතියි. මා කිරීමට කැමති දෙය නම් ඉල්ලුමට අනුව මා ආනයනය කරන තනි history.js ගොනුවක් තිබීම සහ එය හසුරුවන්න.

ඔබ කළ 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>;
    }
}

සංස්කරණය කරන්න 2018 අප්‍රේල් 16:

ඔබට සැබවින්ම සං Routecomponent ටකයකින් විදහා දක්වන ලද සංරචකයකින් සැරිසැරීමට සිදුවුවහොත් , ඔබට මුක්කු වලින් ඉතිහාසයට පිවිසිය හැකිය, ඒ වගේ:

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. ඔබ [ "රංගනයක් වැනි රාජ්ය කළමනාකරණ මෙවලම් සමග අවශ්යතාව ගැඹුරු ඒකාබද්ධ."] ඔබ පමණක් නම්, ඔබේ ම නිර්මාණය කිරීමට පැහැර නොකළ යුතුය reacttraining.com/react-router/web/api/Router
bobbyz

2
එය මම කාලය හා අත්දැකීම් වලින් ඉගෙන ගත් දෙයක්. සාමාන්‍යයෙන් පෙරනිමිය භාවිතා කිරීම හොඳ පුරුද්දක් වන this.props.historyඅතර, ප්‍රතික්‍රියාකාරක අංගයක් ලෙස ගොඩනගා නැති සංරචකයක් හෝ වෙනත් මෙවලමක් නොවන පන්තියක එවැනි දෙයක් කිරීමට මට උපකාර කළ හැකි විසඳුමක් තවම මට හමු වී නැත. ඔබට මුක්කු පසු කළ හැකිය. ඔබගේ ප්‍රතිපෝෂණයට ස්තූතියි :)
එරික් මාටින්

45

මේ සඳහා, සේවාදායක පැත්ත පාලනය නොකරන සහ මේ නිසා හැෂ් රවුටරය 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 තුළ ඔබට අතිරේක මොඩියුලය "ඉතිහාසය" ස්ථාපනය කළ යුතුය (ඔබට අමුතු හැෂ් විමසුම් වළක්වා ගැනීමට අවශ්‍ය නම්), සහ බ්‍රව්සර් ඉතිහාසය භාවිතා කිරීම වෙනුවට ඔබ භාවිතා කළ යුතුය රවුටර් හිස්ටරි (createHashHistory) ( ery queryKey: අසත්‍ය}). මා මෙය පළ කිරීමට ප්‍රධාන හේතුව මෙයයි. හැෂ් ඉතිහාසය සමඟ සැරිසැරීමට මම පෙන්වා දුන්නෙමි.
ඇලෙක්සි වොලොඩ්කෝ

1
ඔහ්, මට පේනවා, ඔයා හරි. මම තවදුරටත් එම ව්‍යාපෘතියේ නොසිටින නමුත් මම සිතන්නේ වඩාත් සුදුසු ක්‍රමය historyදැන් ඕනෑම ප්‍රවේශයක් සඳහා භාවිතා කිරීමයි
ජෝර්ජ් මවර්

4
මෙම පිළිතුර හොඳම නොවන්නේ ඇයි? සන්දර්භය හෝ එච්ඕසී හෝ සිදුවීම් මූලාකෘති සමඟ සියලු කරදර වලට මුහුණ දෙන්නේ ඇයි, ඉතිහාසය ආනයනය කර අප කැමති තැනක භාවිතා නොකරන්නේ ඇයි? වෙළඳාම තේරුම් ගැනීමට උත්සාහ කිරීම
කුණාටු_බස්ටර්

ormstorm_buster වෙළඳාමක් නොමැත. අපට ES6 මොඩියුල ඇති අතර ඒවා භාවිතා කළ යුතුය! මෙය සෑම දෙයක්ම සඳහා ඔබේ මෙවලම භාවිතා කිරීමේ සාමාන්‍ය ප්‍රදර්ශනයකි (මේ අවස්ථාවේ දී ප්‍රතික්‍රියා කරන්න) - ඔබට ඒවා සැබවින්ම භාවිතා කිරීමට අවශ්‍ය නැති දේවල් සඳහා පවා.
කපජ්

40

රවුටරය V4 ප්‍රතික්‍රියා කරන්න

tl: dr;

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

සරල හා ප්‍රකාශන පිළිතුර නම් ඔබ <Redirect to={URL} push={boolean} />සමඟ ඒකාබද්ධව භාවිතා කළ යුතු බවයිsetState()

push: boolean - සත්‍ය වූ විට, යළි හරවා යැවීම වත්මන් එක ප්‍රතිස්ථාපනය කරනවා වෙනුවට ඉතිහාසයට නව ප්‍රවේශයක් තල්ලු කරයි.


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()වෙනත් ස්ථානයක සිට.
කර්මකේස්

ඉතා, ඉතා දක්ෂයි. එහෙත් ඉතා සරල ය. Tks. ReactRouterTable තුළ මම එය භාවිතා කළේ මුළු පේළියේම ක්ලික් කිරීම හැසිරවීමට අවශ්‍ය නිසාය. තත්වය සැකසීමට onRowClick හි භාවිතා වේ. setState ({navigationTo: "/ path /" + row.uuid});
ලොවාටෝ

මෙය වෙඩි නොවදින පිළිතුරකි.
නිටින් ජාදව්

31

අවවාදයයි: මෙම පිළිතුර ආවරණය කරන්නේ 1.0 ට පෙර ReactRouter අනුවාදයන් පමණි

මම මෙම පිළිතුර 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 ක් වත් උත්සාහ කළෙමි!

El ෆෙලිප් ස්කිනර්ගේ withRouterපිළිතුර මට තරමක් අධික වූ අතර මට නව "අපනයන විත් රූටර් " පන්ති නම් සෑදීමට අවශ්‍ය බව මට විශ්වාස නැත.

එය කළ හැකි සරලම හා පිරිසිදුම ක්‍රමය මෙන්න, සර්කා ධාරා ප්‍රතික්‍රියා-රවුටරය 3.0.0 සහ ඊඑස් 6:

ES6 සමඟ ප්‍රතික්‍රියා-රවුටරය 3.xx:

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 හි, සං component ටකයම <Link>භාවිතා කරන බව සලකන්න router.push, එවිට ඔබට <Link to=ටැගය පසු කරන ඕනෑම දෙයක් සම්මත කළ හැකිය , වැනි:

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

1
එය මුළුමනින්ම හොඳින් ක්‍රියාත්මක වේ. නමුත් කේතය 200 OKවෙනුවට ප්‍රතිචාර දක්වයි 30x. මෙම ගැටළුව විසඳන්නේ කෙසේද?
මුහම්මද් ආටෙක් අසාම්

1
හරියටම සහතික නෑ. මෙය කිසි විටෙකත් මා වෙත නොපැමිණියේ එය බාහිර ඉල්ලීමක් නොවන නිසාය - එය ඔබගේ බ්‍රව්සරය මඟින් පිටුවේ ඇති කේතය භාවිතා කර පිටුවේ ඇති දේ වෙනස් කිරීමට භාවිතා කරයි. ඔබ කැමති නම් ඔබට සෑම විටම අතින් ජාවාස්ක්‍රිප්ට් යළි-යොමුවීමක් කළ හැකිය.
බෙන් වීලර්

1
එය classwithRouter සමඟ පන්ති සැරසිලි කරුවෙකු ලෙසද භාවිතා කළ හැකිය ... mobx සමඟ විශිෂ්ටයි
Dan

21

Programmatically නාවික කරන්න, ඔබ නව තල්ලු කිරීමට අවශ්ය ඉතිහාසය වෙත 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"

ප්‍රතික්‍රියා-රවුටරය භාවිතයෙන් මම ක්‍රමලේඛන සංචලනය භාවිතා කළ මගේ ප්‍රතික්‍රියා සං component ටකය පහත දැක්වේ:

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
ඔබ රවුටරය සහ බ්‍රව්සර් ඉතිහාසය සමඟ භාවිතා නොකරන්නේ ඇයි?
අර්වින් මේයර්

1
R අර්වින් ඒපීඅයි v4 හි වෙනස් වේ. මෙම github.com/ReactTraining/react-router/issues/3847 බලන්න .
mcku

1
ප්‍රතික්‍රියා-රවුටරය v4 සඳහා ඔබේ යතුරු ලියන ගොනුව කොහෙන්ද?
jmathew

1
matjmathew මට ප්‍රතික්‍රියා-රවුටරය සඳහා කිසිදු ආකාරයක අර්ථ දැක්වීමක් නොමැත v4
mcku

16

දී ක්රියාත්මක වෙන්න-Router 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>
        )
    }
}

අද ස්ථාපනය කර ඇති ඕනෑම දෙයක් සමඟ. "ප්‍රතික්‍රියා-රවුටරය": "^ 3.0.0" සහ
"@ වර්ග / ප්‍රතික්‍රියා-රවුටරය": "^ 2.0.41"


11

React-Router 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")

අංක දෙක

ඉතිහාස තොගයේ වත්මන් ප්‍රවේශය ප්‍රතිස්ථාපනය කරයි

මුක්කු වල ඉතිහාසය ලබා ගැනීම සඳහා ඔබේ සංරචකය ආවරණය කළ යුතුය

රවුටරය සමඟ


ස්තූතියි !! හොඳම පිළිතුර
ටහා ෆාරුකි

9

ඔබ හැෂ් හෝ බ්‍රව්සර් ඉතිහාසය භාවිතා කරන්නේ නම් ඔබට එය කළ හැකිය

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

2
hashHistory.push, නිර්වචනය නොකළ දේපල "තල්ලු" කියවිය නොහැක. ඔබ මේවා ආනයනය කරන්නේ කොතැනින්ද?
ArchNoob

"ප්‍රතික්‍රියා-රවුටරය" වෙතින් {hashHistory import ආයාත කරන්න; ඔබට එය ඉහළින් ආයාත කළ හැකිය.
සමන් අෆ්සාල්

මම ඔබේ කේත නියැදිය මගේ රීඩක්ස් සාගා ගොනුවෙන් භාවිතා කරමි, ඔබ කියූ ආකාරයටම ආනයනය කර එය භාවිතා කරන නමුත් මම දිගටම එම TypeError ලබා ගනිමි.
ArchNoob

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 සඳහා වැඩ කරයි. හොඳයි ... වසන්න ... එය ඇත්ත වශයෙන්ම මෙය විය යුතුය this.context.router.history.push ('/ back-location');
வேலහෝම්

7

ප්‍රතික්‍රියා-රවුටරය V4

ඔබ 4 වන අනුවාදය භාවිතා කරන්නේ නම්, ඔබට මගේ පුස්තකාලය (ලැජ්ජා විරහිත ප්ලග්) භාවිතා කළ හැකිය, එහිදී ඔබ ක්‍රියාවක් යවන අතර සියල්ල ක්‍රියාත්මක වේ!

dispatch(navigateTo("/aboutUs"));

ට්‍රිප්ලර්


5

ප්‍රතික්‍රියා-රවුටරය v4 මත මෙය ක්‍රියාත්මක කිරීමේදී ගැටළු වලට මුහුණ දෙන අය.

ප්‍රතිගාමී යෙදුම හරහා ප්‍රතික්‍රියා යෙදුම හරහා සැරිසැරීම සඳහා ක්‍රියාකාරී විසඳුමක් මෙන්න.

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>

another_file.js හෝ රීඩක්ස් ගොනුව

import history from './history' 

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

මෙම අදහස් දැක්වීමට ස්තූතියි: ReactTraining ගැටළු අදහස්


4

ප්‍රතික්‍රියා-රවුටරය- ප්‍රතිජනනය හරහා RR4 w / redux යුගලනය කිරීමට සිදුවුවහොත් , රවුටින් ක්‍රියාකාරී නිර්මාණකරුවන් භාවිතා 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)

අසින්ක් ප්‍රවාහය කළමනාකරණය කිරීම සඳහා රෙඩක්ස් තන්ක් / සාගා භාවිතා කරන්නේ නම්, ඉහත ක්‍රියාකාරී නිර්මාණකරුවන් ප්‍රතිනිර්මාණය කිරීමේ ක්‍රියාවලීන්ගෙන් ආනයනය කර සිතියම් ඩිස්පැච්ටෝප්‍රොප්ස් භාවිතයෙන් සංරචක ප්‍රතික්‍රියා කිරීමට කොකු කිරීම වඩා හොඳ විය හැකිය.


1
react-router-redux
දීර් re

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';

කරුණාකර ප්‍රතික්‍රියා-රවුටරයේ අනුවාදය ලියන්න, ඔබ ප්‍රතික්‍රියා-රවුටරයෙන් ආනයනය කළේ කුමක්ද
Ash

ආනයනය කිරීමට කිසිවක් නොමැති අතර මෙය "ප්‍රතික්‍රියා-රවුටරය": "^ 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 නෝඩ් 'ප්‍රේරකයක්' එක් කරන බැවින් ඔබට අවශ්‍ය විටෙක එය පහසුවෙන් ඇමතිය හැකිය. එසේම, ඔබ ප්‍රතික්‍රියාකාරක අංගයක් තුළ අපේක්ෂා නොකළ හැකි DOM සමඟ කෙලින්ම මැදිහත් වනු ඇත.

තවමත්, මෙම ආකාරයේ යළි-යොමුවීම් බොහෝ විට අවශ්‍ය නොවේ. එබැවින් ඔබේ සංරචක සලකුණු කර ඇති අමතර, සැඟවුණු සබැඳි එකක් හෝ දෙකක් එතරම් හානියක් නොවනු ඇත, විශේෂයෙන් ඔබ ඔවුන්ට අර්ථවත් නම් ලබා දෙන්නේ නම්.


පිළිගත් විසඳුමට වඩා ඔබ මෙය භාවිතා කරන්නේ මන්දැයි ඔබට පැහැදිලි කළ හැකිද?
ජෝර්ජ් මවර්

එය සාකච්ඡා කළ ගැටලුවට විකල්ප විසඳුමක් පමණි. දැනටමත් සඳහන් කර ඇති පරිදි, පරමාදර්ශී නොවන නමුත් ක්‍රමලේඛන යළි-යොමුවීම් සඳහා එය හොඳින් ක්‍රියාත්මක වේ.
neatsu

2

මෙය මට ප්‍රයෝජනවත් විය, විශේෂ ආනයන අවශ්‍ය නොවේ:

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

ඇත්ත වශයෙන්ම මේ සඳහා විශේෂ ආනයන අවශ්‍ය වේ - ඔබේ සංරචකය තනිවම historyඑකතු propsවී නොමැත. එය පැමිණෙන්නේ ඔබට භාවිතා කිරීම සඳහා ආනයනය කිරීමට අවශ්‍ය වන (සෘජුවම යවන ලද සංරචක Routeස්වයංක්‍රීයව එම එච්.සී. විසින් ඔතා ඇති නමුත් ඔබට ඒ සඳහා ආනයනයක් අවශ්‍ය වේ Route...)
ජෝර්ජ් මවර්

2

ප්‍රතික්‍රියා-රවුටරය සඳහා නවීන විකල්පය වෙනුවට හූක්‍රූටර් භාවිතා කරන්න

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

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

තෝරාගත් කොටුව හරහා සම්බන්ධ වීම පිළිබඳ OP ප්‍රශ්නයට පිළිතුරු දීමට ඔබට එය කළ හැකිය:

navigate('/about');

FYI. කතුවරයා විසින්ම මෙම පුස්තකාලය "සංකල්පයේ සාක්ෂියක්" ලෙස හඳුන්වන අතර එයට වසරකට ආසන්න කාලයක් (2019 ජුනි) කිසිදු ක්‍රියාකාරකමක් නොමැත.
MEMark

හොඳයි, විවෘත නිකුතුව 38 සහ 2.0 අනුවාදය සත්‍යය අනුව සම්පූර්ණ නැවත ලිවීමක් වනු ඇති බව වෙනත් ආකාරයකින් පවසයි.
MEMark

2

යාවත්කාලීන කිරීම: රවුටරය v6 කොකු සමඟ ප්‍රතික්‍රියා කරන්න

import {useNavigate} from 'react-router-dom';
let navigate = useNavigate();
navigate('home');

බ්‍රව්සර් ඉතිහාසය හරහා ගමන් කිරීමට,

navigate(-1); ---> Go back
navigate(1);  ---> Go forward
navigate(-2); ---> Move two steps backward.

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>
  );
}```

SO වෙත සාදරයෙන් පිළිගනිමු! ඔබ බොහෝ පිළිතුරු සහිත ප්‍රශ්නයකට පිළිතුරු දෙන විට, ඔබේ ප්‍රතිලාභ පෙන්වීමට උත්සාහ කරන්න.
ඩේවිඩ් ගාර්ෂියා බොඩෙගෝ

මෙය සලකුණු කිරීමකින් නොව අත්‍යවශ්‍ය js වෙතින් ක්‍රමලේඛිකව කරන්නේ කෙසේද යන ප්‍රශ්නයටද පිළිතුරු සපයන්නේ නැත.
ජෝර්ජ් මවර්
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.