Navigazione programmatica utilizzando il router di reazione V4


336

Ho appena sostituito react-routerda V3 a V4.
Ma non sono sicuro di come navigare programmaticamente nella funzione membro di a Component. cioè in handleClick()funzione voglio navigare /path/some/wheredopo aver elaborato alcuni dati. Prima lo facevo:

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

Ma non riesco a trovare tali interfacce in v4.
Come posso navigare usando la v4?


3
Puoi accedere all'oggetto history in v4 tramite props: this.props.history.push ('/')
colemerrick,

6
Cosa succede se si desidera accedervi da un luogo diverso da un Component? Ad esempio, all'interno delle azioni di redux.
Massimo S

73
a volte mi chiedo perché sia ​​così complicato passare da un collegamento all'altro =))
Thai Tran

12
Si potrebbe pensare che al giorno d'oggi il reindirizzamento non sarebbe così complicato.
John Allen,

Risposte:


414

Se scegli come target gli ambienti browser, devi utilizzare il react-router-dompacchetto anziché react-router. Stanno seguendo lo stesso approccio di React, al fine di separare core, ( react) e il codice specifico della piattaforma, ( react-dom, react-native) con la sottile differenza che non è necessario installare due pacchetti separati, quindi i pacchetti di ambiente contengono tutto hai bisogno. Puoi aggiungerlo al tuo progetto come:

yarn add react-router-dom

o

npm i react-router-dom

La prima cosa che devi fare è fornire a <BrowserRouter>come componente principale principale nella tua applicazione. <BrowserRouter>usa l' historyAPI HTML5 e la gestisce per te, quindi non devi preoccuparti di crearne un'istanza e passarla al <BrowserRouter>componente come prop (come dovevi fare nelle versioni precedenti).

In V4, per navigare a livello di codice è necessario accedere historyall'oggetto, che è disponibile tramite React context, purché si disponga di un componente <BrowserRouter> provider come il principale principale nella propria applicazione. La libreria espone attraverso il contesto l' routeroggetto che esso stesso contiene historycome proprietà. L' historyinterfaccia offre diversi metodi di navigazione, come push, replacee goBack, tra gli altri. Puoi controllare l'intero elenco di proprietà e metodi qui .

Nota importante per gli utenti Redux / Mobx

Se si utilizza redux o mobx come libreria di gestione dello stato nella propria applicazione, è possibile che si siano verificati problemi con componenti che dovrebbero essere in grado di riconoscere la posizione ma non essere nuovamente riprodotti dopo aver attivato un aggiornamento URL

Ciò accade perché react-routerpassa locationai componenti utilizzando il modello di contesto.

Sia la connessione che l'osservatore creano componenti i cui metodi shouldComponentUpdate fanno un confronto superficiale tra i loro oggetti di scena attuali e quelli successivi. Quei componenti verranno ri-renderizzati solo quando almeno un puntello è cambiato. Ciò significa che, al fine di garantire che si aggiornino quando la posizione cambia, sarà necessario disporre di un sostegno che cambi quando la posizione cambia.

I 2 approcci per risolvere questo sono:

  • Avvolgi il tuo componente collegato in un percorso <Route />. L' locationoggetto corrente è uno degli oggetti di scena che a <Route>passa al componente che rende
  • Avvolgi il tuo componente collegato con il withRoutercomponente di ordine superiore, che in effetti ha lo stesso effetto e inietta locationcome un oggetto di scena

A parte questo, ci sono quattro modi per navigare programmaticamente, ordinati per raccomandazione:

1.- Utilizzo di un <Route>componente

Promuove uno stile dichiarativo. Prima della v4, i <Route />componenti erano collocati nella parte superiore della gerarchia dei componenti, pensando prima alla struttura dei percorsi. Tuttavia, ora puoi avere <Route>componenti ovunque nell'albero, che ti consentono di avere un controllo più preciso per il rendering condizionale a seconda dell'URL. Routeinietta match, locatione historycome oggetti di scena nel tuo componente. I metodi di navigazione (come ad esempio push, replace, goBack...) sono disponibili come proprietà historydell'oggetto.

Ci sono 3 modi per rendere qualcosa con una Route, utilizzando uno component, rendero di childrenoggetti di scena, ma non usare più di uno nello stesso Route. La scelta dipende dal caso d'uso, ma fondamentalmente le prime due opzioni renderanno il tuo componente solo se pathcorrisponde alla posizione dell'URL, mentre conchildren dell'URL il componente verrà visualizzato se il percorso corrisponde alla posizione o meno (utile per regolare l'interfaccia utente in base all'URL corrispondenza).

Se si desidera personalizzare l'output di rendering del componente , è necessario avvolgere il componente in una funzione e utilizzare l' renderopzione per passare al componente eventuali altri oggetti di scena che desideri, a parte match, locatione history. Un esempio per illustrare:

import { BrowserRouter as Router } from 'react-router-dom'

const ButtonToNavigate = ({ title, history }) => (
  <button
    type="button"
    onClick={() => history.push('/my-new-location')}
  >
    {title}
  </button>
);

const SomeComponent = () => (
  <Route path="/" render={(props) => <ButtonToNavigate {...props} title="Navigate elsewhere" />} />
)    

const App = () => (
  <Router>
    <SomeComponent /> // Notice how in v4 we can have any other component interleaved
    <AnotherComponent />
  </Router>
);

2.- Utilizzo di withRouterHoC

Questo componente di ordine superiore inietterà gli stessi oggetti di scena di Route. Tuttavia, comporta la limitazione che è possibile avere solo 1 HoC per file.

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

const ButtonToNavigate = ({ history }) => (
  <button
    type="button"
    onClick={() => history.push('/my-new-location')}
  >
    Navigate
  </button>
);


ButtonToNavigate.propTypes = {
  history: React.PropTypes.shape({
    push: React.PropTypes.func.isRequired,
  }),
};

export default withRouter(ButtonToNavigate);

3.- Utilizzo di un Redirectcomponente

Il rendering a <Redirect>consente di spostarsi in una nuova posizione. Tuttavia, tieni presente che, per impostazione predefinita , la posizione corrente viene sostituita da quella nuova, come i reindirizzamenti lato server (HTTP 3xx). La nuova posizione è fornita da toprop, che può essere una stringa (URL a cui reindirizzare) o un locationoggetto. Se invece vuoi inserire una nuova voce nella cronologia , passa anche un oggetto di pushscena e impostalo sutrue

<Redirect to="/your-new-location" push />

4.- Accesso routermanuale attraverso il contesto

Un po 'scoraggiato perché il contesto è ancora un'API sperimentale ed è probabile che si rompa / cambi nelle versioni future di React

const ButtonToNavigate = (props, context) => (
  <button
    type="button"
    onClick={() => context.router.history.push('/my-new-location')}
  >
    Navigate to a new location
  </button>
);

ButtonToNavigate.contextTypes = {
  router: React.PropTypes.shape({
    history: React.PropTypes.object.isRequired,
  }),
};

Inutile dire che ci sono anche altri componenti del router che sono pensati per gli ecosistemi non browser, come quello <NativeRouter>che replica uno stack di navigazione in memoria e targetizza la piattaforma React Native, disponibile attraverso il react-router-nativepacchetto.

Per ogni ulteriore riferimento, non esitate a dare un'occhiata ai documenti ufficiali . C'è anche un video realizzato da uno dei coautori della libreria che fornisce un'introduzione piuttosto interessante al reagente-router v4, evidenziando alcuni dei principali cambiamenti.


2
Sto usando V4 e quanto sopra funziona bene. Ho trascorso un bel po 'di tempo a scherzare con il router V4 in quanto sembra che ci siano alcune strane scelte ma quanto sopra funziona sicuramente. Presumo che tu stia importando withRouterdareact-router-dom
Sam Parmenter il

3
Sto importando withRouterda react-router-dom. La history.push modifica l'URL, ma non sembra caricare <Route>fino a quando non forzare l'aggiornamento della pagina ...
BreakDS

1
@rauliyohmc Mi sono sbagliato su questo. Il problema è che ho <Router> all'interno un componente React che è decorato @observer, il che fa scattare questo problema . Il problema è avere @withRoutersu ogni componente React.
BreakDS

3
Per coloro che trovano questa grande risposta, withRouterè semplicemente un HOC che utilizza un Routesottotetto. Ciò significa che utilizza solo 3 oggetti di scena, cronologia, corrispondenza e posizione . Nell'esempio sopra sembra che pushsia un prop a cui withRouteraggiungerebbe ButtonToNavigate, ma non è così. props.history.pushdovrebbe essere usato invece. Spero che questo aiuti gli altri che erano un po 'confusi.
vinnymac,

39
Wow. browserHistory.push('/path/some/where')sembra molto più semplice. Gli autori stanno cercando di scoraggiare la programmazione imperativa, ma a volte funziona meglio!
lux

149

Il modo più semplice per farlo:

this.props.history.push("/new/url")

Nota:

  • È possibile che si desideri passare history propdal componente padre al componente che si desidera richiamare l'azione se non è disponibile.

10
Uso un router 4.0, ma sui puntelli non esiste una chiave cronologica. Come posso ripararlo?
Nicolas S.Xu,

41
Se non hai a this.props.historydisposizione nel tuo componente, puoi import {withRouter} from 'react-router-dom'e quindi export default withRouter(MyComponent)(o const MyComponent = withRouter(...)) e inserirà l' historyoggetto negli oggetti di scena del tuo componente.
Malvineous,

@Malvineous è interessante, non lo sapevo! Ci proverò!
Jikku Jose,

2
Mi manca qualcosa di fondamentale, perché per me funziona alla grande, quindi non ho idea del perché tutte le risposte richiedano spiegazioni così lunghe.
Joshua Pinter,

come impedire il rimontaggio dei componenti history.pushe semplicemente attivare l'aggiornamento come quando si fa clic su<Link>
Rahul Yadav

55

Ho avuto un problema simile durante la migrazione a React-Router v4, quindi cercherò di spiegare la mia soluzione di seguito.

Ti preghiamo di non considerare questa risposta come il modo giusto per risolvere il problema, immagino che ci siano buone probabilità che sorga qualcosa di meglio poiché React Router v4 diventa più maturo e lascia la beta (potrebbe anche esistere già e non l'ho scoperto) .

Per il contesto, ho avuto questo problema perché occasionalmente lo uso Redux-Sagaper modificare a livello di codice l'oggetto della cronologia (ad esempio quando un utente esegue l'autenticazione).

Nei documenti di React Router, dai un'occhiata al <Router> componente e puoi vedere che hai la possibilità di passare il tuo oggetto storico tramite un oggetto di scena. Questa è l'essenza della soluzione: forniamo l'oggetto storico a React-Routerda un modulo globale .

passi:

  1. Installa il modulo di cronologia npm - yarn add history oppure npm install history --save
  2. crea un file chiamato history.jsnella tua App.jscartella di livello (questa era la mia preferenza)

    // src/history.js
    
    import createHistory from 'history/createBrowserHistory';
    export default createHistory();`
  3. Aggiungi questo oggetto storico al componente Router in questo modo

    // src/App.js
    
    import history from '../your/path/to/history.js;'
    <Router history={history}>
    // Route tags here
    </Router>
  4. Modifica l'URL come prima importando l' oggetto della cronologia globale:

    import history from '../your/path/to/history.js;'
    history.push('new/path/here/');

Ora tutto dovrebbe rimanere sincronizzato e avrai anche accesso a un modo di impostare l'oggetto cronologico a livello di codice e non tramite un componente / contenitore.


5
Questa modifica ha funzionato per me, ma solo perché sto navigando al di fuori di un componente. Se stessi navigando all'interno di un componente come l'OP, utilizzerei l'approccio suggerito da @rauliyohmc usando gli oggetti di scena passati dal Routecomponente.
Dan Ellis,

2
questo è l'approccio consigliato a partire dal 08/17
Spets

2
@Spets Nel mio caso, se utilizzo questo tipo di approccio, il collegamento verrà aggiornato correttamente dopo il push, ma i componenti non vengono visualizzati correttamente (ad esempio, dopo l'aggiornamento del collegamento, il componente non viene aggiornato a meno che non si imponga l'aggiornamento della pagina). Dove hai trovato questo approccio raccomandato? Qualche link / fonte?
fico

2
@ScottCoates Ho risolto usando l'esempio sopra, fornendo infatti la cronologia come parametro, ma dopo aver eseguito il debug dei moduli del nodo da solo. C'è un errore comune commesso in tutto il web, usando l'importazione di "BrowserHistory as Router", quando invece c'è un altro oggetto chiamato Router da solo nell'ultima versione di reagire-router-dom. Usarlo in combinazione con la cronologia creata nell'esempio sopra funziona bene.
fico

2
l'URL viene aggiornato, ma la pagina non è renderd in base alla nuova radice. Qualche soluzione? Perché il trigger trigger è così difficile? Le persone che progettano reagiscono sono fuori di testa?
Nicolas S.Xu,

43

TL; DR:

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

La risposta semplice e dichiarativa è che è necessario utilizzare <Redirect to={URL} push={boolean} />in combinazione consetState()

push: booleano: se vero, il reindirizzamento spingerà una nuova voce nella cronologia invece di sostituire quella corrente.


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

Esempio completo qui . Leggi di più qui .

PS. L'esempio utilizza gli inizializzatori di proprietà ES7 + per inizializzare lo stato. Guarda anche qui , se sei interessato.


5
Questa dovrebbe essere una risposta accettata. La soluzione più semplice ed elegante! +1 per @lustoykov
Ali Abbas Jaffri,

1
Ho anche impostato la navigazione su false in componentDidUpdate poiché il mio pulsante è in un'intestazione e altrimenti navigerebbe solo una volta.
peterorum,

Funziona solo se conosci il reindirizzamento al caricamento della pagina. Se stai aspettando il ritorno di una chiamata asincrona (ovvero l'autenticazione con Google o qualcosa del genere), dovrai utilizzare uno dei history.push()metodi.
brittohalloran,

Non proprio, puoi comunque sfruttare la natura dichiarativa di reazioni combinata con il componente <Reindirizzamento />. Se la pagina non viene caricata, è possibile eseguire il fallback su un altro <Reindirizzamento />
Lyubomir

@brittohalloran l'idea di questo metodo usando il router di reazione appropriato, è assicurarsi di usare setState per forzare un nuovo rendering.
Qualcuno di speciale il

16

Usa il useHistoryhook se stai utilizzando i componenti delle funzioni

È possibile utilizzare useHistoryhook per ottenere historyistanza.

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

const MyComponent = () => {
  var history = useHistory();

  return (
    <button onClick={() => history.push("/about")}>
      Click me
    </button>
  );
}

L' useHistoryhook ti dà accesso all'istanza della cronologia che puoi usare per navigare.

Usa la historyproprietà all'interno dei componenti della pagina

React Router inietta alcune proprietà tra cui i historycomponenti della pagina.

class HomePage extends React.Component {
  render() {
    const { history } = this.props;

    return (
      <div>
        <button onClick={() => history.push("/projects")}>
          Projects
        </button>
      </div>
    );
  }
}

Avvolgere i componenti figlio withRouterper iniettare le proprietà del router

withRouterwrapper inietta le proprietà del router ai componenti. Ad esempio, è possibile utilizzare questo wrapper per iniettare il router per disconnettere il componente pulsante inserito nel menu utente.

import { withRouter } from "react-router";

const LogoutButton = withRouter(({ history }) => {
  return (
    <button onClick={() => history.push("/login")}>
      Logout
    </button>
  );
});

export default LogoutButton;

11

Puoi anche semplicemente usare gli oggetti di scena per accedere all'oggetto della cronologia: this.props.history.push('new_url')


5
Utile solo quando nel componente discende direttamente dal router. Per non far passare la storia prop a ogni singolo componente in cui hai bisogno di questa funzionalità.
mwieczorek,

3
Se non hai a this.props.historydisposizione nel tuo componente, puoi import {withRouter} from 'react-router-dom'e quindi export default withRouter(MyComponent)(o const MyComponent = withRouter(...)) e inserirà l' historyoggetto negli oggetti di scena del tuo componente.
Malvineous,

9

Passaggio 1: c'è solo una cosa da importare in alto:

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

Passaggio 2: nel percorso, passa la cronologia:

<Route
  exact
  path='/posts/add'
  render={({history}) => (
    <PostAdd history={history} />
  )}
/>

Passaggio 3: la cronologia viene accettata come parte degli oggetti di scena nel componente successivo, quindi puoi semplicemente:

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

È stato facile e davvero potente.


7

Questo funziona:

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

const SomeComponent = withRouter(({ history }) => (
    <div onClick={() => history.push('/path/some/where')}>
        some clickable element
    </div>); 
);

export default SomeComponent;

5

La mia risposta è simile a quella di Alex . Non sono sicuro del motivo per cui React-Router abbia reso questo inutilmente complicato. Perché dovrei avvolgere il mio componente con un HoC solo per avere accesso a ciò che è essenzialmente un globale?

Ad ogni modo, se dai un'occhiata a come sono stati implementati <BrowserRouter>, è solo un piccolo involucro attorno alla storia .

Siamo in grado di estrarre la cronologia in modo da poterla importare da qualsiasi luogo. Il trucco, tuttavia, è se stai eseguendo il rendering sul lato server e provi importil modulo cronologico, non funzionerà perché utilizza API solo per browser. Ma va bene perché di solito reindirizziamo solo in risposta a un clic o ad altri eventi sul lato client. Quindi probabilmente è OK fingere:

// history.js
if(__SERVER__) {
    module.exports = {};
} else {
    module.exports = require('history').createBrowserHistory();
}

Con l'aiuto del webpack, possiamo definire alcuni parametri in modo da sapere in quale ambiente ci troviamo:

plugins: [
    new DefinePlugin({
        '__SERVER__': 'false',
        '__BROWSER__': 'true', // you really only need one of these, but I like to have both
    }),

E ora puoi

import history from './history';

Da qualsiasi luogo Restituirà semplicemente un modulo vuoto sul server.

Se non vuoi usare questi varianti magici, dovrai solo requirenell'oggetto globale dove è necessario (all'interno del gestore dell'evento). importnon funzionerà perché funziona solo ai massimi livelli.


6
accidenti lo hanno reso così complicato.
Abhishek,

4
Sono totalmente d'accordo con te. questo è così complicato solo per una navigazione
Thai Tran

5

Penso che @rgommezz copra la maggior parte dei casi meno uno che penso sia abbastanza importante.

// history is already a dependency or React Router, but if don't have it then try npm install save-dev history

import createHistory from "history/createBrowserHistory"

// in your function then call add the below 
const history = createHistory();
// Use push, replace, and go to navigate around.
history.push("/home");

Questo mi permette di scrivere un semplice servizio con azioni / chiamate che posso chiamare per fare la navigazione da qualsiasi componente che voglio senza fare molto HoC sui miei componenti ...

Non è chiaro perché nessuno abbia fornito questa soluzione prima. Spero che sia di aiuto, e se vedi qualche problema con esso, per favore fatemelo sapere.


4

Sto testando la v4 da alcuni giorni e .. lo adoro finora! Ha senso dopo un po '.

Ho anche avuto la stessa domanda e ho scoperto che gestirla come segue funzionava meglio (e potrebbe anche essere come è destinata). Usa lo stato, un operatore ternario e<Redirect> .

Nel costruttore ()

this.state = {
    redirectTo: null
} 
this.clickhandler = this.clickhandler.bind(this);

Nel render ()

render(){
    return (
        <div>
        { this.state.redirectTo ?
            <Redirect to={{ pathname: this.state.redirectTo }} /> : 
            (
             <div>
               ..
             <button onClick={ this.clickhandler } />
              ..
             </div>
             )
         }

Nel clickhandler ()

 this.setState({ redirectTo: '/path/some/where' });

Spero che sia d'aiuto. Fammi sapere.


Ci sono insidie ​​con questo metodo? Nel mio progetto con funziona solo quando imposto lo stato in costruttore, da lì posso reindirizzare a qualsiasi pagina che desidero. Ma quando imposto lo stato sull'evento (ad esempio gli oggetti di scena sono cambiati) vedo il metodo di rendering chiamato con il nuovo stato, ma il reindirizzamento non avviene vedo la stessa pagina
Dmitry Malugin,

La trappola è che sostituirà la storia, quindi non sarai in grado di contrattaccare, quindi sostanzialmente non è una buona soluzione.
dannytenaglias,

4

Ho lottato con questo per un po '- qualcosa di così semplice, ma così complicato, perché ReactJS è solo un modo completamente diverso di scrivere applicazioni web, è molto estraneo a noi anziani!

Ho creato un componente separato per sottrarre il disordine:

// LinkButton.js

import React from "react";
import PropTypes from "prop-types";
import {Route} from 'react-router-dom';

export default class LinkButton extends React.Component {

    render() {
        return (
            <Route render={({history}) => (
                <button {...this.props}
                       onClick={() => {
                           history.push(this.props.to)
                       }}>
                    {this.props.children}
                </button>
            )}/>
        );
    }
}

LinkButton.propTypes = {
    to: PropTypes.string.isRequired
};

Quindi aggiungilo al tuo render()metodo:

<LinkButton className="btn btn-primary" to="/location">
    Button Text
</LinkButton>

Trovo questa soluzione abbastanza utile. Sto copiando il codice. Fammi sapere che lo metti su github - te lo attribuirò direttamente.
Abhinav Manchanda,

3

Dato che non c'è altro modo di affrontare questo orribile progetto, ho scritto un componente generico che utilizza l' approccio withRouter HOC . L'esempio seguente racchiude un buttonelemento, ma puoi passare a qualsiasi elemento selezionabile di cui hai bisogno:

import React from 'react';
import PropTypes from 'prop-types';
import { withRouter } from 'react-router-dom';

const NavButton = (props) => (
  <Button onClick={() => props.history.push(props.to)}>
    {props.children}
  </Button>
);

NavButton.propTypes = {
  history: PropTypes.shape({
    push: PropTypes.func.isRequired
  }),
  to: PropTypes.string.isRequired
};

export default withRouter(NavButton);

Uso:

<NavButton to="/somewhere">Click me</NavButton>

3
this.props.history.push("/url")

Se non hai trovato this.props.history disponibile nel tuo componente, prova questo

import {withRouter} from 'react-router-dom'
export default withRouter(MyComponent)  

Grazie mille!
QauseenMZ,

1

Siccome a volte preferisco cambiare rotta per Applicazione e poi per pulsanti, questo è un esempio minimo di lavoro che funziona per me:

import { Component } from 'react'
import { BrowserRouter as Router, Link } from 'react-router-dom'

class App extends Component {
  constructor(props) {
    super(props)

    /** @type BrowserRouter */
    this.router = undefined
  }

  async handleSignFormSubmit() {
    await magic()
    this.router.history.push('/')
  }

  render() {
    return (
      <Router ref={ el => this.router = el }>
        <Link to="/signin">Sign in</Link>
        <Route path="/signin" exact={true} render={() => (
          <SignPage onFormSubmit={ this.handleSignFormSubmit } />
        )} />
      </Router>
    )
  }
}

0

Per quelli di voi che hanno bisogno di reindirizzare prima di inizializzare completamente un router usando React Routero React Router DomÈ possibile fornire un reindirizzamento semplicemente accedendo all'oggetto della cronologia e inserendo un nuovo stato all'interno di esso app.js. Considera quanto segue:

function getSubdomain(hostname) {
    let regexParse = new RegExp('[a-z\-0-9]{2,63}\.[a-z\.]{2,5}$');
    let urlParts = regexParse.exec(hostname);
    return hostname.replace(urlParts[0], '').slice(0, -1);
}

class App extends Component {

    constructor(props) {
        super(props);


        this.state = {
            hostState: true
        };

        if (getSubdomain(window.location.hostname).length > 0) {
            this.state.hostState = false;
            window.history.pushState('', '', './login');
        } else {
            console.log(getSubdomain(window.location.hostname));
        }

    }


    render() {
        return (

            <BrowserRouter>
                {this.state.hostState ? (
                    <div>
                        <Route path="/login" component={LoginContainer}/>
                        <Route path="/" component={PublicContainer}/>
                    </div>
                ) : (
                    <div>
                        <Route path="/login" component={LoginContainer}/>
                    </div>
                )

                }
            </BrowserRouter>)
    }


}

Qui vogliamo cambiare le rotte di output dipendenti da un sottodominio, interagendo con l'oggetto della cronologia prima che il componente esegua il rendering, possiamo reindirizzare efficacemente lasciando ancora intatte le nostre rotte.

window.history.pushState('', '', './login');
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.