कोणीय में, आप सक्रिय मार्ग कैसे निर्धारित करते हैं?


311

नोट: यहाँ कई अलग-अलग उत्तर हैं, और अधिकांश एक समय या किसी अन्य पर मान्य हैं। तथ्य यह है कि क्या काम करता है कई बार बदल गया है क्योंकि कोणीय टीम ने अपना राउटर बदल दिया है। राउटर 3.0 संस्करण, जो अंत में एंगुलर में राउटर होगा , इन समाधानों में से कई को तोड़ता है, लेकिन अपने स्वयं के बहुत सरल समाधान प्रदान करता है। RC.3 के रूप में, पसंदीदा समाधान का उपयोग इस उत्तर[routerLinkActive] में दिखाया गया है ।

एक कोणीय अनुप्रयोग में (वर्तमान 2.0.0-बीटा.0 रिलीज में जैसा कि मैं यह लिखता हूं), आप यह कैसे निर्धारित करते हैं कि वर्तमान में सक्रिय मार्ग क्या है?

मैं एक ऐसे ऐप पर काम कर रहा हूं जो बूटस्ट्रैप 4 का उपयोग करता है और मुझे नेविगेशन लिंक / बटन को सक्रिय करने के लिए एक तरीका चाहिए जब उनके संबद्ध घटक को <router-output>टैग में दिखाया जा रहा हो ।

मुझे एहसास है कि जब बटन में से एक पर क्लिक किया जाता है तो मैं खुद को राज्य बनाए रख सकता हूं, लेकिन यह एक ही मार्ग में कई पथ होने के मामले को कवर नहीं करेगा (मुख्य नेविगेशन मेनू और मुख्य घटक में एक स्थानीय मेनू भी कह सकता है) )।

किसी भी सुझाव या लिंक की सराहना की जाएगी। धन्यवाद।

जवाबों:


354

नए कोणीय राउटर के साथ , आप [routerLinkActive]="['your-class-name']"अपने सभी लिंक में एक विशेषता जोड़ सकते हैं :

<a [routerLink]="['/home']" [routerLinkActive]="['is-active']">Home</a>

या सरलीकृत गैर-सरणी प्रारूप यदि केवल एक वर्ग की आवश्यकता है:

<a [routerLink]="['/home']" [routerLinkActive]="'is-active'">Home</a>

या उससे भी सरल प्रारूप यदि केवल एक वर्ग की आवश्यकता है:

<a [routerLink]="['/home']" routerLinkActive="is-active">Home</a>

अधिक जानकारी के लिए खराब प्रलेखित routerLinkActiveनिर्देश देखें । (मैं ज्यादातर परीक्षण और त्रुटि के माध्यम से यह पता लगा।)

अद्यतन: routerLinkActiveनिर्देश के लिए बेहतर प्रलेखन अब यहाँ पाया जा सकता है । (नीचे टिप्पणी में @Victor ह्यूगो अरंगो ए के लिए धन्यवाद।)


4
क्या मार्ग के बच्चों के सक्रिय होने पर इसे सक्रिय करने का कोई तरीका है? कोड में @inputविकल्पों के लिए है, लेकिन exact: falseवर्ग को सक्रिय करता है जब भी वर्तमान मार्ग के भाई-बहन सक्रिय होते हैं।
मतेज

1
@ गेब्रियलब-डेविड मैंने इसका परीक्षण नहीं किया है, लेकिन मुझे लगता है कि router.navigate()यह ठीक काम करेगा। routerLinkActiveबस इस बात का एक संकेतक है कि क्या यह लिंक सक्रिय मार्ग का प्रतिनिधित्व करता है।
जेसेपिन्हो

7
दिए गए उदाहरण में, [routerLinkActive] को <a /> टैग में जोड़ा जाता है, हालांकि, इसे अन्य तत्वों पर भी डाला जा सकता है यदि वर्ग कहीं और आवश्यक हो। <ul> <li [routerLinkActive] = "['सक्रिय']"> <a hrouterLinkacing="ImyRoute.Routeiding">
Oblivion2000

2
@jessepinho - ने इसे आज़माया - [राऊटरलिंकएक्टिव] = "'सक्रिय'" केवल तभी काम करेगा जब आपके पास इन-टैग में [राऊटरलिंक] भी हो। यदि आपके पास [राऊटरलिंक] के बजाय (क्लिक करें) = "navitageTo ('/ मार्ग')", और उस फ़ंक्शन में, आपने इसे कहा था। weter.navigate (मार्ग), नया घटक लोड होगा लेकिन आपका सक्रिय सीएसएस वर्ग जीत गया t लगाया जाए। मैं इस फंक्शन में इसके अलावा कुछ और करने की कोशिश कर रहा हूँ।
मिकेल कारुसो

2
आधिकारिक प्रलेखन में उदाहरण आपकी मदद कर सकता है: angular.io/docs/ts/latest/api/router/index/…
विक्टर ह्यूगो अरंगो ए।

69

मैंने एक अन्य प्रश्न में इसका उत्तर दिया है, लेकिन मेरा मानना ​​है कि यह इसके लिए भी प्रासंगिक हो सकता है। यहां मूल उत्तर के लिए एक लिंक है: कोणीय 2: मापदंडों के साथ सक्रिय मार्ग कैसे निर्धारित करें?

मैं यह जानने के लिए सक्रिय कक्षा निर्धारित करने की कोशिश कर रहा हूं कि वास्तव में वर्तमान स्थान (मार्ग नाम का उपयोग करके) क्या है । सबसे अच्छा समाधान जो मुझे अब तक मिला है, वह फ़ंक्शन का उपयोग कर रहा है । कक्षा में उपलब्ध आर्कटिकRouter

router.isRouteActive(instruction): Booleanएक पैरामीटर लेता है जो एक रूट Instructionऑब्जेक्ट है और रिटर्न trueया falseवह निर्देश सही है या नहीं जो वर्तमान रूट के लिए है। आप 's जनरेट (linkParams: Array)Instruction का उपयोग करके एक मार्ग उत्पन्न कर सकते हैं । LinkParams एक राउटरलिंक निर्देश (उदा ) में पारित मान के समान सटीक प्रारूप का अनुसरण करता है ।Routerrouter.isRouteActive(router.generate(['/User', { user: user.id }]))

यह है कि रूटकॉन्फिग कैसे दिख सकती है (मैंने इसे परमेस के उपयोग को दिखाने के लिए इसे थोड़ा बदल दिया है) :

@RouteConfig([
  { path: '/', component: HomePage, name: 'Home' },
  { path: '/signin', component: SignInPage, name: 'SignIn' },
  { path: '/profile/:username/feed', component: FeedPage, name: 'ProfileFeed' },
])

और दृश्य इस तरह दिखेगा:

<li [class.active]="router.isRouteActive(router.generate(['/Home']))">
   <a [routerLink]="['/Home']">Home</a>
</li>
<li [class.active]="router.isRouteActive(router.generate(['/SignIn']))">
   <a [routerLink]="['/SignIn']">Sign In</a>
</li>
<li [class.active]="router.isRouteActive(router.generate(['/ProfileFeed', { username: user.username }]))">
    <a [routerLink]="['/ProfileFeed', { username: user.username }]">Feed</a>
</li>

यह समस्या के लिए मेरा पसंदीदा समाधान रहा है, यह आपके लिए भी उपयोगी हो सकता है।


1
मुझे लगता है कि यह समाधान स्वीकार किए गए से बेहतर है क्योंकि यह एंगुलर एपीआई के बजाय मार्ग से मेल खाता हुआ रेगीक्स का उपयोग करता है। यह अभी भी थोड़ा बदसूरत है, लेकिन यह सिर्फ करने में सक्षम होने के लिए अच्छा होगा router.isRouteActive('Home')
फिलिप्प

2
मैंने समाधान को लागू करने की कोशिश करने पर कुछ मुद्दों का सामना किया, इसलिए शायद कुछ उपयोगी हो सकते हैं: stackoverflow.com/questions/35882998/…
निकिता वेलसेंको

5
Routerक्लास के कंस्ट्रक्टर में डालना नहीं भूलना चाहिए
निकिता वेलसेंको

2
नवीनतम कॉन्फ़िगरेशन 2 संस्करण में मैंने राउटर कॉन्फ़िगरेशन ऑब्जेक्ट के nameबजाय उपयोग किया as
कॉमफ्रीक

9
इसका उपयोग rc1 के बजाय किया जा सकता है:router.urlTree.contains(router.createUrlTree(['Home']))
František ikiačik

35

मैंने इस लिंक में आई एक समस्या को हल किया और मुझे पता चला कि आपके प्रश्न का एक सरल समाधान है। आप router-link-activeअपनी शैलियों के बजाय उपयोग कर सकते हैं।

@Component({
   styles: [`.router-link-active { background-color: red; }`]
})
export class NavComponent {
}

2
मेरा मानना ​​है कि यह स्वीकृत उत्तर होना चाहिए। Angular2 का राउटर आपके लिए यह स्वचालित रूप से जोड़ देगा।
गाबु

2
दुर्भाग्य से, वह वर्ग <
ul

दुर्भाग्य से यह वास्तव में अच्छी तरह से काम नहीं करता है। मेरे पास एक गतिशील रूप से उत्पन्न मेनू है और router-link-activeकक्षा को सक्रिय aया में नहीं जोड़ा जा रहा है li। लेकिन बूटस्ट्रैप का उपयोग करने वाला एक स्थान है nav-tabsऔर यह वहां काम करता है।
श्री

33

Https://github.com/angular/angular/pull/6407#issuecomment-190179875 पर आधारित @ एलेक्स-कोरिया-संतोस उत्तर में छोटा सुधार

import {Router, RouteConfig, ROUTER_DIRECTIVES} from 'angular2/router';
// ...
export class App {
  constructor(private router: Router) {
  }

  // ...

  isActive(instruction: any[]): boolean {
    return this.router.isRouteActive(this.router.generate(instruction));
  }
} 

और इसे इस तरह से उपयोग करें:

<ul class="nav navbar-nav">
    <li [class.active]="isActive(['Home'])">
        <a [routerLink]="['Home']">Home</a>
    </li>
    <li [class.active]="isActive(['About'])">
        <a [routerLink]="['About']">About</a>
    </li>
</ul>

और घटक में एक शैली। styles : [सक्रिय {पृष्ठभूमि-रंग: एलिसब्लू; } ]। +1 यह काम करता है
प्रतीक केलवकर

महान समाधान, इसके साथ आप राउटर को निजी बना सकते हैं।
केल्विन डील्का

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

30

आप Locationअपने कंट्रोलर में ऑब्जेक्ट को इंजेक्ट करके वर्तमान रूट की जाँच कर सकते हैं path(), जैसे:

class MyController {
    constructor(private location:Location) {}

    ...  location.path(); ...
}

आपको इसे पहले आयात करना सुनिश्चित करना होगा:

import {Location} from "angular2/router";

फिर आप एक नियमित अभिव्यक्ति का उपयोग करके उस पथ के विरुद्ध मिलान कर सकते हैं जो यह देखने के लिए है कि कौन सा मार्ग सक्रिय है। ध्यान दें कि Locationवर्ग एक सामान्यीकृत पथ लौटाता है, भले ही LocationStrategyआप उसका उपयोग कर रहे हों। तो भले ही आप HashLocationStragegyवापस आए रास्तों का उपयोग कर रहे हों, फिर भी फॉर्म /foo/bar नहीं होगा #/foo/bar


17

आप कैसे निर्धारित करते हैं कि वर्तमान में सक्रिय मार्ग क्या है?

अद्यतन: Angular2.4.x के अनुसार अद्यतन किया गया

constructor(route: ActivatedRoute) {
   route.snapshot.params; // active route's params

   route.snapshot.data; // active route's resolved data

   route.snapshot.component; // active route's component

   route.snapshot.queryParams // The query parameters shared by all the routes
}

और देखें...


14

सक्रिय मार्गों को चिह्नित करने के routerLinkActiveलिए इस्तेमाल किया जा सकता है

<a [routerLink]="/user" routerLinkActive="some class list">User</a>

यह भी अन्य तत्वों की तरह काम करता है

<div routerLinkActive="some class list">
  <a [routerLink]="/user">User</a>
</div>

यदि आंशिक मैचों का भी उपयोग किया जाना चाहिए

routerLinkActive="some class list" [routerLinkActiveOptions]="{ exact: false }"

जहां तक ​​मुझे पता exact: falseहै कि RC.4 में डिफ़ॉल्ट होने जा रहा है


11

अभी मैं बूटस्ट्रैप 4 के साथ rc.4 का उपयोग कर रहा हूं और यह एक मेरे लिए एकदम सही है:

 <li class="nav-item" routerLinkActive="active" [routerLinkActiveOptions]="{exact:
true}">
    <a class="nav-link" [routerLink]="['']">Home</a>
</li>

यह url के लिए काम करेगा: / घर


सटीक विकल्प का उद्देश्य क्या है? क्या यह उप-पथों की तरह मेल नहीं खाता है /home/whatever?
माइकल ऑरिल

हां, exactमतलब, उस मार्ग का एक ही नाम होगा। और यह आवश्यक है अगर आप इसे ट्विटर बूटस्ट्रैप जैसे उपकरणों के साथ उपयोग करने की योजना बनाते हैं। यह पहले से ही सक्रिय लिंक स्थिति को संभालता है और बिना exactविकल्प काम नहीं करेगा। (यह सुनिश्चित नहीं है कि यह कोर में कैसे काम करता है, मैं यह कोशिश कर रहा था और यह मेरे लिए काम कर रहा है)
आर्टेम ज़िनोविएव

7

नीचे रूट रूट के अनुसार रूटडेटा का उपयोग करने की विधि है।

RouteConfig में टैब के साथ डेटा (वर्तमान मार्ग) शामिल हैं:

@RouteConfig([
  {
    path: '/home',    name: 'Home',    component: HomeComponent,
    data: {activeTab: 'home'},  useAsDefault: true
  }, {
    path: '/jobs',    name: 'Jobs',    data: {activeTab: 'jobs'},
    component: JobsComponent
  }
])

लेआउट का एक टुकड़ा:

  <li role="presentation" [ngClass]="{active: isActive('home')}">
    <a [routerLink]="['Home']">Home</a>
  </li>
  <li role="presentation" [ngClass]="{active: isActive('jobs')}">
    <a [routerLink]="['Jobs']">Jobs</a>
  </li>

वर्ग:

export class MainMenuComponent {
  router: Router;

  constructor(data: Router) {
    this.router = data;
  }

  isActive(tab): boolean {
    if (this.router.currentInstruction && this.router.currentInstruction.component.routeData) {
      return tab == this.router.currentInstruction.component.routeData.data['activeTab'];
    }
    return false;
  }
}

7

बस मैंने सोचा था कि मैं एक ऐसे उदाहरण में जोड़ूंगा जो किसी भी प्रकार का उपयोग नहीं करता है:

<input type="hidden" [routerLink]="'home'" routerLinkActive #home="routerLinkActive" />
<section *ngIf="home.isActive"></section>

routerLinkActiveचर एक टेम्पलेट चर के लिए बाध्य है और उसके बाद फिर से इस्तेमाल किया के रूप में की आवश्यकता है। दुर्भाग्य से एकमात्र चेतावनी यह है कि आप <section>तत्व पर यह सब नहीं कर सकते हैं क्योंकि पार्सर मारने से पहले#home हल करने की आवश्यकता है ।<section>


सक्रिय मार्गों पर शर्तों को लागू करने के लिए सही समाधान। कहीं @ कोणीय / राउटर या फिर काम नहीं किया।
रोहित पार्ट

वाह, यह बहुत उपयोगी है। धन्यवाद!
यूलियन

6

Routerकोणीय 2 आरसी में अब परिभाषित isRouteActiveऔर generateतरीके नहीं हैं।

urlTree - वर्तमान url पेड़ देता है।

createUrlTree(commands: any[], segment?: RouteSegment) - वर्तमान url ट्री पर कमांड का एक सरणी लागू करता है और एक नया url ट्री बनाता है।

निम्नलिखित का प्रयास करें

<li 
[class.active]=
"router.urlTree.contains(router.createUrlTree(['/SignIn', this.routeSegment]))">

नोटिस, routeSegment : RouteSegmentघटक के निर्माता में इंजेक्ट किया जाना चाहिए।


6

एंगुलर संस्करण में सक्रिय मार्ग स्टाइल को जोड़ने के लिए एक पूर्ण उदाहरण यहां 2.0.0-rc.1दिया गया है जो अशक्त रूट पथ (जैसे path: '/') को ध्यान में रखता है।

app.component.ts -> रूट

import { Component, OnInit } from '@angular/core';
import { Routes, Router, ROUTER_DIRECTIVES } from '@angular/router';
import { LoginPage, AddCandidatePage } from './export';
import {UserService} from './SERVICES/user.service';

@Component({
  moduleId: 'app/',
  selector: 'my-app',
  templateUrl: 'app.component.html',
  styleUrls: ['app.component.css'],
  providers: [UserService],
  directives: [ROUTER_DIRECTIVES]
})

@Routes([
  { path: '/', component: AddCandidatePage },
  { path: 'Login', component: LoginPage }
])
export class AppComponent  { //implements OnInit

  constructor(private router: Router){}

  routeIsActive(routePath: string) {
     let currentRoute = this.router.urlTree.firstChild(this.router.urlTree.root);
     // e.g. 'Login' or null if route is '/'
     let segment = currentRoute == null ? '/' : currentRoute.segment;
     return  segment == routePath;
  }
}

app.component.html

<ul>
  <li [class.active]="routeIsActive('Login')"><a [routerLink]="['Login']" >Login</a></li>
  <li [class.active]="routeIsActive('/')"><a [routerLink]="['/']" >AddCandidate</a></li>
</ul>
<route-outlet></router-outlet>

6

Angular2 RC 4 के लिए समाधान:

import {containsTree} from '@angular/router/src/url_tree';
import {Router} from '@angular/router';

export function isRouteActive(router: Router, route: string) {
   const currentUrlTree = router.parseUrl(router.url);
   const routeUrlTree = router.createUrlTree([route]);
   return containsTree(currentUrlTree, routeUrlTree, true);
}

5

के रूप में 8, यह काम करता है:

<li routerLinkActive="active" [routerLinkActiveOptions]="{ exact: true }">
    <a [routerLink]="['/']">Home</a>
</li>

{ exact: true } यह सुनिश्चित करता है कि यह यूआरएल से मेल खाता है।


5

2020 में यदि आप सक्रिय वर्ग को उस तत्व पर सेट करना चाहते हैं जिसमें कोई [रूटरलिंक] नहीं है - आप बस कर सकते हैं:

<a
  (click)="bookmarks()"
  [class.active]="router.isActive('/string/path/'+you+'/need', false)" // <== you need this one. second argument 'false' - exact: true/false
  routerLinkActive="active"
  [routerLinkActiveOptions]="{ exact: true }"
>
  bookmarks
</a>

धन्यवाद, इगोर। यह सबसे अच्छा उपाय है।
दिमित्री ग्रिंको

आपकी प्रतिक्रिया के लिए धन्यवाद :)
कुर्कोव इगोर

4

एक और समाधान। कोणीय राउटर V3 अल्फा में बहुत आसान है। राउटर इंजेक्ट करके

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

export class AppComponent{

    constructor(private router : Router){}

    routeIsActive(routePath: string) {
        return this.router.url == routePath;
    }
}

प्रयोग

<div *ngIf="routeIsActive('/')"> My content </div>

जैसे ही मैं इसे आयात करता हूं, मुझे एक शून्य रीड प्रॉपर्टी मिल जाती है जो 'nSkipSelf' है। कोई विचार?
atsituab

4

Angular2 RC2 में आप इस सरल कार्यान्वयन का उपयोग कर सकते हैं

<a [routerLink]="['/dashboard']" routerLinkActive="active">Dashboard</a>

यह activeमिलान किए गए url के साथ तत्व में कक्षा को जोड़ देगा , इसके बारे में अधिक यहां पढ़ें


4

नीचे अब तक जारी किए गए Angular 2 RC संस्करणों के सभी संस्करणों के लिए इस प्रश्न के उत्तर दिए गए हैं:

RC4 और RC3 :

लिंक करने के लिए कक्षा को लागू करने या लिंक के पूर्वज के लिए:

<li routerLinkActive="active"><a [routerLink]="['/home']">Home</a></li>

/ होम URL होना चाहिए और रूट का नाम नहीं होना चाहिए क्योंकि नाम संपत्ति अब राउटर ऑब्जेक्ट पर मौजूद नहीं है जैसा कि राउटर v3 है।

इस लिंक पर routerLinkActive निर्देश के बारे में अधिक ।

वर्तमान मार्ग के आधार पर किसी भी विभाग को आवेदन करने के लिए:

  • घटक के निर्माता में रूटर इंजेक्ट करें।
  • तुलना के लिए उपयोगकर्ता राऊटर।

जैसे

<nav [class.transparent]="router.url==('/home')">
</nav>

RC2 और RC1 :

राऊटर का संयोजन का उपयोग करें। RouteActive और वर्ग। *। होम रूट के आधार पर सक्रिय वर्ग को लागू करने के लिए।

नाम और यूआरएल दोनों को राउटर में भेजा जा सकता है।

 <li [class.active]="router.isRouteActive(router.generate(['Home']))">
    <a [routerLink]="['Home']" >Home</a>
</li>

4

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

@Pipe({
    name: "isRouteActive",
    pure: false
})
export class IsRouteActivePipe implements PipeTransform {

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

    transform(route: any[], options?: { queryParams?: any[], fragment?: any, exact?: boolean }) {
        if (!options) options = {};
        if (options.exact === undefined) options.exact = true;

        const currentUrlTree = this.router.parseUrl(this.router.url);
        const urlTree = this.router.createUrlTree(route, {
            relativeTo: this.activatedRoute,
            queryParams: options.queryParams,
            fragment: options.fragment
        });
        return containsTree(currentUrlTree, urlTree, options.exact);
    }
}

फिर:

<div *ngIf="['/some-route'] | isRouteActive">...</div>

और पाइप पर निर्भरता में पाइप को शामिल करने के लिए मत भूलना;)


अच्छा विचार है, लेकिन angular2.0.0rc3 में मैं इसे बदल देता हूं। aterter.isRouteActive ... इसको ._location.path () में डाल दिया और इसे ऊपर रख दिया: '@ कोणीय / आम' से {स्थान} आयात करें;
Kamil Kiełczewski

2
लगता है कि कोड से कुछ गायब है। कहाँ containsTreeपरिभाषित किया गया है?
Øystein एमंडसन

4

कोणीय संस्करण 4+ के लिए, आपको किसी भी जटिल समाधान का उपयोग करने की आवश्यकता नहीं है। आप बस उपयोग कर सकते हैं [routerLinkActive]="'is-active'"

बूटस्ट्रैप 4 नेवी लिंक के साथ एक उदाहरण के लिए:

    <ul class="navbar-nav mr-auto">
      <li class="nav-item" routerLinkActive="active">
        <a class="nav-link" routerLink="/home">Home</a>
      </li>
      <li class="nav-item" routerLinkActive="active">
        <a class="nav-link" routerLink="/about-us">About Us</a>
      </li>
      <li class="nav-item" routerLinkActive="active">
        <a class="nav-link " routerLink="/contact-us">Contact</a>
      </li>
    </ul>

3

राउटर वर्ग का एक उदाहरण वास्तव में एक अवलोकन योग्य है और यह वर्तमान मार्ग को हर बार बदल देता है। यह मेरा इसे करने का तरीका है :

export class AppComponent implements OnInit { 

currentUrl : string;

constructor(private _router : Router){
    this.currentUrl = ''
}

ngOnInit() {
    this._router.subscribe(
        currentUrl => this.currentUrl = currentUrl,
        error => console.log(error)
    );
}

isCurrentRoute(route : string) : boolean {
    return this.currentUrl === route;
 } 
}

और फिर मेरे HTML में:

<a [routerLink]="['Contact']" class="item" [class.active]="isCurrentRoute('contact')">Contact</a>

1
रूटर उदाहरण पर उपलब्ध नहीं है।
शिवांग गुप्ता

3

जैसा कि स्वीकृत उत्तर की टिप्पणियों में से एक में उल्लेख किया गया है, routerLinkActiveनिर्देश वास्तविक के एक कंटेनर पर भी लागू किया जा सकता है<a> टैग के ।

उदाहरण के लिए ट्विटर बूटस्ट्रैप टैब के साथ जहां सक्रिय वर्ग को उस <li>टैग पर लागू किया जाना चाहिए जिसमें लिंक शामिल है:

<ul class="nav nav-tabs">
    <li role="presentation" routerLinkActive="active">
        <a routerLink="./location">Location</a>
    </li>
    <li role="presentation" routerLinkActive="active">
        <a routerLink="./execution">Execution</a>
    </li>
</ul>

काफी साफ़ ! मुझे लगता है कि निर्देश टैग की सामग्री का निरीक्षण करता है और निर्देश के <a>साथ टैग की तलाश routerLinkकरता है।


2

कोणीय 5 उपयोगकर्ताओं के लिए सरल समाधान है, बस routerLinkActiveसूची आइटम में जोड़ें ।

routerLinkActive निर्देश एक मार्ग से जुड़ा होता है एक routerLinkनिर्देश के माध्यम से ।

यह इनपुट के रूप में वर्गों की एक सरणी लेता है जो इसे तत्व से जोड़ देगा यदि यह मार्ग वर्तमान में सक्रिय है, जैसे:

<li class="nav-item"
    [routerLinkActive]="['active']">
  <a class="nav-link"
     [routerLink]="['home']">Home
  </a>
</li>

उपरोक्त एंकर टैग में सक्रिय का एक वर्ग जोड़ देगा यदि हम वर्तमान में होम रूट देख रहे हैं।

डेमो


2

और कोणीय के नवीनतम संस्करण में, आप बस जांच कर सकते हैं router.isActive(routeNameAsString)। उदाहरण के लिए नीचे उदाहरण देखें:

 <div class="collapse navbar-collapse" id="navbarNav">
    <ul class="navbar-nav">
      <li class="nav-item" [class.active] = "router.isActive('/dashboard')">
        <a class="nav-link" href="#">داشبورد <span class="sr-only">(current)</span></a>
      </li>
      <li class="nav-item" [class.active] = "router.isActive(route.path)" *ngFor="let route of (routes$ | async)">
        <a class="nav-link" href="javascript:void(0)" *ngIf="route.childRoutes && route.childRoutes.length > 0"
          [matMenuTriggerFor]="menu">{{route.name}}</a>
        <a class="nav-link" href="{{route.path}}"
          *ngIf="!route.childRoutes || route.childRoutes.length === 0">{{route.name}}</a>
        <mat-menu #menu="matMenu">
          <span *ngIf="route.childRoutes && route.childRoutes.length > 0">
            <a *ngFor="let child of route.childRoutes" class="nav-link" href="{{route.path + child.path}}"
              mat-menu-item>{{child.name}}</a>
          </span>
        </mat-menu>
      </li>
    </ul>
    <span class="navbar-text mr-auto">
      <small>سلام</small> {{ (currentUser$ | async) ? (currentUser$ | async).firstName : 'کاربر' }}
      {{ (currentUser$ | async) ? (currentUser$ | async).lastName : 'میهمان' }}
    </span>
  </div>

और सुनिश्चित करें कि आप अपने घटक में राउटर को इंजेक्ट करना नहीं भूल रहे हैं।


1

मैं Angular2 के साथ एक ट्विटर बूटस्ट्रैप स्टाइल नेवी का उपयोग करने का एक तरीका तलाश रहा था, लेकिन इसे पाने में परेशानी थी active कक्षा को चयनित लिंक के मूल तत्व पर लागू करने में । पाया कि @ एलेक्स- correia-santos का समाधान पूरी तरह से काम करता है!

आपके टैब वाले घटक को राउटर को आयात करना होगा और आवश्यक कॉल करने से पहले इसे अपने कंस्ट्रक्टर में परिभाषित करना होगा।

यहाँ मेरे कार्यान्वयन का एक सरलीकृत संस्करण है ...

import {Component} from 'angular2/core';
import {Router, RouteConfig, ROUTER_DIRECTIVES} from 'angular2/router';
import {HomeComponent} from './home.component';
import {LoginComponent} from './login.component';
import {FeedComponent} from './feed.component';

@Component({
  selector: 'my-app',
  template: `
    <ul class="nav nav-tabs">
      <li [class.active]="_r.isRouteActive(_r.generate(['Home']))">
        <a [routerLink]="['Home']">Home</a>
      </li>
      <li [class.active]="_r.isRouteActive(_r.generate(['Login']))">
        <a [routerLink]="['Login']">Sign In</a>
      </li>
      <li [class.active]="_r.isRouteActive(_r.generate(['Feed']))">
        <a [routerLink]="['Feed']">Feed</a>
      </li>
    </ul>`,
  styleUrls: ['app/app.component.css'],
  directives: [ROUTER_DIRECTIVES]
})
@RouteConfig([
  { path:'/', component:HomeComponent, name:'Home', useAsDefault:true },
  { path:'/login', component:LoginComponent, name:'Login' },
  { path:'/feed', component:FeedComponent, name:'Feed' }
])
export class AppComponent {
  title = 'My App';
  constructor( private _r:Router ){}
}

1

मान लें कि आप CSS को मेरी सक्रिय स्थिति / टैब में जोड़ना चाहते हैं। अपनी रूटिंग लिंक को सक्रिय करने के लिए राऊटरलिंकएक्टिव का उपयोग करें ।

नोट: 'सक्रिय' यहाँ मेरे वर्ग का नाम है

<style>
   .active{
       color:blue;
     }
</style>

  <a routerLink="/home" [routerLinkActive]="['active']">Home</a>
  <a routerLink="/about" [routerLinkActive]="['active']">About</a>
  <a routerLink="/contact" [routerLinkActive]="['active']">Contact</a>

0

मैं कोणीय राउटर का उपयोग कर रहा हूं ^3.4.7और मुझे अभी भी routerLinkActiveनिर्देश के साथ समस्या हो रही है ।

यदि आपके पास एक ही url के साथ कई लिंक हैं तो यह काम नहीं कर रहा है और यह हर समय ताज़ा नहीं लगता है।

@Tomaszbak उत्तर से प्रेरित होकर मैंने काम करने के लिए एक छोटा घटक बनाया


0

शुद्ध html टेम्पलेट की तरह हो

 <a [routerLink]="['/home']" routerLinkActive="active">Home</a>
 <a [routerLink]="['/about']" routerLinkActive="active">About us</a>
 <a [routerLink]="['/contact']" routerLinkActive="active">Contacts</a>

0

अपने .ts में RouterLinkActive को आयात करने के साथ शुरू करें

'@ कोणीय / राउटर' से {RouterLinkActive} आयात करें;

अब अपने HTML में RouterLinkActive का उपयोग करें

<span class="" routerLink ="/some_path" routerLinkActive="class_Name">Value</span></a>

कक्षा "class_Name" के लिए कुछ सीएसएस प्रदान करें, जब यह लिंक सक्रिय / क्लिक किया जाएगा तो निरीक्षण के दौरान आपको यह वर्ग दिखाई देगा।


0

एक प्रोग्रामेटिक तरीके से इसे कंपोनेंट में ही करना होगा। मैंने इस मुद्दे पर तीन सप्ताह तक संघर्ष किया, लेकिन कोणीय डॉक्स को छोड़ दिया और वास्तविक कोड को पढ़ा जिसने राउटरलिंक के काम और थॉट्स को सबसे अच्छे डॉक्स के बारे में बताया।

    import {
  Component,AfterContentInit,OnDestroy, ViewChild,OnInit, ViewChildren, AfterViewInit, ElementRef, Renderer2, QueryList,NgZone,ApplicationRef
}
  from '@angular/core';
  import { Location } from '@angular/common';

import { Subscription } from 'rxjs';
import {
  ActivatedRoute,ResolveStart,Event, Router,RouterEvent, NavigationEnd, UrlSegment
} from '@angular/router';
import { Observable } from "rxjs";
import * as $ from 'jquery';
import { pairwise, map } from 'rxjs/operators';
import { filter } from 'rxjs/operators';
import {PageHandleService} from '../pageHandling.service'
@Component({
  selector: 'app-header',
  templateUrl: './header.component.html',
  styleUrls: ['./header.component.scss']
})




export class HeaderComponent implements AfterContentInit,AfterViewInit,OnInit,OnDestroy{

    public previousUrl: any;
    private subscription: Subscription;


      @ViewChild("superclass", { static: false } as any) superclass: ElementRef;
      @ViewChildren("megaclass") megaclass: QueryList<ElementRef>;


  constructor( private element: ElementRef, private renderer: Renderer2, private router: Router, private activatedRoute: ActivatedRoute, private location: Location, private pageHandleService: PageHandleService){
    this.subscription = router.events.subscribe((s: Event) => {
      if (s instanceof NavigationEnd) {
        this.update();
      }
    });


  }


  ngOnInit(){

  }


  ngAfterViewInit() {
  }

  ngAfterContentInit(){
  }



private update(): void {
  if (!this.router.navigated || !this.superclass) return;
      Promise.resolve().then(() => {
        this.previousUrl = this.router.url

        this.megaclass.toArray().forEach( (superclass) => {

          var superclass = superclass
          console.log( superclass.nativeElement.children[0].classList )
          console.log( superclass.nativeElement.children )

          if (this.previousUrl == superclass.nativeElement.getAttribute("routerLink")) {
            this.renderer.addClass(superclass.nativeElement.children[0], "box")
            console.log("add class")

          } else {
            this.renderer.removeClass(superclass.nativeElement.children[0], "box")
            console.log("remove class")
          }

        });
})
//update is done
}
ngOnDestroy(): void { this.subscription.unsubscribe(); }


//class is done
}

नोट :
प्रोग्रामेटिक तरीके के लिए, राउटर-लिंक जोड़ना सुनिश्चित करें और यह एक चाइल्ड एलिमेंट लेता है। यदि आप उसे बदलना चाहते हैं, तो आपको बच्चों से छुटकारा पाने की आवश्यकता है superclass.nativeElement

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