Imposta lo stile di tab attivo con AngularJS


144

Ho percorsi impostati in AngularJS in questo modo:

$routeProvider
    .when('/dashboard', {templateUrl:'partials/dashboard', controller:widgetsController})
    .when('/lab', {templateUrl:'partials/lab', controller:widgetsController})

Ho alcuni collegamenti sulla barra superiore in stile schede. Come posso aggiungere una classe "attiva" a una scheda a seconda del modello o dell'URL corrente?



4
@AminMeyghani Come si può duplicare questa domanda, che è stata posta quasi un anno dopo ?
Regent

Risposte:


274

Un modo per risolvere questo problema senza dover fare affidamento sugli URL è aggiungere un attributo personalizzato a ogni parziale durante la $routeProviderconfigurazione, come questo:

$routeProvider.
    when('/dashboard', {
        templateUrl: 'partials/dashboard.html',
        controller: widgetsController,
        activetab: 'dashboard'
    }).
    when('/lab', {
        templateUrl: 'partials/lab.html',
        controller: widgetsController,
        activetab: 'lab'
    });

Esporre $routenel controller:

function widgetsController($scope, $route) {
    $scope.$route = $route;
}

Imposta la activeclasse in base alla scheda attiva corrente:

<li ng-class="{active: $route.current.activetab == 'dashboard'}"></li>
<li ng-class="{active: $route.current.activetab == 'lab'}"></li>

3
questa è la migliore soluzione che ho visto finora perché supporta URL dinamici come / foo /: bar.
martinpaulucci,

3
in realtà non sono stato in grado di farlo funzionare. saresti in grado di fornire un plnkr?
PPPaul

9
Solo una cosa: meglio impostare in $scope.activeTab = $route.current.activetabmodo da poter mantenere l'html un po 'più pulito.
Christoph,

2
Questo non funziona in AngularJS 1.0.8. $ route.current non è definito.
Pesce gatto

2
Combina questo con il $rootScopetrucco di @Lucas qui sotto per renderlo disponibile in tutti gli ambiti.
Colllin,

134

Un modo per farlo sarebbe usare la direttiva ngClass e il servizio $ location. Nel tuo modello potresti fare:

ng-class="{active:isActive('/dashboard')}"

dove isActivesarebbe una funzione in un ambito definito come questo:

myApp.controller('MyCtrl', function($scope, $location) {
    $scope.isActive = function(route) {
        return route === $location.path();
    }
});

Ecco il jsFiddle completo: http://jsfiddle.net/pkozlowski_opensource/KzAfG/

La ripetizione ng-class="{active:isActive('/dashboard')}"su ciascuna scheda di navigazione potrebbe essere noiosa (se hai molte schede), quindi questa logica potrebbe essere candidata per una direttiva molto semplice.


1
Mi ci è voluto molto tempo prima che trovassi le 'direttive molto semplici' in realtà molto semplici da scrivere, quindi ne ho fornito una qui sotto. :-) Dovrebbe essere riutilizzabile in una varietà di contesti, senza configurazione non dichiarativa.
XML,

1
Guardando il jsFiddle, come si imposta la pagina corrente attiva al caricamento della pagina? L'esempio funziona solo quando un utente fa clic su un'opzione. Ad esempio, potresti voler evidenziare un navig 'home' quando atterra sulla homepage da un link esterno.
thathurtabit

Ahh mi ha grattato la testa per un po 'su questo. Grazie!
masterwok,

41

Seguendo il consiglio di Pavel di utilizzare una direttiva personalizzata, ecco una versione che non richiede l'aggiunta di payload a routeConfig, è super dichiarativa e può essere adattata per reagire a qualsiasi livello del percorso, semplicemente cambiando a quale slice()di essa stai prestando attenzione .

app.directive('detectActiveTab', function ($location) {
    return {
      link: function postLink(scope, element, attrs) {
        scope.$on("$routeChangeSuccess", function (event, current, previous) {
            /*  
                Designed for full re-usability at any path, any level, by using 
                data from attrs. Declare like this: 
                <li class="nav_tab">
                  <a href="#/home" detect-active-tab="1">HOME</a>
                </li> 
            */

            // This var grabs the tab-level off the attribute, or defaults to 1
            var pathLevel = attrs.detectActiveTab || 1,
            // This var finds what the path is at the level specified
                pathToCheck = $location.path().split('/')[pathLevel] || 
                  "current $location.path doesn't reach this level",
            // This var finds grabs the same level of the href attribute
                tabLink = attrs.href.split('/')[pathLevel] || 
                  "href doesn't include this level";
            // Above, we use the logical 'or' operator to provide a default value
            // in cases where 'undefined' would otherwise be returned.
            // This prevents cases where undefined===undefined, 
            // possibly causing multiple tabs to be 'active'.

            // now compare the two:
            if (pathToCheck === tabLink) {
              element.addClass("active");
            }
            else {
              element.removeClass("active");
            }
        });
      }
    };
  });

Stiamo raggiungendo i nostri obiettivi ascoltando l' $routeChangeSuccessevento, piuttosto che posizionandoli $watchsul percorso. Lavoro credendo che ciò significhi che la logica dovrebbe funzionare meno spesso, poiché penso che guardi il fuoco su ogni $digestciclo.

Invocalo passando il tuo argomento a livello di percorso sulla dichiarazione della direttiva. Questo specifica a quale blocco dell'attuale $ location.path () si desidera abbinare l' hrefattributo.

<li class="nav_tab"><a href="#/home" detect-active-tab="1">HOME</a></li>

Quindi, se le tue schede dovessero reagire al livello base del percorso, fai l'argomento '1'. Pertanto, quando location.path () è "/ home", corrisponderà a "# / home" in href. Se sono presenti schede che dovrebbero reagire al secondo livello, o al terzo o all'undicesimo del percorso, regolare di conseguenza. Questo taglio da 1 o superiore aggirerà il nefasto '#' nell'href, che vivrà all'indice 0.

L'unico requisito è che invochi su un <a>, poiché l'elemento assume la presenza di un hrefattributo, che verrà confrontato con il percorso corrente. Tuttavia, è possibile adattarsi abbastanza facilmente per leggere / scrivere un elemento genitore o figlio, se si preferisce invocare il <li>o qualcosa del genere. Lo scavo perché puoi riutilizzarlo in molti contesti semplicemente variando l'argomento pathLevel. Se la profondità da cui leggere fosse assunta nella logica, avresti bisogno di più versioni della direttiva da utilizzare con più parti della navigazione.


MODIFICA 18/03/2014: la soluzione non è stata sufficientemente generalizzata e si attiverebbe se si definisse un arg per il valore di "activeTab" restituito undefinedsia rispetto a quello $location.path()che a quello dell'elemento href. Perché: undefined === undefined. Aggiornato per correggere quella condizione.

Mentre ci lavoravo, ho capito che avrebbe dovuto esistere una versione che puoi semplicemente dichiarare su un elemento genitore, con una struttura modello come questa:

<nav id="header_tabs" find-active-tab="1">
    <a href="#/home" class="nav_tab">HOME</a>
    <a href="#/finance" class="nav_tab">Finance</a>
    <a href="#/hr" class="nav_tab">Human Resources</a>
    <a href="#/quarterly" class="nav_tab">Quarterly</a>
</nav>

Si noti che questa versione non assomiglia più in remoto a HTML in stile Bootstrap. Ma è più moderno e utilizza meno elementi, quindi sono parziale. Questa versione della direttiva, oltre all'originale, è ora disponibile su Github come modulo drop-in che puoi semplicemente dichiarare come dipendenza. Sarei felice di perderli, se qualcuno li usa davvero.

Inoltre, se vuoi una versione compatibile con bootstrap che includa quella <li>, puoi andare con il modulo Tabs angular-ui-bootstrap , che penso sia uscito dopo questo post originale e che forse è ancora più dichiarativo di questo. È meno conciso per le cose di base, ma ti offre alcune opzioni aggiuntive, come le schede disabilitate e gli eventi dichiarativi che attivano l'attivazione e la disattivazione.


4
Non potevo credere che nessuno potesse davvero votare! Ecco i miei 2 centesimi. Sebbene ci sia un piccolo errore nel codice, penso che "tabLevel" dovrebbe essere "activeTab". E per lo stile Bootstrap, potresti voler aggiungere la classe 'attiva' all'elemento LI invece dell'elemento A. Ma questo richiede solo piccoli cambiamenti.
David Lin,

1
Hai assolutamente ragione su activeTab, @DavidLin. Modificato. Ma non sono innamorato della struttura di Bootstrap, quindi una deliberata differenza lì. In effetti, sto cominciando a pensare che le astrazioni navali potrebbero non appartenere ulaffatto a, e forse dovrebbero essere solo raccolte di ancore, avvolte da uno navo altri elementi di raggruppamento. Affrontare lo strato intermedio di li"s" è una complessità aggiunta senza payoff, in particolare ora che abbiamo l' navelemento a nostra disposizione per chiarire cosa sta succedendo.
XML

Questo è semplice e geniale. Sono stato sorpreso che non ci fosse qualcosa di simile già in Angular per controllare il percorso che stai percorrendo.
Intellix,

1
Per farlo funzionare con bootstrap3, tutto ciò che devi fare è cambiare `element.addClass (" active ");` in `element.parent ('li'). AddClass (" active ");` Penso che potrebbe essere migliore chiamato però, qualcosa come is-active-tab, invece di active-tab, che sembra dichiarare che la scheda è attiva. Altrimenti, questa è una direttiva seriamente bella. Vedi questo cambiamento nella risposta di @domi
boatcoder il

La migliore soluzione in questa pagina, non posso credere che abbia così pochi voti.
Karolis,

27

@ rob-juurlink Ho migliorato un po 'la tua soluzione:

invece di ogni percorso che richiede una scheda attiva; e ho bisogno di impostare la scheda attiva in ciascun controller lo faccio:

var App = angular.module('App',[]);
App.config(['$routeProvider', function($routeProvider){
  $routeProvider.
  when('/dashboard', {
    templateUrl: 'partials/dashboard.html',
    controller: Ctrl1
  }).
  when('/lab', {
    templateUrl: 'partials/lab.html',
    controller: Ctrl2
  });
}]).run(['$rootScope', '$location', function($rootScope, $location){
   var path = function() { return $location.path();};
   $rootScope.$watch(path, function(newVal, oldVal){
     $rootScope.activetab = newVal;
   });
}]);

E l'HTML è simile a questo. Activetab è solo l'URL relativo a quella route. Questo elimina semplicemente la necessità di aggiungere codice in ciascun controller (trascinando dipendenze come $ route e $ rootScope se questo è l'unico motivo per cui vengono utilizzati)

<ul>
    <li ng-class="{active: activetab=='/dashboard'}">
       <a href="#/dashboard">dashboard</a>
    </li>
    <li ng-class="{active: activetab=='/lab'}">
       <a href="#/lab">lab</a>
    </li>
</ul>

Mille grazie per questa modifica. Molto bella. Hai qualche suggerimento per impostare una scheda attiva al primo caricamento della pagina?
Hairgami_Master

2
dipende da cosa vuoi. in genere avresti "/" l'URL come controller principale. in questo modo quando l'utente passa al tuo URL, caricherà quel controller e imposterà quella scheda come attiva. Nell'esempio sopra non ho un '/' url, quindi se questo è il tuo caso aggiungi semplicemente un .otherwise () $ routeProvider. when ('/ dashboard', {templateUrl: 'partials / dashboard.html', controller: Ctrl1}). when ('/ lab', {templateUrl: 'partials / lab.html', controller: Ctrl2}). altrimenti ({redirectTo: '/ dashboard'}); buona fortuna!
Lucas,

Mille grazie @Lucas. Questo ha aiutato. Qualche motivo per cui ho dovuto aggiungere il simbolo # al mio percorso principale quando ('# /', {controller: FormsController, templateUrl: 'partials / dashboard.html'}).
Hairgami_Master

Preferisco così. Avere un rootScope e fare qualsiasi cosa ovunque
wrivas

16

Forse una direttiva come questa potrebbe risolvere il tuo problema: http://jsfiddle.net/p3ZMR/4/

HTML

<div ng-app="link">
<a href="#/one" active-link="active">One</a>
<a href="#/two" active-link="active">One</a>
<a href="#" active-link="active">home</a>


</div>

JS

angular.module('link', []).
directive('activeLink', ['$location', function(location) {
    return {
        restrict: 'A',
        link: function(scope, element, attrs, controller) {
            var clazz = attrs.activeLink;
            var path = attrs.href;
            path = path.substring(1); //hack because path does bot return including hashbang
            scope.location = location;
            scope.$watch('location.path()', function(newPath) {
                if (path === newPath) {
                    element.addClass(clazz);
                } else {
                    element.removeClass(clazz);
                }
            });
        }

    };

}]);

1
Nota che devi usare $ observ se l'href contiene un'espressione: docs.angularjs.org/guide/directive#Attributes . Vedi violino aggiornato: jsfiddle.net/p3ZMR/10
Narretz

14

La soluzione più semplice qui:

Come impostare la classe attiva navst bootstrap con Angular JS?

Che è:

Usa ng-controller per eseguire un singolo controller al di fuori di ng-view:

<div class="collapse navbar-collapse" ng-controller="HeaderController">
    <ul class="nav navbar-nav">
        <li ng-class="{ active: isActive('/')}"><a href="/">Home</a></li>
        <li ng-class="{ active: isActive('/dogs')}"><a href="/dogs">Dogs</a></li>
        <li ng-class="{ active: isActive('/cats')}"><a href="/cats">Cats</a></li>
    </ul>
</div>
<div ng-view></div>

e includi in controllers.js:

function HeaderController($scope, $location) 
{ 
    $scope.isActive = function (viewLocation) { 
        return viewLocation === $location.path();
    };
}

2
d'accordo, di gran lunga il più semplice
AngeloS

12

Consiglio di utilizzare il modulo state.ui che non solo supporta viste multiple e nidificate, ma rende anche questo tipo di lavoro molto semplice (codice sotto citato):

<ul class="nav">
    <li ng-class="{ active: $state.includes('contacts') }"><a href="#{{$state.href('contacts')}}">Contacts</a></li>
    <li ng-class="{ active: $state.includes('about') }"><a href="#{{$state.href('about')}}">About</a></li>
</ul>

Vale la pena leggere.


4

Ecco un'altra versione di XMLillies con la modifica LI di domi che utilizza una stringa di ricerca anziché un livello di percorso. Penso che questo sia un po 'più ovvio cosa sta succedendo per il mio caso d'uso.

statsApp.directive('activeTab', function ($location) {
  return {
    link: function postLink(scope, element, attrs) {
      scope.$on("$routeChangeSuccess", function (event, current, previous) {
        if (attrs.href!=undefined) { // this directive is called twice for some reason
          // The activeTab attribute should contain a path search string to match on.
          // I.e. <li><a href="#/nested/section1/partial" activeTab="/section1">First Partial</a></li>
          if ($location.path().indexOf(attrs.activeTab) >= 0) {
            element.parent().addClass("active");//parent to get the <li>
          } else {
            element.parent().removeClass("active");
          }
        }
      });
    }
  };
});

HTML ora assomiglia a:

<ul class="nav nav-tabs">
  <li><a href="#/news" active-tab="/news">News</a></li>
  <li><a href="#/some/nested/photos/rawr" active-tab="/photos">Photos</a></li>
  <li><a href="#/contact" active-tab="/contact">Contact</a></li>
</ul>

3

Ho trovato la risposta di XMLilley la migliore, la più adattabile e non invadente.

Tuttavia ho avuto un piccolo problema tecnico.

Per l'uso con bootstrap nav, ecco come l'ho modificato:

app.directive('activeTab', function ($location) {
    return {
      link: function postLink(scope, element, attrs) {
        scope.$on("$routeChangeSuccess", function (event, current, previous) {
            /*  designed for full re-usability at any path, any level, by using 
                data from attrs
                declare like this: <li class="nav_tab"><a href="#/home" 
                                   active-tab="1">HOME</a></li> 
            */
            if(attrs.href!=undefined){// this directive is called twice for some reason
                // this var grabs the tab-level off the attribute, or defaults to 1
                var pathLevel = attrs.activeTab || 1,
                // this var finds what the path is at the level specified
                    pathToCheck = $location.path().split('/')[pathLevel],
                // this var finds grabs the same level of the href attribute
                    tabLink = attrs.href.split('/')[pathLevel];
                // now compare the two:
                if (pathToCheck === tabLink) {
                  element.parent().addClass("active");//parent to get the <li>
                }
                else {
                  element.parent().removeClass("active");
                }
            }
        });
      }
    };
  });

Ho aggiunto "if (attrs.href! = Undefined)" perché questa funzione viene chiamata in modo apprendente due volte, la seconda volta produce un errore.

Per quanto riguarda l'html:

<ul class="nav nav-tabs">
   <li class="active" active-tab="1"><a href="#/accueil" active-tab="1">Accueil</a></li>
   <li><a active-tab="1" href="#/news">News</a></li>
   <li><a active-tab="1" href="#/photos" >Photos</a></li>
   <li><a active-tab="1" href="#/contact">Contact</a></li>
</ul>

nvm, è stata colpa mia se è stato chiamato due volte. Suppongo che "if (attrs.href! = Undefined)" non è necessario.
domi,

3

Esempio Bootstrap.

Se si utilizza il routing incorporato angolare (ngview), è possibile utilizzare questa direttiva:

angular.module('myApp').directive('classOnActiveLink', [function() {
    return {
        link: function(scope, element, attrs) {

            var anchorLink = element.children()[0].getAttribute('ng-href') || element.children()[0].getAttribute('href');
            anchorLink = anchorLink.replace(/^#/, '');

            scope.$on("$routeChangeSuccess", function (event, current) {
                if (current.$$route.originalPath == anchorLink) {
                    element.addClass(attrs.classOnActiveLink);
                }
                else {
                    element.removeClass(attrs.classOnActiveLink);
                }
            });

        }
    };
}]);

Supponendo che il tuo markup assomigli a questo:

    <ul class="nav navbar-nav">
        <li class-on-active-link="active"><a href="/orders">Orders</a></li>
        <li class-on-active-link="active"><a href="/distributors">Distributors</a></li>
    </ul>

Mi piace che lo facessi perché puoi impostare il nome della classe che desideri nel tuo attributo.


2

Puoi anche semplicemente inserire la posizione nell'ambito e usarla per dedurre lo stile per la navigazione:

function IndexController( $scope, $rootScope, $location ) {
  $rootScope.location = $location;
  ...
}

Quindi usalo nel tuo ng-class:

<li ng-class="{active: location.path() == '/search'}">
  <a href="/search">Search><a/>
</li>

non dovrebbe essere $ root.location.path () nel markup?
Irshu,

@Irshu: Potrebbe essere più pulito, ma l'approccio sopra ha funzionato anche per me.
Der Hochstapler,

2

un modo alternativo è usare ui-sref-active

Una direttiva che lavora a fianco di ui-sref per aggiungere classi a un elemento quando il relativo stato della direttiva ui-sref è attivo e rimuoverle quando è inattivo. Il caso d'uso principale è semplificare l'aspetto speciale dei menu di navigazione basandosi su ui-sref, facendo apparire il pulsante di menu dello stato "attivo" in modo diverso, distinguendolo dalle voci di menu inattive.

Uso:

ui-sref-active = 'class1 class2 class3' - le classi "class1", "class2" e "class3" vengono ciascuna aggiunte all'elemento direttiva quando il relativo stato di ui-sref è attivo e rimosse quando è inattivo.

Esempio:
dato il seguente modello,

<ul>
  <li ui-sref-active="active" class="item">
    <a href ui-sref="app.user({user: 'bilbobaggins'})">@bilbobaggins</a>
  </li>
  <!-- ... -->
</ul>

quando lo stato dell'app è "app.user" e contiene il parametro state "user" con valore "bilbobaggins", l'HTML risultante verrà visualizzato come

<ul>
  <li ui-sref-active="active" class="item active">
    <a ui-sref="app.user({user: 'bilbobaggins'})" href="/users/bilbobaggins">@bilbobaggins</a>
  </li>
  <!-- ... -->
</ul>

Il nome della classe viene interpolato una volta durante il tempo di collegamento delle direttive (eventuali ulteriori modifiche al valore interpolato vengono ignorate). È possibile specificare più classi in un formato separato da spazi.

Utilizzare la direttiva ui-sref-opts per passare le opzioni a $ state.go (). Esempio:

<a ui-sref="home" ui-sref-opts="{reload: true}">Home</a>

Grazie. È davvero utile quando si lavora in una struttura ionica!
Avijit Gupta,

1

Sono d'accordo con il post di Rob sull'avere un attributo personalizzato nel controller. Apparentemente non ho abbastanza rappresentante per commentare. Ecco il jsfiddle che è stato richiesto:

HTML di esempio

<div ng-controller="MyCtrl">
    <ul>
        <li ng-repeat="link in links" ng-class="{active: $route.current.activeNav == link.type}"> <a href="{{link.uri}}">{{link.name}}</a>

        </li>
    </ul>
</div>

app.js di esempio

angular.module('MyApp', []).config(['$routeProvider', function ($routeProvider) {
    $routeProvider.when('/a', {
        activeNav: 'a'
    })
        .when('/a/:id', {
        activeNav: 'a'
    })
        .when('/b', {
        activeNav: 'b'
    })
        .when('/c', {
        activeNav: 'c'
    });
}])
    .controller('MyCtrl', function ($scope, $route) {
    $scope.$route = $route;
    $scope.links = [{
        uri: '#/a',
        name: 'A',
        type: 'a'
    }, {
        uri: '#/b',
        name: 'B',
        type: 'b'
    }, {
        uri: '#/c',
        name: 'C',
        type: 'c'
    }, {
        uri: '#/a/detail',
        name: 'A Detail',
        type: 'a'
    }];
});

http://jsfiddle.net/HrdR6/


Mi piace l'approccio basato sui dati all'elenco dei collegamenti. E alcuni potrebbero scegliere di spostare la matrice di collegamenti in un servizio / fabbrica.
Grant Lindsay,

1
'use strict';

angular.module('cloudApp')
  .controller('MenuController', function ($scope, $location, CloudAuth) {
    $scope.menu = [
      {
        'title': 'Dashboard',
        'iconClass': 'fa fa-dashboard',
        'link': '/dashboard',
        'active': true
      },
      {
        'title': 'Devices',
        'iconClass': 'fa fa-star',
        'link': '/devices'
      },
      {
        'title': 'Settings',
        'iconClass': 'fa fa-gears',
        'link': '/settings'
      }
    ];
    $location.path('/dashboard');
    $scope.isLoggedIn = CloudAuth.isLoggedIn;
    $scope.isAdmin = CloudAuth.isAdmin;
    $scope.isActive = function(route) {
      return route === $location.path();
    };
  });

E usa il seguente nel modello:

<li role="presentation" ng-class="{active:isActive(menuItem.link)}" ng-repeat="menuItem in menu"><a href="{{menuItem.link}}"><i class="{{menuItem.iconClass}}"></i>&nbsp;&nbsp;{{menuItem.title}}</a></li>

0

Avevo bisogno di una soluzione che non richiedesse modifiche ai controller, perché per alcune pagine visualizziamo solo modelli e non esiste alcun controller. Grazie ai precedenti commentatori che avevano suggerito di usare $routeChangeSuccessmi sono inventato qualcosa del genere:

# Directive
angular.module('myapp.directives')
.directive 'ActiveTab', ($route) ->
  restrict: 'A'

  link: (scope, element, attrs) ->
    klass = "active"

    if $route.current.activeTab? and attrs.flActiveLink is $route.current.activeTab
      element.addClass(klass)

    scope.$on '$routeChangeSuccess', (event, current) ->
      if current.activeTab? and attrs.flActiveLink is current.activeTab
        element.addClass(klass)
      else
        element.removeClass(klass)

# Routing
$routeProvider
.when "/page",
  templateUrl: "page.html"
  activeTab: "page"
.when "/other_page",
  templateUrl: "other_page.html"
  controller: "OtherPageCtrl"
  activeTab: "other_page"

# View (.jade)
a(ng-href='/page', active-tab='page') Page
a(ng-href='/other_page', active-tab='other_page') Other page

Non dipende dagli URL e quindi è davvero facile configurarlo per qualsiasi sottopagina ecc.


0

Non ricordo dove ho trovato questo metodo, ma è piuttosto semplice e funziona bene.

HTML:

<nav role="navigation">
    <ul>
        <li ui-sref-active="selected" class="inactive"><a ui-sref="tab-01">Tab 01</a></li> 
        <li ui-sref-active="selected" class="inactive"><a ui-sref="tab-02">Tab 02</a></li>
    </ul>
</nav>

CSS:

  .selected {
    background-color: $white;
    color: $light-blue;
    text-decoration: none;
    border-color: $light-grey;
  } 

0

Se stai utilizzando ngRoute (per il routing), l'applicazione avrà una configurazione inferiore,

angular
  .module('appApp', [
    'ngRoute'
 ])
config(function ($routeProvider) {
    $routeProvider
      .when('/', {
        templateUrl: 'views/main.html',
        controller: 'MainCtrl',
        controllerAs: 'main'
      })
      .when('/about', {
        templateUrl: 'views/about.html',
        controller: 'AboutCtrl',
        controllerAs: 'about'
      })
}
});

Ora, aggiungi un controller in questa configurazione proprio come sotto,

angular
      .module('appApp', [
        'ngRoute'
     ])
    config(function ($routeProvider) {
        $routeProvider
          .when('/', {
            templateUrl: 'views/main.html',
            controller: 'MainCtrl',
            activetab: 'main'
          })
          .when('/about', {
            templateUrl: 'views/about.html',
            controller: 'AboutCtrl',
            activetab: 'about'
          })
    }
    })
  .controller('navController', function ($scope, $route) {
    $scope.$route = $route;
  });

Come hai menzionato la scheda attiva nella tua configurazione, ora devi solo aggiungere una classe attiva nel tuo tag <li>o <a>. Piace,

ng-class="{active: $route.current.activetab == 'about'}"

Ciò significa che, ogni volta che l'utente fa clic sulla pagina, questo identificherà automaticamente la scheda corrente e applicherà la classe CSS attiva.

Spero che aiuti!


-3

Sono venuto qui per la soluzione .. anche se le soluzioni di cui sopra funzionano bene ma le hanno trovate un po 'complesse non necessarie. Per le persone che sono ancora alla ricerca di una soluzione semplice e pulita, svolgerà perfettamente il loro compito.

<section ng-init="tab=1">
                <ul class="nav nav-tabs">
                    <li ng-class="{active: tab == 1}"><a ng-click="tab=1" href="#showitem">View Inventory</a></li>
                    <li ng-class="{active: tab == 2}"><a ng-click="tab=2" href="#additem">Add new item</a></li>
                    <li ng-class="{active: tab == 3}"><a ng-click="tab=3" href="#solditem">Sold item</a></li>
                </ul>
            </section>
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.