Como obter a rota atual

471

Os documentos atuais falam apenas sobre como obter parâmetros de rota, não os segmentos de rota reais.

Por exemplo, se eu quiser encontrar o pai da rota atual, como isso é possível?

pdeva
fonte
25
window.location.pathname
Dchacke
1
@dchacke O problema window.locationé que, no futuro, eles desejam implementar a renderização no servidor, enfrentarão algumas dificuldades, uma vez windowque não existe no servidor Node.js, mas precisam usar os métodos padrão Angular para acessar a rota e eles ficarão bem no servidor e no navegador.
Mohammad Kermani 30/03
Sim, faz sentido. Aqueles que usam ou planejam usar a renderização no servidor devem levar isso em consideração.
dchacke 31/03

Respostas:

523

O novo roteador V3 tem uma propriedade de URL.

this.router.url === '/login'
Victor96
fonte
5
Eu uso esse código e estou recebendo esse URL na variável string, mas quando tento imprimir no console .log, ele não está imprimindo this.fullUrl = this.router.url console.log (this.fullUrl); // não imprime
vijay gupta 28/10
3
Veja como usar o novo recurso ativo do roteador <a routerLink="/dashboard" routerLinkActive="active"> Painel </a>
Victor96
34
este é inútil quando você está navegando com a estratégia de Hash, o url é sempre "/"
Ninja Codificação
5
@NinjaCoding Estou usando a estratégia Hash e estou recebendo apenas "/". Como posso obter o URL da rota com o Hash?
Murtuza
9
@Murtuza aqui está uma solução: this.router.events.filter((event: any) => event instanceof NavigationEnd).subscribe(event => { console.log('this is what your looking for ', event.url); });. Certifique-se de importarimport { Router, NavigationEnd } from '@angular/router';
Gel
160

RC4 angular:

Você pode importar Routerde@angular/router

Em seguida, injete-o:

constructor(private router: Router ) {

}

Em seguida, chame seu parâmetro de URL:

console.log(this.router.url); //  /routename
lowcrawler
fonte
2
A clareza extra sobre como importar o roteador em si é muito útil. Você poderia esclarecer se seria diferente se você estivesse usando um roteador personalizado?
Kbpontius
1
Isso certamente dependeria da 'customização' do roteador personalizado. (desculpe este não era um comentário particularmente útil - se você tem uma pergunta específica, eu sugiro fazer uma nova pergunta e referenciando esta resposta)
lowcrawler
42
Eu usei essa solução, mas sempre recebo esse "/". Alguem sabe por quê?
Marcio M.
4
A Injeção de dependência angular depende da sintaxe do açúcar TypeScript; portanto, quando você declara private _router: Router na assinatura do construtor, uma propriedade _router é criada automaticamente na instância de classe atual com o roteador injetado. Esta declaração this.router = _router; é apenas uma sobrecarga para mim, pois você teria duas referências à mesma instância de objeto (nesse caso, o roteador).
Andrew Reborn
1
@Marcio M. Pode ser porque o roteador ainda não atingiu esse estado, mesmo que o URL mostre diferente. Por exemplo, se você olhar para o router.url em um serviço de guarda. location.path (), conforme mencionado nas respostas, fornecerá o URL, independentemente do estado do roteador.
Daniel van Niekerk
61

Injete Locationno seu componente e leia location.path(); Você precisa adicionar ROUTER_DIRECTIVESum local para que o Angular possa resolver Location. Você precisa adicionar import: [RouterModule]ao módulo.

Atualizar

No roteador V3 (RC.3), você pode injetar ActivatedRoutee acessar mais detalhes usando sua snapshotpropriedade.

constructor(private route:ActivatedRoute) {
  console.log(route);
}

ou

constructor(private router:Router) {
  router.events.subscribe(...);
}

Consulte também ouvinte de eventos do roteador Angular 2

Günter Zöchbauer
fonte
3
isso me dá o caminho 'url'. como localizo os 'nomes de rota' para que eu possa passá-los em uma matriz para o navigatemétodo, juntamente com o nome (anexado) da rota filho para a qual quero navegar.
Pdeva
Eu vejo. Eu também não acho isso satisfatório. Eu não tentei eu mesmo, mas talvez o MyTrackingServiceexplicado em stackoverflow.com/a/34548656/217408 permita acessar esses valores.
Günter Zöchbauer 4/16/16
Os nomes das rotas desapareceram agora.
Günter Zöchbauer
4
@GunterZochbauer, existe uma maneira de obter a rota solicitada antes de ser ativada? Por exemplo, se eu quiser armazenar a rota solicitada dentro de um canActivate()método, para que eu possa redirecionar para uma página de "login" e depois redirecionar de volta para a rota original depois que o usuário se autenticar?
Yevgeny Ananin
1
Você não pode fazer isso com um guarda canActivate?
Günter Zöchbauer
42

para novo roteador> = RC.3

Melhor e uma maneira simples de fazer isso é!

import { Router } from '@angular/router';
constructor(router: Router) { 
      router.events.subscribe((url:any) => console.log(url));
      console.log(router.url);  // to print only path eg:"/login"
}
Rajath MS
fonte
Como esta resposta difere da lowcrawler?
Not2savvy
1
O @ not2savvy havia dado mais uma maneira de descobrir o mesmo através do ouvinte de eventos do roteador, o que ajudou algumas pessoas a encontrar o que estavam procurando.
Rajath MS
36

Usa isto

import { Router, NavigationEnd } from '@angular/router';

constructor(private router: Router) {
    router.events.filter(event => event instanceof NavigationEnd)
        .subscribe(event => {
            console.log(event);
        });
}

E na main.tsimportação

import 'rxjs/add/operator/filter';

EDITAR

Maneira moderna

import {filter} from 'rxjs/operators';

router.events.pipe(
    filter(event => event instanceof NavigationEnd)
)
    .subscribe(event => {
        console.log(event);
    });
Vlad
fonte
10
Essa é realmente a maneira recomendada de fazer algo tão simples quanto verificar para onde o URL atual está apontando? Não estou discutindo contra você neste caso. No entanto, notei que o roteamento é uma fonte de muitas alterações, atualizações, confusões, etc. Eu esperava que o ActivatedRoute fosse usado principalmente para isso, não para o roteador . Estou sentindo falta da complexidade do problema, talvez?
DonkeyBanana
Refiro-me ao ActivatedRoute nos documentos oficiais.
DonkeyBanana
1
Não há necessidade de qualquer pelo menos aqui, as exportações do roteador do tipo "RouterEvent" que se estende por outros eventos do roteador - angular.io/api/router/RouterEvent
chrismarx
1
@chrismarx fixo
Vlad
@DonkeyBanana Na verdade, se você estiver lidando com módulos aninhados que contêm suas próprias rotas, então sim. De fato, usando módulos e roteadores aninhados (que é o que a Equipe Angular recomenda) é a única maneira de obter o URL real da rota atual, todos os outros métodos simplesmente retornam /.
Eagerestwolf 10/04
32

Para quem ainda está procurando por isso. No Angular 2.x, existem algumas maneiras de fazer isso.

constructor(private router: Router, private activatedRoute: ActivatedRoute){

   // string path from root to current route. i.e /Root/CurrentRoute
   router.url 

    // just the fragment of the current route. i.e. CurrentRoute
   activatedRoute.url.value[0].path

    // same as above with urlSegment[]
   activatedRoute.url.subscribe((url: urlSegment[])=> console.log(url[0].path))

   // same as above
   activatedRoute.snapshot.url[0].path

   // the url fragment from the parent route i.e. Root
   // since the parent is an ActivatedRoute object, you can get the same using 
   activatedRoute.parent.url.value[0].path
}

Referências:

  1. https://angular.io/docs/ts/latest/api/router/index/ActivatedRoute-interface.html
  2. https://angular.io/docs/ts/latest/api/router/index/Router-class.html
  3. https://angular.io/docs/ts/latest/guide/router.html
n4nd0_o
fonte
27

Para obter os segmentos da rota:

import { ActivatedRoute, UrlSegment } from '@angular/router';

constructor( route: ActivatedRoute) {}

getRoutes() { const segments: UrlSegment[] = this.route.snapshot.url; }
ttugates
fonte
14

Você pode tentar com

import { Router, ActivatedRoute} from '@angular/router';    

constructor(private router: Router, private activatedRoute:ActivatedRoute) {
console.log(activatedRoute.snapshot.url)  // array of states
console.log(activatedRoute.snapshot.url[0].path) }

Maneiras alternativas

router.location.path();   this works only in browser console. 

window.location.pathname que fornece o nome do caminho.

Jose G Varanam
fonte
update: enabledRoute.snapshot.url é um Observable agora e você precisa se inscrever nele.
Sadok Mtir
12

Para obter com segurança a rota atual completa, você pode usar este

this.router.events.subscribe(
  (event: any) => {
    if (event instanceof NavigationEnd) {
      console.log('this.router.url', this.router.url);
    }
  }
);
Andrei Diaconescu
fonte
9

O windowobjeto nativo também funciona bem

console.log('URL:' + window.location.href);
console.log('Path:' + window.location.pathname);
console.log('Host:' + window.location.host);
console.log('Hostname:' + window.location.hostname);
console.log('Origin:' + window.location.origin);
console.log('Port:' + window.location.port);
console.log('Search String:' + window.location.search);

NOTA: NÃO UTILIZE ESTE NA RENDERAÇÃO LATERAL DO SERVIDOR

Sanket Berde
fonte
1
Tenha cuidado se você estiver usando a renderização no servidor, isso será interrompido.
Jason Foglia
7

versão curta se você tiver roteador importado, poderá simplesmente usar algo como

this.router.url === "/ pesquisa"

caso contrário, faça o seguinte

1) Importe o roteador

import { Router } from '@angular/router';

2) Declarar sua entrada no construtor

constructor(private router: Router) { }

3) Use seu valor em sua função

yourFunction(){
    if(this.router.url === "/search"){
        //some logic
    }
}

resposta @ victor me ajudou, esta é a mesma resposta que ele, mas com um pequeno detalhe, pois pode ajudar alguém

Mateen
fonte
6
import { Router } from '@angular/router';
constructor(router: Router) { 
      console.log(router.routerState.snapshot.url);
}
Caracteres
fonte
5

No Angular2 Rc1, você pode injetar RouteSegment e passá-los no método naviagte.

constructor(private router:Router,private segment:RouteSegment) {}

  ngOnInit() {
    this.router.navigate(["explore"],this.segment)
  }
Arpit Agarwal
fonte
5

Com o angular 2.2.1 (em um projeto baseado no angular2-webpack-starter) funciona isso:

export class AppComponent {
  subscription: Subscription;
  activeUrl: string;

  constructor(public appState: AppState,
              private router: Router) {
    console.log('[app] constructor AppComponent');
  }

  ngOnInit() {
    console.log('[app] ngOnInit');
    let _this = this;
    this.subscription = this.router.events.subscribe(function (s) {
      if (s instanceof NavigationEnd) {
        _this.activeUrl = s.urlAfterRedirects;
      }
    });
  }

  ngOnDestroy() {
    console.log('[app] ngOnDestroy: ');
    this.subscription.unsubscribe();
  }
}

No modelo do AppComponent, você pode usar, por exemplo, {{activeUrl}}.

Esta solução é inspirada no código do RouterLinkActive.

adrhc
fonte
esta é uma boa resposta b / c se você tiver uma rota curinga que redirecione de volta para / home event.url não é suficiente para corresponder à rota / home, ela realmente mostrará a rota que não existe. event.urlAfterRedirects imprimirá a rota final real. ty.
Ian Poston Framer
4

angular 2 rc2

router.urlTree.contains(router.createUrlTree(['/home']))
nadav
fonte
4

Aqui está o que está funcionando para mim no Angular 2.3.1.

location: any;

constructor(private _router: Router) { 

      _router.events.subscribe((data:any) => { this.location = data.url; });

      console.warn(this.location);  // This should print only path e.g. "/home"
}

O dataé um objeto e precisamos da urlpropriedade contida nesse objeto. Portanto, capturamos esse valor em uma variável e também podemos usá-la em nossa página HTML. Por exemplo, eu quero mostrar uma div somente quando o usuário estiver na página inicial. Nesse caso, o valor do URL do meu roteador será /home. Para que eu possa escrever uma div da seguinte maneira:

<div *ngIf="location == '/home'">
This is content for the home page.
</div>
Devner
fonte
4

Eu tive o mesmo problema usando

this.router.url

Eu recebo a rota atual com parâmetros de consulta. Uma solução alternativa que fiz foi usar isso:

this.router.url.split('?')[0]

Não é uma solução muito boa, mas útil.

Formiga T.
fonte
4

Você pode usar ActivatedRoutepara obter o roteador atual

Resposta original (para versão RC)

Encontrei uma solução no AngularJS Google Group e é tão fácil!

ngOnInit() {
  this.router.subscribe((url) => console.log(url));
}

Aqui está a resposta original

https://groups.google.com/d/msg/angular/wn1h0JPrF48/zl1sHJxbCQAJ

Khaled Al-Ansari
fonte
Foi alterado a partir de rc.2, pois urlagora não é mais a URL e uma string, mas a ComponentInstruction.
Martin C.
4

MANEIRA 1 : Usando Angular: this.router.url

import { Component } from '@angular/core';

// Step 1: import the router 
import { Router } from '@angular/router';

@Component({
    template: 'The href is: {{href}}'
    /*
    Other component settings
    */
})
export class Component {
    public href: string = "";

    //Step 2: Declare the same in the constructure.
    constructor(private router: Router) {}

    ngOnInit() {
        this.href = this.router.url;
        // Do comparision here.....
        ///////////////////////////
        console.log(this.router.url);
    }
}

MANEIRA 2 Window.location, como fazemos no Javascript, se você não quiser usar o roteador

this.href= window.location.href;
Trilok Pathak
fonte
3

Para seus propósitos, você pode usar this.activatedRoute.pathFromRoot.

import {ActivatedRoute} from "@angular/router";
constructor(public activatedRoute: ActivatedRoute){

}

Com a ajuda de pathFromRoot, você pode obter a lista de URLs pai e verificar se a parte necessária da URL corresponde à sua condição.

Para obter informações adicionais, consulte este artigo http://blog.2muchcoffee.com/getting-current-state-in-angular2-router/ ou instale o ng2-router-helper a partir da npm

npm install ng2-router-helper
Дмитрий Мельниченко
fonte
3

Para encontrar o pai da rota atual, você pode obter o UrlTreedo roteador usando rotas relativas:

var tree:UrlTree = router.createUrlTree(['../'], {relativeTo: route});

Em seguida, para obter os segmentos da tomada principal:

tree.root.children[PRIMARY_OUTLET].segments;
pixelbits
fonte
3

A partir de agora, estou seguindo meu caminho da seguinte maneira:

this.router.url.subscribe(value => {
    // you may print value to see the actual object
    // console.log(JSON.stringify(value));
    this.isPreview = value[0].path === 'preview';
})

Onde, routeré uma instância deActivatedRoute

Tushar Walzade
fonte
3

router.events.subscribe(e => {
      if (e instanceof NavigationEnd) {
        this.currentUrl = e.url;
      }
    });

Manoj Manu M
fonte
3
import { Router, NavigationEnd } from "@angular/router";

constructor(private router: Router) {
  // Detect current route
  router.events.subscribe(val => {
    if (val instanceof NavigationEnd) {
      console.log(val.url);
    }
});
Hamza
fonte
2

isso é simples, no angular 2 você só precisa importar a biblioteca do roteador como esta:

import { Router } from '@angular/router';

Em seguida, no construtor do componente ou serviço, você deve instancia-lo assim:

constructor(private _router: Router) {}

Em qualquer parte do código, seja em uma função, método, construção, qualquer que seja:

      this._router.events
        .subscribe(
            (url:any) => {
                let _ruta = "";
                url.url.split("/").forEach(element => {
                    if(element!=="" && _ruta==="")
                        _ruta="/"+element;  
                });
                console.log("route: "+_ruta); //<<<---- Root path
                console.log("to URL:"+url.url); //<<<---- Destination URL                    
                console.log("from URL:"+this._router.url);//<<<---- Current URL
            }); 
eberlast
fonte
2

Você pode usar no arquivo .ts

import { Route, Router, NavigationStart } from '@angular/router';

constructor(private router: Router) {}

this.router.events.subscribe(value => {
      if (value instanceof NavigationStart) {
        console.log(value) // your current route
      }
    });
Chirag
fonte
1

essa pode ser sua resposta, use o método params da rota ativada para obter parâmetros do URL / rota que você deseja ler, abaixo está o snippet de demonstração

import {ActivatedRoute} from '@angular/router'; 
@Component({
})
export class Test{
constructor(private route: ActivatedRoute){
this.route.params.subscribe(params => {
             this.yourVariable = params['required_param_name'];
        });
    }
}
Vinod
fonte
1
this.router.events.subscribe((val) => {
   const currentPage = this.router.url; // Current page route
  const currentLocation = (this.platformLocation as any).location.href; // Current page url
});
Shanil Sasikumar
fonte
1

Se você precisar acessar o URL atual, normalmente precisará aguardar que NavigationEnd ou NavigationStart faça alguma coisa. Se você apenas se inscrever nos eventos do roteador, a assinatura produzirá muitos eventos no ciclo de vida da rota. Em vez disso, use um operador RxJS para filtrar apenas o evento que você precisa. O efeito colateral benéfico disso é agora que temos tipos mais rígidos!

constructor(private router: Router) {
    router.events.pipe(
      filter(ev => (ev instanceof NavigationEnd))
    ).subscribe((ev: NavigationEnd) => {
      console.log(ev.url);
    });
}

codescholar
fonte
1

Eu estava enfrentando o problema em que precisava do caminho da URL quando o usuário estava navegando no aplicativo ou acessando uma URL (ou atualizando em uma URL específica) para exibir componentes filhos com base na URL.

Além disso , quero um Observable que possa ser consumido no modelo, para que router.url não fosse uma opção. Nem a assinatura router.events porque o roteamento é acionado antes da inicialização do modelo do componente.

this.currentRouteURL$ = this.router.events.pipe(
     startWith(this.router),
     filter(
         (event) => event instanceof NavigationEnd || event instanceof Router
     ),
     map((event: NavigationEnd | Router) => event.url)
);

Espero que ajude, boa sorte!

Andrew Radulescu
fonte
1
Isso é incrível.
codeepic