Skip to content

AngularJS Spickzettel

JavaScript-basiertes Front-End-Web-Framework (Angular 1.x).

01

Einstieg

Setup & Bootstrap

AngularJS (1.x) wird über ein script-Tag eingebunden. ng-app bootstrapt die Anwendung und ng-controller verdrahtet einen Controller mit einem DOM-Teilbaum. Die doppelten geschweiften Klammern {{ }} sind Angular-Ausdrücke, die Modelldaten rendern.

angularjs
<!-- include AngularJS 1.8.x -->
<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.8.2/angular.min.js"></script>

<body ng-app="myApp">
  <div ng-controller="MainCtrl">
    {{ message }}
  </div>
</body>

<script>
  var app = angular.module('myApp', []);
  app.controller('MainCtrl', function($scope) {
    $scope.message = 'Hello AngularJS!';
  });
</script>

ng-app & Auto-Bootstrap

ng-app mit einem Modulnamen bootstrapt AngularJS automatisch bei DOMContentLoaded. ng-strict-di erzwingt explizite Dependency-Annotations und fängt Minification-Bugs früh in der Entwicklung. Nur ein ng-app pro Seite wird automatisch gebootstrapt.

angularjs
<!-- ng-app on <html> makes the whole page an Angular app -->
<html ng-app="myApp" ng-strict-di>
  <head><title>App</title></head>
  <body>
    <div>{{ 1 + 2 }}</div>
  </body>
</html>

<!-- ng-strict-di enforces dependency injection annotations -->
<!-- (errors if a service uses implicit DI without annotation) -->

Manueller Bootstrap

angular.bootstrap() verwenden, wenn der Start verzögert werden soll (z. B. Warten auf asynchrones Modul-Laden oder eine abgerufene Konfiguration). So lassen sich mehrere Angular-Apps auf einer Seite betreiben, jeweils auf ihrem eigenen Root-Element.

angularjs
<!-- HTML has NO ng-app attribute -->
<div id="appRoot">
  {{ message }}
</div>

<script>
  angular.element(document).ready(function() {
    angular.bootstrap(document.getElementById('appRoot'), ['myApp']);
  });
</script>

Erste Datenbindung

Mit ng-app ohne Modulnamen läuft Angular im 'auto'-Modus mit dem Default-ng-Modul. ng-model bindet das Eingabefeld an eine Eigenschaft namens 'name' auf dem impliziten Scope, und {{ }} rendert sie live. Das ist Two-Way-Data-Binding in seiner einfachsten Form.

angularjs
<div ng-app>
  <label>Your name:
    <input type="text" ng-model="name">
  </label>
  <p>Hello {{ name || 'stranger' }}!</p>
</div>

Modul- & Controller-Grundlagen

angular.module('name', [deps]) erzeugt ein Modul; angular.module('name') holt ein bestehendes. Die Inline-Array-Annotation ['$scope', function($scope){}] hält den Controller minification-safe. Beim Erzeugen immer die Dependencies explizit an das Modul übergeben.

angularjs
var app = angular.module('myApp', []); // create module
//          ^name   ^dependencies

app.controller('GreetCtrl', ['$scope', function($scope) {
  $scope.user = { name: 'Ada' };
  $scope.greet = function() {
    return 'Hi ' + $scope.user.name;
  };
}]);
02

Module

Modul erzeugen vs. abrufen

Die Zwei-Argument-Form angular.module(name, deps) erzeugt ein neues Modul. Die Ein-Argument-Form angular.module(name) holt ein zuvor definiertes. Wird versehentlich zweimal [] übergeben, löscht das stillschweigend die Registrierungen des Moduls.

angularjs
// CREATE a module (second arg = dependency array)
var app = angular.module('myApp', []);

// RETRIEVE an existing module (NO second arg)
// var app = angular.module('myApp');

// common mistake: passing [] again overwrites the module

Modul-Dependencies

Das Dependency-Array listet Module, deren Provider in dieses injiziert werden. Eingebaute Module wie ngRoute sind optional und müssen explizit gelistet werden (mit geladenem Script). Sub-Module erlauben es, eine große App in wiederverwendbare Teile zu zerlegen.

angularjs
var app = angular.module('myApp', [
  'ngRoute',          // built-in routing
  'ngAnimate',        // animation hooks
  'ui.router',        // 3rd-party router
  'myApp.common',     // your own sub-module
]);

Config-Block

config() läuft während der Provider-Registrierung, bevor irgendeine Service-Instanz erzeugt wird. Es ist der einzige Ort, an dem Providers injiziert und konfiguriert werden können (z. B. $routeProvider, $locationProvider). Damit Routen einrichten, HTML5-Modus aktivieren oder eigene Validatoren registrieren.

angularjs
app.config(['$routeProvider', function($routeProvider) {
  $routeProvider
    .when('/home', { templateUrl: 'home.html' })
    .when('/about', { templateUrl: 'about.html' })
    .otherwise({ redirectTo: '/home' });
}]);

Run-Block

run() läuft nach dem Erzeugen des Injectors und der Konfiguration aller Provider — der 'main'-Einsprungpunkt der App. Instanzen injizieren (keine Provider). Üblich ist das Registrieren globaler $rootScope-Listener für Routenwechsel oder Auth-Checks.

angularjs
app.run(['$rootScope', 'AuthService', function($rootScope, AuthService) {
  $rootScope.$on('$routeChangeStart', function(event, next) {
    if (!AuthService.isAuthenticated()) {
      event.preventDefault();
    }
  });
}]);

Constants & Values

constant() registriert einen Wert, der auch in config()-Blöcke injizierbar ist — ideal für Konfiguration, die Provider brauchen. value() ist nur in Run-Phase-Konstrukte injizierbar (Services, Controller). constant für Konfiguration, die früh verfügbar sein muss.

angularjs
// constant: available in BOTH config and run phases
app.constant('API_BASE', 'https://api.example.com');

// value: available only in run phase (injectable as instance)
app.value('defaultPageSize', 20);

// usage in a service:
app.factory('UserSvc', ['API_BASE', function(API_BASE) {
  return { all: function() { /* use API_BASE */ } };
}]);
03

Controller

Einfacher Controller

Controller setzen den Anfangszustand von $scope und ergänzen Verhalten (Funktionen). Controller schlank halten — Geschäftslogik gehört in Services. Der Controller-Konstruktor läuft bei jedem Bedarf einer neuen Controller-Instanz (z. B. je ng-controller-Verwendung).

angularjs
app.controller('TodoCtrl', ['$scope', function($scope) {
  $scope.todos = [
    { text: 'Learn AngularJS', done: true },
    { text: 'Build an app', done: false }
  ];

  $scope.addTodo = function() {
    $scope.todos.push({ text: $scope.todoText, done: false });
    $scope.todoText = '';
  };

  $scope.remaining = function() {
    return $scope.todos.filter(function(t) { return !t.done; }).length;
  };
}]);

controllerAs-Syntax

controllerAs publiziert die Controller-Instanz unter einem Alias (main) auf dem Scope. Statt $scope für Eigenschaften und Methoden this verwenden. Das vermeidet Fallstricke der $scope-Vererbung und macht explizit, aus welchem Controller eine Eigenschaft in verschachtelten Views stammt.

angularjs
<div ng-controller="MainCtrl as main">
  <p>{{ main.title }}</p>
  <button ng-click="main.save()">Save</button>
</div>

<script>
app.controller('MainCtrl', function() {
  this.title = 'Controller As';
  this.save = function() { /* ... */ };
});
</script>

Minification-sichere DI

Minifier benennen Funktionsparameter um und brechen so Angulars namensbasierte Dependency-Erkennung. Die Inline-Array-Annotation listet die Service-Namen als Strings vor der Funktion, damit die Namen die Minification überstehen. Immer diese Annotation oder ng-annotate / $inject verwenden.

angularjs
// SAFE: inline array annotation (parameter names are string literals)
app.controller('SafeCtrl', ['$scope', '$http', function($scope, $http) {
  $http.get('/api/items').then(function(res) { $scope.items = res.data; });
}]);

// UNSAFE: implicit DI breaks when minified
app.controller('UnsafeCtrl', function($scope, $http) { /* ... */ });

$inject-Eigenschafts-Annotation

Eine Alternative zum Inline-Array: ein $inject-Array mit Service-Namen an die Konstruktorfunktion hängen. Das hält die Funktionsdeklaration lesbar und wiederverwendbar. Beide Stile sind äquivalent — einen wählen und konsistent bleiben (oder mit ng-annotate automatisieren).

angularjs
function UserCtrl($scope, UserService) {
  UserService.list().then(function(users) {
    $scope.users = users;
  });
}
// explicit dependency list on the function
UserCtrl.$inject = ['$scope', 'UserService'];

app.controller('UserCtrl', UserCtrl);

Verschachtelte Controller & Vererbung

Kind-Scopes erben prototypisch von Eltern-Scopes, daher liest ein Kind-Controller Eltern-Eigenschaften. Eine Zuweisung eines Primitivs auf dem Kind erzeugt aber eine neue lokale Eigenschaft, die die Eltern-Eigenschaft überdeckt statt sie zu aktualisieren — häufiger Stolperstein. Objekte (Punktnotation) oder controllerAs bevorzugen.

angularjs
<div ng-controller="ParentCtrl">
  <p>{{ shared }}</p>      <!-- sees parent's 'shared' -->
  <div ng-controller="ChildCtrl">
    <p>{{ shared }}</p>    <!-- inherits, can shadow -->
    <p>{{ childOnly }}</p>
  </div>
</div>

app.controller('ParentCtrl', ['$scope', function($scope) {
  $scope.shared = 'from parent';
}]);
app.controller('ChildCtrl', ['$scope', function($scope) {
  $scope.childOnly = 'child only';
  $scope.shared = 'overridden by child'; // shadows parent
}]);

Controller-Aufräumen ($destroy)

Auf $scope das $destroy-Ereignis lauschen, um beim Abbauen des Controller-Scopes aufzuräumen (z. B. beim Wegnavigieren). $interval/$timeout-Timer canceln, window/listener entbinden und Referenzen freigeben, um Memory-Leaks zu verhindern. Angular räumt seine eigenen Scope-Watcher automatisch auf.

angularjs
app.controller('TimerCtrl', ['$scope', '$interval', function($scope, $interval) {
  var timer = $interval(function() { $scope.now = Date.now(); }, 1000);

  $scope.$on('$destroy', function() {
    $interval.cancel(timer); // free the resource
  });
}]);
04

$scope

$scope-Grundlagen

$scope ist der Klebstoff zwischen Controller und View — er hält das Modell und das Verhalten, an das das Template bindet. Angular erzeugt für jeden Controller einen neuen Scope; Ausdrücke im Template werden gegen diesen Scope (und seine Eltern) ausgewertet.

angularjs
app.controller('MsgCtrl', ['$scope', function($scope) {
  $scope.message = 'Hi';          // model on scope
  $scope.count = 0;
  $scope.inc = function() {
    $scope.count++;
  };
}]);

// In HTML: {{ message }}, {{ count }}, ng-click="inc()"

Scope-Vererbung (prototypisch)

Kind-Scopes erben über die JavaScript-Prototypenkette vom Eltern-Scope. Das Lesen einer Eltern-Eigenschaft funktioniert, aber das Zuweisen eines Primitivs (z. B. $scope.name = 'x') auf dem Kind erzeugt eine lokale Kopie, die den Elternwert überdeckt. An Objekte binden (user.name), damit Schreibzugriffe die Kette hinauf propagieren.

angularjs
<!-- primitive on parent: child writes a NEW copy -->
<div ng-controller="ParentCtrl">
  <div ng-controller="ChildCtrl">
    <input ng-model="name"> <!-- shadows parent.name -->
  </div>
</div>

<!-- object avoids the shadowing gotcha -->
app.controller('ParentCtrl', ['$scope', function($scope) {
  $scope.user = { name: 'Ada' }; // child edits user.name -> updates parent
}]);

$rootScope

$rootScope ist die Spitze der Scope-Hierarchie; jeder andere Scope stammt davon ab. Hier abgelegte Eigenschaften sind in allen Templates sichtbar. Sparsam für wirklich globale Werte einsetzen (App-Name, Session-Flag) — Übergebrauch erzeugt versteckte Kopplung und macht Zustand schwer nachvollziehbar.

angularjs
app.run(['$rootScope', function($rootScope) {
  $rootScope.appName = 'MyApp';     // available everywhere
  $rootScope.version = '1.0';
}]);

<!-- any template -->
<footer>© {{ appName }} {{ version }}</footer>

Scope-Events: $emit / $broadcast / $on

$emit feuert ein Ereignis, das nach oben zu $rootScope wandert; $broadcast wandert nach unten zu allen Kind-Scopes. $on registriert einen Listener und gibt eine Deregistrierungsfunktion zurück. Daten über das zweite Argument übergeben. Listener bei $destroy entbinden, um Leaks zu vermeiden.

angularjs
// travel UP toward $rootScope
$scope.$emit('userLoggedOut', { userId: 7 });

// travel DOWN to all descendant scopes
$scope.$broadcast('itemAdded', { id: 99 });

// listen for an event
var unbind = $scope.$on('itemAdded', function(event, args) {
  console.log('item', args.id);
});
// stop listening when scope is destroyed
$scope.$on('$destroy', unbind);

$new, $id, $parent

$new(isolated, parent) erzeugt einen Kind-(oder Isolate-)Scope; $id ist eine eindeutige numerische id; $parent referenziert den Eltern-Scope. Diese werden meist in Directives verwendet. Manuell erzeugte Scopes immer mit $destroy() zerstören, um Watcher zu entfernen und Memory-Leaks zu vermeiden.

angularjs
var child = $scope.$new();        // create a child scope
child.extra = 'child data';
console.log(child.$id);          // unique scope id
console.log(child.$parent === $scope); // true
// ...
child.$destroy();                // remove from hierarchy

Isolate-Scope (Direktiven-Vorschau)

scope: {} in einer Directive erzeugt einen isolate scope, der NICHT prototypisch vom Eltern-Scope erbt — unverzichtbar für wiederverwendbare Komponenten. Der Eltern-Scope kommuniziert nur über deklarierte Bindings (@, =, &). Das verhindert, dass Komponenten versehentlich den umgebenden Scope lesen oder verschmutzen.

angularjs
app.directive('userCard', function() {
  return {
    scope: {              // ISOLATE scope: does NOT inherit parent
      user: '=',          // two-way binding
      onKick: '&'         // expression binding
    },
    template: '<p>{{ user.name }}</p>'
  };
});

<!-- usage -->
<user-card user="currentUser" on-kick="removeUser()"></user-card>
05

Ausdrücke

Grundlegende Ausdrücke

Angular-Ausdrücke ähneln JavaScript, werden aber gegen $scope ausgewertet (nicht window). Sie unterstützen Arithmetik, String-Verkettung, Member-Zugriff und Ternaries. Anders als JS zeigen undefined/null als leeren String (kein 'undefined'-Text). Der Optional-Chaining-Operator wird NICHT unterstützt.

angularjs
<p>{{ 1 + 2 }}</p>                <!-- 3 -->
<p>{{ 'Hello, ' + name }}</p>
<p>{{ user.name }}</p>
<p>{{ items.length }} items</p>
<p>{{ obj?.nested }}</p>           <!-- AngularJS does NOT support ?. -->

Ausdruck vs. JavaScript

Ausdrücke sind eingeschränkter als JS: keine Statements (if/for/while), kein new/throw, keine Kommas, keine Funktionsdefinitionen, auf manchen Versionen kein Bitwise. Sie werden mit $scope als Kontext ausgewertet und schlucken Fehler stillschweigend (geloggt als $exceptionHandler). Das hält das Template sicher und deklarativ.

angularjs
<!-- ALLOWED in expressions -->
{{ a + b }}
{{ cond ? 'yes' : 'no' }}
{{ user.getName() }}
{{ [1,2,3].length }}

<!-- NOT allowed: control flow, new, throw, comma operator -->
{{ if (x) { ... } }}     <!-- SyntaxError -->
{{ throw new Error() }}  <!-- not allowed -->

One-time-Binding (::)

Das ::-Präfix erzeugt ein one-time binding: Angular wertet den Ausdruck aus und entfernt den Watcher, sobald der Wert definiert (nicht-undefined) ist. Das reduziert die Watcher-Zahl im Digest-Zyklus drastisch und verbessert die Performance für Daten, die nach dem ersten Laden nicht mehr ändern.

angularjs
<!-- AngularJS 1.3+ -->
<p>{{ ::user.name }}</p>           <!-- evaluated once, then unwatched -->
<li ng-repeat="item in ::items">{{ ::item.label }}</li>

<!-- good for static data that never changes -->
<h1>{{ ::conferenceTitle }}</h1>

$eval und $parse

$scope.$eval(expr) parst und führt einen Ausdrucks-String gegen den Scope aus. $parse kompiliert einen Ausdruck einmalig in eine wiederverwendbare Getter/Setter-Funktion — viel effizienter als ein String, der immer wieder ausgewertet wird. $parse in Directives/Services verwenden, die Ausdrucks-Bindings konsumieren.

angularjs
// evaluate an expression against $scope
var result = $scope.$eval('1 + 2 * count');   // 1 + 2*count
// $scope.$eval(expr, locals)

// compile once, reuse: more efficient for repeated eval
var getter = $parse('user.name');
var name = getter($scope);
getter.assign($scope, 'Ada'); // two-way: sets user.name

Filter in Ausdrücken

Das Pipe-Zeichen | wendet einen Filter auf den Ausdruck an; mehrere Filter verketten sich links nach rechts. Argumente werden mit Doppelpunkt übergeben. Filter sind bequem, laufen aber bei jedem Digest neu — bei großen Listen im Controller über $filter oder eine berechnete Eigenschaft filtern.

angularjs
<p>{{ price | currency }}</p>             <!-- $1.99 -->
<p>{{ today | date:'yyyy-MM-dd' }}</p>    <!-- 2025-01-01 -->
<p>{{ name | uppercase }}</p>
<p>{{ items | filter:query | orderBy:'name' }}</p>

<!-- chained with |, arguments after : -->

ng-bind & ng-cloak

Bevor Angular bootstrapt, zeigt der Browser rohen {{ }}-Text ('flash of uncompiled content'). ng-bind schreibt den Wert erst nach Angulars Start in den Text des Elements und vermeidet das Aufblitzen. ng-cloak mit einer CSS-Regel versteckt Elemente, bis Angular sie kompiliert hat.

angularjs
<!-- raw {{ }} may flash before Angular compiles -->
<p>{{ message }}</p>

<!-- ng-bind avoids the flash -->
<p ng-bind="message"></p>

<!-- ng-cloak hides elements until compiled -->
<style>[ng-cloak] { display: none; }</style>
<p ng-cloak>{{ message }}</p>
06

Eingebaute Directives

ng-model (Two-Way-Binding)

ng-model bindet Formular-Eingaben mit Zweisynchronisation an eine Scope-Eigenschaft: Eingabeänderungen aktualisieren das Modell, Modelländerungen das Eingabefeld. Funktioniert auf input, textarea, select und checkbox/radio. Immer an eine gepunktete Eigenschaft binden (user.name), um Primitive-Shadowing zu vermeiden.

angularjs
<input type="text" ng-model="user.name">
<p>Hello, {{ user.name }}</p>

<!-- checkbox binds to boolean -->
<input type="checkbox" ng-model="agree"> I agree

<!-- select binds the chosen option's value -->
<select ng-model="color">
  <option value="r">Red</option>
  <option value="g">Green</option>
</select>

ng-repeat

ng-repeat klont das Element für jedes Element einer Sammlung. $index, $first, $last, $middle, $even, $odd sind verfügbar. Immer track by verwenden, um Angular eine stabile Identität zu geben, damit es DOM-Knoten wiederverwenden kann, wenn sich das Array ändert — das verhindert vollständiges Re-Rendering und behebt duplicate-key-Fehler.

angularjs
<ul>
  <li ng-repeat="item in items track by item.id">
    {{ $index }}: {{ item.name }}
    <span ng-if="$first">(first)</span>
    <span ng-if="$last">(last)</span>
  </li>
</ul>

<!-- ng-repeat over object -->
<li ng-repeat="(key, value) in config">{{ key }} = {{ value }}</li>

ng-if / ng-show / ng-hide

ng-if fügt das Element (und seine Kind-Scopes) bedingt in das DOM ein bzw. entfernt es — teuer beim Umschalten, billig wenn versteckt. ng-show/ng-hide kippen nur eine CSS-Klasse und behalten das Element im DOM — billig beim Umschalten, aber das Element ist immer kompiliert. ng-if für selten gezeigte Inhalte bevorzugen.

angularjs
<!-- ng-if: removes/adds element from DOM -->
<div ng-if="user.isAdmin">Admin tools</div>

<!-- ng-show/ng-hide: toggles display:none only -->
<div ng-show="isLoading">Loading...</div>
<div ng-hide="isLoggedIn">Please log in</div>

ng-class & ng-style

ng-class akzeptiert ein Objekt (truthy Keys werden Klassen), ein Array von Klassennamen oder einen String. ng-style nimmt ein Objekt, das CSS-Eigenschaftsnamen auf Werte mappt. Beide werten bei jedem Digest neu aus — für statisches Styling lieber ein normales class-Attribut; diese für zustandsgetriebenes Styling.

angularjs
<!-- object form: keys are classes, truthy values apply them -->
<div ng-class="{ active: tab === 1, disabled: !enabled }"></div>

<!-- array form -->
<div ng-class="[styleA, styleB]"></div>

<!-- ng-style: object of CSS properties -->
<div ng-style="{ color: theme.color, 'font-size': theme.size + 'px' }">
  Styled text
</div>

ng-bind-template & ng-init

ng-bind-template bindet mehrere Ausdrücke an den Text eines Elements, ohne rohe {{ }}. ng-init wertet einen Ausdruck einmalig bei der Initialisierung des Elements aus — praktisch für Demos, aber in echten Apps unüblich, weil es Logik ins Markup legt. Anfangszustand im Controller setzen.

angularjs
<!-- bind multiple expressions to text -->
<p ng-bind-template="Hello {{ first }} {{ last }}"></p>

<!-- ng-init: set a local (use sparingly, prefer controller) -->
<div ng-init="qty = 1; cost = 5">
  Total: {{ qty * cost }}
</div>

ng-src / ng-href / ng-disabled

ng-src und ng-href statt src='{{ }}' verwenden, damit der Browser keine Anfrage gegen die wörtliche '{{ }}'-URL stellt, bevor Angular sie interpoliert. ng-disabled schaltet das disabled-Attribut anhand eines Ausdrucks — perfekt, um Submit-Buttons bei ungültigem Formular oder laufender Anfrage zu deaktivieren.

angularjs
<!-- avoid broken requests before binding resolves -->
<img ng-src="{{ user.avatarUrl }}" alt="avatar">
<a ng-href="{{ profileUrl }}">Profile</a>

<button ng-disabled="form.$invalid || saving">
  {{ saving ? 'Saving...' : 'Save' }}
</button>
07

Eigene Directives

Einfache Directive

Eine Directive erweitert HTML. restrict: 'E' macht daraus ein Custom-Element (<greeting>); 'A' ein Attribut. Die einfachsten Directives geben nur ein template zurück. Standardmäßig Element/Attribute-Restricts; Class/Comment-Restricts sind selten. Moderne Best-Practice bevorzugt Components für template-basierte Directives.

angularjs
app.directive('greeting', function() {
  return {
    restrict: 'E',              // E=element, A=attr, C=class, M=comment
    template: '<h1>Hello there!</h1>'
  };
});

<!-- usage -->
<greeting></greeting>
<!-- or as attribute: <div greeting></div> -->

Directive Definition Object (DDO)

Das Directive Definition Object konfiguriert alles: restrict, scope (isolate oder nicht), template/templateUrl, transclude, controller und die link-Funktion. templateUrl lädt das Template über $http (gecacht); template ist inline. DOM-Manipulation in link, View-Model-Logik im controller halten.

angularjs
app.directive('card', function() {
  return {
    restrict: 'E',
    scope: {},                  // isolate scope
    templateUrl: 'card.html',
    transclude: true,
    controller: function() { /* ... */ },
    controllerAs: 'vm',
    bindToController: {},
    link: function(scope, el, attrs) { /* DOM work */ }
  };
});

Isolate-Scope-Bindings (@ = &)

@ liest das Attribut als String (one-way, parent->child, interpoliert). = erzeugt ein Two-Way-Binding auf den Ausdruck des Eltern-Scope. & exponiert eine Funktion, die einen Ausdruck im Eltern-Scope ausführt — für Event-Callbacks. Diese drei Bindings sind der Kern wiederverwendbarer Directive-Komponenten.

angularjs
app.directive('profile', function() {
  return {
    restrict: 'E',
    scope: {
      name: '@',          // read attribute as STRING (one-way)
      user: '=',          // two-way binding to expression
      onSave: '&'         // callback: evaluate expression in parent scope
    },
    template: '<p>{{ name }} / {{ user.email }}</p>'
  };
});

<profile name="{{ n }}" user="currentUser" on-save="save()"></profile>

Link-Funktion

Die link-Funktion läuft, nachdem das Directive-Element kompiliert wurde. Für direkte DOM-Manipulation, Event-Listener (über jQuery Lite's .on) und das Beobachten interpolierter Attribute mit attrs.$observe. scope ist der Scope der Directive, element der jqLite-umwickelte DOM-Knoten, attrs die normalisierten Attribute.

angularjs
app.directive('highlight', function() {
  return {
    restrict: 'A',
    link: function(scope, element, attrs) {
      element.on('mouseenter', function() {
        element.css('background', 'yellow');
      });
      element.on('mouseleave', function() {
        element.css('background', '');
      });
      attrs.$observe('highlight', function(val) {
        // react to attribute interpolation changes
      });
    }
  };
});

Compile-Funktion

Die compile-Funktion läuft einmalig auf dem Original-Template-Element, bevor Angular es für ng-repeat usw. klont. Für Template-Ebene-Transformationen, die keinen Scope brauchen. Sie gibt eine link-Funktion zurück (oder ein pre/post-link-Objekt). Die meisten Directives brauchen kein compile — link für Instanz-Arbeit bevorzugen.

angularjs
app.directive('repeatN', function() {
  return {
    restrict: 'E',
    compile: function(tElement, tAttrs) {
      // runs ONCE on the TEMPLATE element, before cloning
      var n = parseInt(tAttrs.count, 10);
      for (var i = 1; i < n; i++) {
        tElement.after(tElement.clone());
      }
      // optionally return a (post) link function
      return function link(scope, el, attrs) {
        el.addClass('repeated');
      };
    }
  };
});

Transclusion

transclude: true erfasst den Inhalt des Originalelements und fügt ihn ins Template ein, wo ng-transclude steht. Der transkludierte Inhalt behält seinen ursprünglichen (Eltern-)Scope, nicht den isolate scope der Directive. So kann eine Wrapper-Directive (panel, modal, card) beliebigen vom Aufrufer gelieferten Inhalt ummanteln.

angularjs
app.directive('panel', function() {
  return {
    restrict: 'E',
    transclude: true,
    template: '<div class="panel"><div class="panel-body" ng-transclude></div></div>'
  };
});

<!-- the inner content lands inside ng-transclude -->
<panel>
  <h3>Title</h3>
  <p>Body content goes here.</p>
</panel>
08

Filter

Eingebaute Filter

Angular bringt number, currency, date, lowercase, uppercase, json, limitTo, orderBy und filter mit. Das Argument nach dem Doppelpunkt konfiguriert den Filter. currency akzeptiert ein ISO-Symbol oder ein eigenes Zeichen. Filter laufen bei jedem Digest neu — teure Berechnungen cachen oder im Controller rechnen.

angularjs
<p>{{ 1234.5 | number:2 }}</p>          <!-- 1,234.50 -->
<p>{{ 9.99 | currency:'USD' }}</p>     <!-- $9.99 -->
<p>{{ 128 | currency:'&euro;' }}</p>   <!-- €128.00 -->
<p>{{ 'hi' | uppercase }}</p>          <!-- HI -->
<p>{{ 'HI' | lowercase }}</p>          <!-- hi -->
<p>{{ 'a b c' | limitTo:2 }}</p>       <!-- a  -->

date-Filter

Der date-Filter formatiert ein Date-Objekt, einen ISO-8601-String oder Epoch-Millisekunden. Vordefinierte Formate: 'short','medium','long','full','shortDate','mediumDate','shortTime'. Eigene Formate nutzen Token: y (Jahr), M (Monat), d (Tag), H (Stunde), m (Minute), s (Sekunde), EEEE (vollständiger Wochentag).

angularjs
<p>{{ now | date }}</p>                       <!-- Jan 1, 2025 -->
<p>{{ now | date:'yyyy-MM-dd' }}</p>        <!-- 2025-01-01 -->
<p>{{ now | date:'shortTime' }}</p>         <!-- 3:45 PM -->
<p>{{ now | date:'EEEE, MMMM d, y' }}</p>   <!-- Wednesday, January 1, 2025 -->

<!-- accepts a Date, ISO string, or millis timestamp -->

filter-Filter (Array-Suche)

Der filter-Filter wählt Array-Elemente aus, die einem String, Objekt oder einer Prädikatfunktion entsprechen. Ein Objekt matcht Elemente, deren benannte Felder die angegebenen Werte enthalten. Das optionale dritte Argument true erzwingt exaktes Matching. Bei großen Arrays im Controller filtern, um Re-Läufe je Digest zu vermeiden.

angularjs
<!-- match any field containing the query string -->
<li ng-repeat="u in users | filter:query">{{ u.name }}</li>

<!-- match a specific field with an object -->
<li ng-repeat="u in users | filter:{ role: 'admin' }">{{ u.name }}</li>

<!-- strict equality on a field -->
<li ng-repeat="u in users | filter:{ id: 5 }:true">{{ u.name }}</li>

orderBy-Filter

orderBy sortiert ein Array nach Feldname (Präfix '-' für absteigend), nach einem Array solcher Felder oder einer Comparator-Funktion. Es erzeugt bei jedem Digest ein neues sortiertes Array — bei großen Listen einmal im Controller sortieren und wiederverwenden. Kombiniert mit filter treibt es Such+Sort-UIs an.

angularjs
<!-- ascending by 'name' -->
<li ng-repeat="u in users | orderBy:'name'">{{ u.name }}</li>

<!-- descending -->
<li ng-repeat="u in users | orderBy:'-name'">{{ u.name }}</li>

<!-- multiple fields -->
<li ng-repeat="u in users | orderBy:['role','-age']">{{ u.name }}</li>

<!-- by a function -->
<li ng-repeat="u in users | orderBy:scoreFn">{{ u.name }}</li>

Eigener Filter

Eine Filter-Factory mit app.filter registrieren. Die Factory gibt eine Funktion zurück, die den Eingabewert (der Wert vor der Pipe) plus weitere Argumente transformiert. Filter müssen pur und nebenwirkungsfrei sein. Sie sind injizierbar, also können sie in der Factory andere Services nutzen.

angularjs
app.filter('capitalize', function() {
  return function(input) {
    if (!input) return '';
    input = String(input);
    return input.charAt(0).toUpperCase() + input.slice(1).toLowerCase();
  };
});

<!-- usage -->
<p>{{ 'hELLo' | capitalize }}</p>   <!-- Hello -->

$filter-Service im Controller

$filter injizieren, um einen Filter innerhalb von JS anzuwenden (Controller, Services). Aufruf: $filter('name')(value, arg1, arg2). Das vermeidet Neuberechnung bei jedem Digest und erlaubt die Wiederverwendung des Ergebnisses. Nützlich, wenn der gefilterte Wert in Logik gebraucht wird, nicht nur in der View.

angularjs
app.controller('ListCtrl', ['$scope', '$filter', function($scope, $filter) {
  $scope.users = [/* ... */];

  // run the orderBy filter programmatically
  $scope.sorted = $filter('orderBy')($scope.users, 'name');

  // currency filter to format a number
  $scope.priceText = $filter('currency')(99.5, '$');
}]);
09

Services ($http, $location, ...)

$http-Grundlagen

$http führt XHR-Anfragen aus und gibt ein Promise zurück. Der erfüllte Wert ist ein Response-Objekt mit data, status, headers und config. .then behandelt Erfolg, .catch Fehler. Seit Angular 1.6 sind .success/.error-Callbacks entfernt — konsequent .then/.catch verwenden.

angularjs
app.controller('ApiCtrl', ['$scope', '$http', function($scope, $http) {
  $http.get('/api/users')
    .then(function(response) {
      $scope.users = response.data;       // response: {data, status, headers, config}
    })
    .catch(function(error) {
      console.error('failed', error.status);
    });
}]);

$http POST/PUT mit Config

Komfortmethoden für get/post/put/delete/patch/jsonp/head vorhanden. Für volle Kontrolle ein Config-Objekt übergeben: params werden zur Query-String, headers setzt Request-Header, responseType steuert das Parsen des Bodys. $http wendet Default-Transforms (JSON-Parse) automatisch an.

angularjs
$http.post('/api/users', { name: 'Ada' })
  .then(function(res) { console.log('created', res.data); });

// with headers / query params / response type
$http({
  method: 'GET',
  url: '/api/report',
  params: { format: 'pdf' },
  headers: { 'X-Auth': token },
  responseType: 'arraybuffer'
}).then(function(res) { /* res.data is binary */ });

$location-Service

$location ist ein Wrapper über window.location, der synchron zur Browser-URL und zum Digest-Zyklus bleibt. Damit path, Suchparameter und hash lesen oder ändern. Für HTML5-pretty-URLs $locationProvider.html5Mode(true) konfigurieren und ein <base>-Tag ergänzen.

angularjs
// read the URL
$location.path();          // '/users/42'
$location.search();        // { tab: 'edit' }
$location.hash();          // 'top'
$location.absUrl();        // full URL

// change without full reload
$location.path('/dashboard');
$location.search('q', 'angular');   // ?q=angular
$location.hash('section-2');

$timeout & $interval

$timeout und $interval sind digest-bewusste Wrapper über setTimeout/setInterval — sie triggern $apply, damit Scope-Updates erkannt werden. Bei $destroy immer canceln, um Leaks und 'digest on a destroyed scope'-Fehler zu vermeiden. false als drittes Argument übergeben, um den Digest zu überspringen, wenn er nicht gebraucht wird.

angularjs
// $timeout: like setTimeout but triggers a $digest
var promise = $timeout(function() {
  $scope.status = 'ready';
}, 1000);

// cancel
$timeout.cancel(promise);

// $interval: like setInterval, also digest-aware
var ticker = $interval(function() { $scope.now = Date.now(); }, 5000);
$scope.$on('$destroy', function() { $interval.cancel(ticker); });

$log & $window / $document

$log ist ein dünner Wrapper über console mit log/info/warn/error/debug und lässt sich für Produktions-Logging dekorieren. $window und $document umwickeln die Globals — immer injizieren statt direkt window/document aufzurufen, damit Tests sie mocken können und der Code umgebungsagnostisch bleibt.

angularjs
app.controller('LogCtrl', ['$log', '$window', function($log, $window) {
  $log.log('plain');
  $log.info('info');
  $log.warn('warning');
  $log.error('error');

  $window.alert('Hi');      // safer than bare alert()
  $window.innerWidth;
}]);

// $document wraps document; $window wraps window.
// Injecting them (instead of using globals) makes testing easy.

$rootScope.broadcast & globale Events

$rootScope.$broadcast für App-weite Events (Login/Logout, Theme-Wechsel). Listener auf jedem Scope empfangen es. Für Events, die nur $rootScope-Listener hören sollen, ist $rootScope.$emit billiger (steigt nicht ab). Globale Events nicht übergebrauchen — für die meiste Kommunikation Services mit expliziter API bevorzugen.

angularjs
// anywhere: broadcast a global event
$rootScope.$broadcast('auth:logout');

// in a controller: listen
$scope.$on('auth:logout', function() {
  $scope.currentUser = null;
});

// $emit on $rootScope = effectively global too
$rootScope.$emit('something', data); // only $rootScope.$on hears this
10

Factories, Services & Providers

factory()

factory() nimmt eine Funktion, die die Service-Instanz zurückgibt — die Factory läuft einmal (Singleton), der Rückgabewert wird geteilt. Der üblichste Weg, einen Service zu schaffen: ideal, um privaten Zustand hinter einer sauberen API zu kapseln. Alles, was zurückgegeben wird (Objekt, Funktion, Primitiv), wird zum Service.

angularjs
app.factory('UserService', ['$http', function($http) {
  var current = null;            // private state

  return {
    login: function(creds) {
      return $http.post('/login', creds).then(function(res) {
        current = res.data;
        return current;
      });
    },
    getCurrent: function() { return current; },
    isLoggedIn: function() { return !!current; }
  };
}]);

service()

service() instanziert den Konstruktor mit new, also Eigenschaften an this hängen. Äquivalent zu einer Factory, die eine neue Instanz zurückgibt — beide sind Singletons. service() bei Konstruktor/Klassen-Stil; factory(), wenn ein bestimmtes Objekt zurückgegeben oder etwas umwickelt werden soll.

angularjs
app.service('Counter', function() {
  // invoked with 'new' -> 'this' is the instance
  this.count = 0;
  this.inc = function() { this.count++; };
  this.reset = function() { this.count = 0; };
});

// usage: Counter.inc(); Counter.count;

provider()

provider() ist das niedrigste Rezept: es exponiert ein Config-Phase-Objekt (mit Settern) und eine $get-Factory, die die Instanz baut. Nur Provider sind in config()-Blöcke injizierbar (Suffix 'Provider'). provider() verwenden, wenn ein Service vor der Instanziierung konfiguriert werden muss; sonst factory() bevorzugen.

angularjs
app.provider('Greeter', function() {
  // config-time: defaults settable from .config()
  this.greeting = 'Hello';        // default

  this.setGreeting = function(g) { this.greeting = g; };

  // factory that produces the service instance
  this.$get = function() {
    var self = this;
    return {
      greet: function(name) { return self.greeting + ', ' + name + '!'; }
    };
  };
});

// configure in a config block:
app.config(['GreeterProvider', function(GreeterProvider) {
  GreeterProvider.setGreeting('Bonjour');
}]);

constant() vs. value()

Beide registrieren einen einfachen injizierbaren Wert. constant() ist schon in der Config-Phase verfügbar (Provider können ihn nutzen) und unveränderlich. value() erst in der Run-Phase. Faustregel: constant für Konfiguration, von der Provider abhängen; value für gemeinsame Laufzeit-Daten oder Helfer.

angularjs
// constant: injectable in config AND run phases
app.constant('MAX_USERS', 1000);

// value: injectable in run phase only (not config)
app.value('toastConfig', { duration: 3000 });

// value can hold any type, even a function
app.value('logger', function(msg) { console.log(msg); });

factory vs. service vs. provider

Unter der Haube ist jedes Rezept ein Provider: factorys Funktion wird $get, service ist eine Factory, die den Konstruktor mit new aufruft. Nach Lesbarkeit wählen: factory für die meisten Fälle, service für Konstruktor-Klassen, provider bei Config vor der Instanziierung. Komponenten konsumieren nur — die Wahl bleibt intern.

angularjs
// all three are singletons; the difference is HOW the instance is built

// factory: function returns the instance
app.factory('A', function() { return { x: 1 }; });

// service: constructor is 'new'-ed
app.service('B', function() { this.x = 1; });

// provider: $get returns the instance (configurable)
app.provider('C', function() {
  this.$get = function() { return { x: 1 }; };
});

$provide.decorator()

decorator() fängt die Instanziierung eines bestehenden Service ab — $delegate ist die Original-Instanz, die umwickelt, erweitert oder ersetzt werden kann. Für Querschnittsbelange (Logging, Caching, Fehlerberichte), ohne den Original-Service anzufassen. Decorators laufen lazy, erst beim ersten Injizieren des Service.

angularjs
app.decorator('$log', ['$delegate', function($delegate) {
  // $delegate is the original $log instance
  var origError = $delegate.error;
  $delegate.error = function(msg) {
    // e.g., send to error tracking, then call original
    trackError(msg);
    origError.apply($delegate, arguments);
  };
  return $delegate;   // return the (modified) service
}]);
11

Routing (ngRoute & ui-router)

ngRoute-Setup

ngRoute ist der eingebaute Router (in einer eigenen angular-route.js-Datei). Routen mit .when(path, config) registrieren und einen Fallback mit .otherwise(). ng-view ist die Ausgabe, an der das matchende Template+Controller rendern. ngRoute unterstützt nur eine Ausgabe und einfache :param-URLs — für verschachtelte Views ui-router verwenden.

angularjs
<!-- include angular-route.js (separate file in 1.x) -->
<script src="angular-route.js"></script>

var app = angular.module('myApp', ['ngRoute']);

app.config(['$routeProvider', function($routeProvider) {
  $routeProvider
    .when('/home', { templateUrl: 'home.html', controller: 'HomeCtrl' })
    .when('/users/:id', { templateUrl: 'user.html', controller: 'UserCtrl' })
    .otherwise({ redirectTo: '/home' });
}]);

<!-- where the matched view renders -->
<div ng-view></div>

ngRoute-Routen-Parameter

$routeParams exponiert URL-Segmente (:id) als Objekt mit String-Keys — Werte sind immer Strings, also Zahlen mit parseInt umwandeln. Es aktualisiert sich nach einem Routenwechsel. Für dynamische Links ng-href. Das Default-Hashbang-Präfix ist #! (seit 1.6); konfigurierbar über $locationProvider.hashPrefix('').

angularjs
app.controller('UserCtrl', ['$routeParams', 'UserSvc',
  function($routeParams, UserSvc) {
    // URL /users/42  ->  $routeParams.id === '42' (always a string)
    this.user = UserSvc.get($routeParams.id);
  }]);

<!-- links -->
<a href="#!/users/42">View user 42</a>
<!-- with HTML5 mode, use a plain href="/users/42" -->

ngRoute-Lifecycle-Events

ngRoute broadcastet $routeChangeStart (abbruchbar via event.preventDefault), $routeChangeSuccess und $routeChangeError. Die 'next'/'current'-Argumente tragen die Routen-Konfiguration (mit resolve-Ergebnissen). Für Auth-Guards, Ladeindikatoren und Breadcrumb-Titel. resolve-Ablehnungen feuern $routeChangeError.

angularjs
app.run(['$rootScope', function($rootScope) {
  $rootScope.$on('$routeChangeStart', function(event, next, current) {
    if (next.requireAuth && !AuthService.isLoggedIn()) {
      event.preventDefault();             // cancel navigation
    }
  });

  $rootScope.$on('$routeChangeSuccess', function(event, current, previous) {
    $rootScope.pageTitle = current.$$route.title;
  });

  $rootScope.$on('$routeChangeError', function(event, current, previous, rejection) {
    console.error('route failed', rejection);
  });
}]);

ui-router-States

ui-router organisiert die App in benannte States (nicht URL-Pfade). ui-sref verlinkt per State-Name und Parametern, ui-view ist die Ausgabe. States können verschachtelt sein und eigene URLs haben. Das entkoppelt Navigation von URLs und unterstützt mehrere/benannte Views — weit mächtiger als ngRoute für echte Apps.

angularjs
var app = angular.module('myApp', ['ui.router']);

app.config(['$stateProvider', function($stateProvider) {
  $stateProvider
    .state('home', { url: '/home', templateUrl: 'home.html' })
    .state('users', { url: '/users', templateUrl: 'users.html' })
    .state('users.detail', {
      url: '/:id',
      templateUrl: 'user-detail.html',
      controller: 'UserDetailCtrl'
    });
}]);

<!-- outlet -->
<div ui-view></div>
<!-- links: state name instead of URL -->
<a ui-sref="users.detail({ id: 42 })">User 42</a>

ui-router resolve & verschachtelte States

resolve mappt Keys auf Promises; der Controller wird erst instanziert, wenn alle resolve. Bei einer resolve-Ablehnung feuert $stateChangeError, und der State wird nicht betreten. Resolve-Werte sind per Key in den Controller injizierbar. Kind-States erben und können Eltern-Resolves nutzen — praktisch für Datenvorladen.

angularjs
$stateProvider.state('users.detail', {
  url: '/:id',
  templateUrl: 'user-detail.html',
  controller: 'UserDetailCtrl',
  controllerAs: 'vm',
  resolve: {
    // injected into the controller; waits for these before activating
    user: ['UserSvc', '$stateParams', function(UserSvc, $stateParams) {
      return UserSvc.get($stateParams.id);   // returns a promise
    }]
  }
});

app.controller('UserDetailCtrl', ['user', function(user) {
  this.user = user;   // already resolved
}]);

ui-router: mehrere benannte Views

ui-router kann pro State mehrere benannte ui-view-Ausgaben rendern. Die Keys der views-Map entsprechen den ui-view-Namen im Template; der leere String-Key zielt auf die unbenannte Ausgabe. So kann ein einzelner State mehrere Regionen komponieren (header, sidebar, main) — mit ngRoutes einzelnem ng-view unmöglich.

angularjs
$stateProvider.state('dashboard', {
  url: '/dashboard',
  views: {
    '':        { templateUrl: 'dashboard/main.html' },
    'sidebar': { templateUrl: 'dashboard/sidebar.html', controller: 'SideCtrl' },
    'header':  { templateUrl: 'dashboard/header.html' }
  }
});

<!-- index.html -->
<div ui-view="header"></div>
<div ui-view="sidebar"></div>
<div ui-view></div>          <!-- the unnamed '' view -->
12

Formulare & Validierung

Formular mit ng-model

Dem Formular ein name-Attribut geben, um seinen Validierungszustand auf dem Scope zu exponieren. novalidate schaltet die Browser-eigenen Bubbles aus, damit Angular die Validierung steuert. Jedes benannte Eingabefeld publiziert seinen eigenen Zustand (myForm.email.$valid, $dirty, $error). ng-model ist nötig, damit die Validierung das Feld verfolgt.

angularjs
<form name="myForm" novalidate>
  <input name="email" type="email" ng-model="user.email" required>
  <input name="age" type="number" ng-model="user.age" min="18" required>

  <button ng-disabled="myForm.$invalid" ng-click="save()">Save</button>
</form>

<!-- novalidate disables the browser's native validation so Angular handles it -->

Validierungs-Zustände

Jedes Eingabefeld exponiert $pristine/$dirty (geändert?), $touched/$untouched (Fokus verloren?), $valid/$invalid und $error (eine Map der fehlgeschlagenen Validatoren). Das Formular aggregiert: myForm.$invalid ist true, wenn irgendein Feld ungültig ist. Meldungen erst nach $touched oder $dirty zeigen, um Nutzer nicht vor der Eingabe anzufahren.

angularjs
<input name="email" ng-model="user.email" required>
<p ng-show="myForm.email.$touched && myForm.email.$error.required">
  Email is required.
</p>

<!-- states available on each input / the form -->
<!-- $pristine, $dirty, $touched, $untouched, $valid, $invalid, $error -->

Eingebaute Validatoren

Eingebaute Validatoren: required, type=email/url/number, min/max, ng-minlength/ng-maxlength, ng-pattern. Jeder fehlgeschlagene Validator setzt einen Key in $error (z. B. $error.required, $error.minlength, $error.pattern). Backslashes in ng-pattern-Regexes innerhalb von HTML-Attributen escapen.

angularjs
<input name="email" type="email" ng-model="user.email" required>
<input name="age" type="number" ng-model="user.age" min="18" max="120">
<input name="code" ng-model="user.code"
       ng-minlength="4" ng-maxlength="8" required>
<input name="url" type="url" ng-model="user.url">
<input name="zip" ng-model="user.zip" ng-pattern="/^\d{5}$/">

Eigener Validator (Directive)

Eigene Validatoren über eine Directive ergänzen, die ngModel verlangt und eine Funktion auf ctrl.$validators registriert. true für gültig, false für ungültig — der Fehler erscheint in $error unter deinem Key (hier 'even'). Für asynchrone Validierung ctrl.$asyncValidators mit einem Promise verwenden.

angularjs
app.directive('evenNumber', function() {
  return {
    require: 'ngModel',
    link: function(scope, el, attrs, ctrl) {
      ctrl.$validators.even = function(modelValue, viewValue) {
        if (ctrl.$isEmpty(modelValue)) return true;   // let 'required' handle empty
        return parseInt(modelValue, 10) % 2 === 0;
      };
    }
  };
});

<input ng-model="n" even-number>
<p ng-show="form.n.$error.even">Must be even!</p>

ngMessages

ngMessages zeigt den ersten passenden Fehler (oder alle mit ng-messages-multiple). Deutlich sauberer als ng-if für jeden Validator zu stapeln. Gemeinsame Meldungen in ein Partial auslagern und mit ng-messages-include='messages.html' einbinden. Funktioniert mit eingebauten wie eigenen Validator-Keys.

angularjs
<!-- include angular-messages.js, add module 'ngMessages' -->
<script src="angular-messages.js"></script>

<div ng-messages="myForm.email.$error" ng-if="myForm.email.$touched">
  <div ng-message="required">Email is required.</div>
  <div ng-message="email">Enter a valid email.</div>
  <div ng-message="server">That email is taken.</div>
</div>

<!-- a template can be reused across fields with ng-messages-include -->

Formular-Absenden

ng-submit feuert beim Absenden des Formulars (Enter-Taste oder type='submit'-Button) und nur, wenn die ng-model-Validierungen passen, sofern nicht überschrieben. myForm.$valid als Sicherheitsprüfung an den Handler übergeben. novalidate stellt sicher, dass Angular (nicht der Browser) die Validierung treibt. Button mit ng-disabled deaktivieren, um Doppelsends zu verhindern.

angularjs
<form name="myForm" ng-submit="save(myForm.$valid)" novalidate>
  <input name="email" ng-model="user.email" required>
  <button type="submit" ng-disabled="myForm.$invalid">Save</button>
</form>

app.controller('FormCtrl', ['$scope', function($scope) {
  $scope.save = function(isValid) {
    if (!isValid) return;
    // ...submit to server
  };
}]);
13

Events (ng-click, ng-change, ...)

ng-click

ng-click wertet einen Ausdruck aus, wenn das Element geklickt wird. $event ist das native DOM-Ereignis, also lassen sich stopPropagation/preventDefault darauf aufrufen — trotzdem wo möglich ng-submit für Formulare und eingebaute Directives bevorzugen. ng-click funktioniert auf jedem Element, nicht nur Buttons.

angularjs
<button ng-click="count = count + 1">Inc</button>
<span>{{ count }}</span>

<!-- call a scope method -->
<button ng-click="save()">Save</button>

<!-- pass the native event with $event -->
<button ng-click="save($event)">Save</button>
<button ng-click="save($event); $event.stopPropagation()">Save</button>

ng-change

ng-change feuert, nachdem ng-model das Modell aktualisiert hat — $scope.country ist also schon der neue Wert. Es verlangt ng-model auf demselben Element. Damit auf Änderungen von input/select/checkbox reagieren (kaskadierende Dropdowns, Live-Filterung), ohne eigenen change-Listener einzurichten.

angularjs
<select ng-model="country" ng-change="onCountryChange()">
  <option value="us">US</option>
  <option value="uk">UK</option>
</select>

app.controller('LocCtrl', ['$scope', function($scope) {
  $scope.onCountryChange = function() {
    // fires AFTER ng-model updates $scope.country
    $scope.cities = CityService.forCountry($scope.country);
  };
}]);

ng-submit & ng-focus/blur-Familie

ng-submit behandelt das Absenden des Formulars. Angular exponiert außerdem Event-Directives für viele DOM-Ereignisse: ng-focus, ng-blur, ng-change, ng-copy, ng-cut, ng-paste, ng-keydown/up/press, ng-mousedown/up/enter/over/leave/move und ng-dblclick. Jede wertet einen Ausdruck aus, mit $event verfügbar.

angularjs
<!-- ng-submit: on form submission -->
<form ng-submit="search()">
  <input ng-model="query">
</form>

<!-- the ng-focus / ng-blur / ng-copy / ng-cut / ng-paste directives -->
<input ng-model="q" ng-focus="onFocus()" ng-blur="onBlur()">
<input ng-copy="copied = true">

Tastatur- & Maus-Events

Angular liefert ng-keydown/ng-keypress/ng-keyup und ng-mousedown/up/enter/leave/over/move plus ng-dblclick. Jede reicht $event durch, also lassen sich $event.keyCode oder $event.shiftKey prüfen. Für App-weite Shortcuts auf $document oder $window in einem Service binden, statt Handler in Templates zu verstreuen.

angularjs
<!-- keyboard events -->
<input ng-keydown="onKey($event)">
<input ng-keypress="onKey($event)">

<!-- mouse events -->
<div ng-mouseenter="hover = true" ng-mouseleave="hover = false">
  {{ hover ? 'Hovering' : 'Not hovering' }}
</div>
<button ng-dblclick="open()">Double-click</button>

$event-Objekt

$event ist das native DOM-Ereignis, das an den Handler weitergereicht wird. target, Koordinaten, Modifikator-Tasten lesen und preventDefault/stopPropagation aufrufen. Schwere Logik in Click-Handlern vermeiden — stattdessen eine Methode auf Controller/Service aufrufen. $event ist in jeder Event-Directive verfügbar.

angularjs
<button ng-click="onClick($event)">Click</button>

app.controller('ClickCtrl', ['$scope', function($scope) {
  $scope.onClick = function(event) {
    console.log(event.target);    // clicked element
    console.log(event.clientX, event.clientY);
    event.preventDefault();
    event.stopPropagation();
  };
}]);

Event-Modifikatoren (manuell)

Anders als Vue/Angular 2+ hat AngularJS keine .stop/.prevent/.once-Modifikatoren — die Event-Methoden ruft man selbst im Handler auf. Mehr Schreibarbeit, aber explizit. Für häufig gebrauchte Verhaltensweisen (auto preventDefault beim Submit) macht ng-submit das für Formulare bereits.

angularjs
<!-- AngularJS has NO built-in modifiers like .stop / .prevent.
     Call the method on $event instead. -->
<a href="/delete" ng-click="del($event)">Delete</a>

app.controller('DelCtrl', ['$scope', function($scope) {
  $scope.del = function(event) {
    event.preventDefault();   // stop the link navigation
    $scope.removeItem();
  };
}]);
14

$watch / $digest / $apply

$scope.$watch

$watch registriert einen Listener, der bei jeder Änderung des beobachteten Werts während eines Digests läuft. Das erste Argument kann ein String-Ausdruck oder eine Funktion sein; der Callback erhält (newVal, oldVal). $watch gibt eine Deregistrierungsfunktion zurück — aufrufen, um das Beobachten zu beenden und Leaks zu vermeiden, besonders in Directives.

angularjs
app.controller('WatchCtrl', ['$scope', function($scope) {
  $scope.user = { name: 'Ada' };

  // watch a path expression (string)
  var unbind = $scope.$watch('user.name', function(newVal, oldVal) {
    console.log('name changed', oldVal, '->', newVal);
  });

  // stop watching (frees resources)
  unbind();
}]);

$watchCollection

$watchCollection beobachtet eine Ebene eines Arrays oder Objekts: es feuert beim Hinzufügen/Entfernen/Ersetzen von Elementen, vergleicht aber NICHT tief die Element-Eigenschaften. Deutlich billiger als tiefer $watch (drittes Argument true). Für Arrays von Primitiven oder wenn nur die Listenzugehörigkeit zählt, nicht die tiefen Inhalte.

angularjs
$scope.items = [1, 2, 3];

// watch array/object shallowly: detects add/remove/replace but NOT deep mutation
$scope.$watchCollection('items', function(newItems, oldItems) {
  console.log('collection changed', newItems);
});

// fires on push/splice, or when an item is replaced,
// but NOT when an item's own properties change.

Tiefer $watch (drittes Argument)

true als drittes Argument lässt $watch einen tiefen Wertvergleich machen — es feuert bei jeder Änderung einer verschachtelten Eigenschaft. Das ist teuer (läuft bei jedem Digest durch das ganze Objekt). Lieber einen konkreten Pfad beobachten oder $watchCollection verwenden. Tiefes Beobachten kleinen Objekten vorbehalten, wo es wirklich nötig ist.

angularjs
$scope.config = { ui: { theme: 'dark' } };

// third arg true -> deep comparison by value (expensive!)
$scope.$watch('config', function(n, o) {
  console.log('config (deep) changed');
}, true);

// prefer watching a specific path when possible:
$scope.$watch('config.ui.theme', function(n, o) { /* cheaper */ });

$scope.$apply

Code außerhalb Angulars (rohes setTimeout, XHR ohne $http, jQuery-Events, Promise-Callbacks) ändert das Modell, aber Angular weiß es nicht — $apply() aufrufen, um einen $digest zu triggern. Die Funktionsform umwickelt die Änderungen mit Exception-Behandlung und führt genau einen Digest aus. Innerhalb Angular-Services ($http, $timeout) ist $apply schon erledigt — nicht doppelt anwenden.

angularjs
// NON-Angular async callback (e.g., a 3rd-party library) won't trigger a digest
externalLib.onReady(function() {
  $scope.message = 'Ready!';

  // tell Angular to run a digest so the view updates
  $scope.$apply();
});

// or wrap the change so errors are caught and digest runs once
$scope.$apply(function() {
  $scope.message = 'Ready!';
  $scope.ready = true;
});

$evalAsync & $timeout (sicheres Apply)

$evalAsync oder $timeout(fn, 0) einem manuellen $apply vorziehen, wenn unklar ist, ob schon ein Digest läuft — sie vermeiden 'digest already in progress'-Fehler. $evalAsync batcht in den laufenden Digest; $timeout schiebt auf den nächsten Tick. $timeout verwenden, wenn auch das DOM gerendert haben soll.

angularjs
// $evalAsync: schedule work later in the SAME digest if one is running,
//             otherwise start a new one. Safer than $apply.
$scope.$evalAsync(function() {
  $scope.computed = heavyCompute();
});

// $timeout(..., 0) always runs in a fresh digest — useful when you
// need the DOM updated before your code runs.
$timeout(function() {
  $scope.deferred = true;
}, 0);

Der $digest-Zyklus erklärt

$digest ist die Schleife, die Modelländerungen in die View propagiert: sie wertet jeden Watcher neu aus, bis sich Werte nicht mehr ändern (dirty checking), maximal 10 Iterationen. Weil jeder Watcher bei jedem Digest läuft, skaliert die Performance mit der Watcher-Zahl. Watcher reduzieren über one-time binding (::), track by und Verlagerung von Berechnungen in den Controller.

angularjs
// a $digest iterates over ALL watchers on $scope and its children:
//   1. read each watched value, compare to previous
//   2. if changed, call the listener
//   3. listeners may change other watched values -> re-run
//   4. repeat until stable (max 10 iterations -> error)

// so: keep watchers cheap and few.
// track by, one-time binding (::), and compute in controllers help.
15

Components (.component())

.component()-Grundlagen

.component() ist Zucker über directive, optimiert für template-basierte Komponenten. Standard ist restrict 'E', isolate scope und controllerAs '$ctrl' — also this (alias $ctrl) statt $scope verwenden. bindings ersetzt scope:{...}; '<' (one-way inbound) ist seit 1.5 für Inputs '=' vorzuziehen.

angularjs
app.component('heroDetail', {
  template: '<h2>{{$ctrl.hero.name}}</h2><p>{{$ctrl.hero.power}}</p>',
  bindings: {
    hero: '<'        // one-way ('<'), two-way ('='), string ('@'), expr ('&')
  }
});

<!-- usage -->
<hero-detail hero="selectedHero"></hero-detail>

Component mit Controller & Bindings

Ein Component-Controller nutzt this (im Template als $ctrl aliasiert). bindings deklariert Inputs ('<', '=') und Outputs ('&'). One-way '<' für Inputs bevorzugen. Outputs nutzen '&' — Aufruf mit einem Argument-Objekt, das zu den locals des Eltern-Ausdrucks wird: onChange({ value: ... }).

angularjs
app.component('counter', {
  bindings: {
    start: '<',
    onChange: '&'
  },
  template: `
    <button ng-click="$ctrl.dec()">-</button>
    <span>{{ $ctrl.count }}</span>
    <button ng-click="$ctrl.inc()">+</button>
  `,
  controller: function() {
    this.$onInit = function() { this.count = this.start || 0; };
    this.inc = function() { this.count++; this.onChange({ value: this.count }); };
    this.dec = function() { this.count--; this.onChange({ value: this.count }); };
  }
});

Component-Lifecycle-Hooks

Die Component-Hooks von AngularJS 1.5+ spiegeln den Lifecycle von Angular 2+: $onInit (Init), $onChanges (Binding-Änderungen, mit isFirstChange), $doCheck (je Digest), $postLink (nach dem Verlinken des Kind-DOM), $onDestroy (Abbau). Statt Logik in den Konstruktor zu stopfen — sie machen Komponentenverhalten explizit und testbar.

angularjs
app.component('editor', {
  bindings: { doc: '<', onClose: '&' },
  controller: function() {
    this.$onInit = function() { /* after bindings, before first render */ };
    this.$onChanges = function(changes) {
      // changes.doc: { currentValue, previousValue, isFirstChange() }
    };
    this.$doCheck = function() { /* every digest: custom dirty checking */ };
    this.$onDestroy = function() { /* cleanup: timers, listeners */ };
    this.$postLink = function() { /* after child linking, DOM ready */ };
  }
});

$onChanges im Detail

$onChanges feuert, wenn sich die Referenz eines one-way ('<')-Bindings ändert, mit einem changes-Objekt: jeder Key hat currentValue, previousValue und isFirstChange(). Bei Mutationen desselben Objekts feuert es NICHT (Referenz unverändert) — dafür $doCheck. Beim Init feuert es immer einmal mit isFirstChange() true.

angularjs
app.component('userView', {
  bindings: { user: '<' },
  controller: function() {
    this.$onChanges = function(changesObj) {
      // changesObj is keyed by binding name
      if (changesObj.user) {
        var c = changesObj.user;
        console.log(c.previousValue, '->', c.currentValue);
        console.log('first time?', c.isFirstChange());
      }
    };
  }
});

Transclusion in Components

transclude: true setzen und ng-transclude ins Template aufnehmen, damit Aufrufer Inhalte injizieren können. In Components wird auch Multi-Slot-Transclusion unterstützt über transclude: { slotName: 'elementName' }. Transclusion erlaubt wiederverwendbare Wrapper (Panels, Modals, Cards), deren Körper das Parent liefert.

angularjs
app.component('modal', {
  transclude: true,
  template: `
    <div class="modal">
      <div class="modal-body" ng-transclude></div>
    </div>
  `,
  bindings: { title: '@' }
});

<!-- caller's content lands in ng-transclude -->
<modal title="Confirm">
  <p>Are you sure?</p>
  <button>Yes</button>
</modal>

Component vs. Directive

Components für alles verwenden, was ein Template rendert — sie sind einfacher und führen Richtung Angular-2+-Modell (isolate scope, this/controllerAs, Lifecycle-Hooks). Directives für attributartiges Verhalten ohne Template reservieren (autofocus, Tooltip-Trigger, Input-Maske) und direkte DOM-Manipulation in link.

angularjs
// COMPONENT: template-based, isolate scope, controllerAs by default
app.component('userCard', {
  template: '...',
  bindings: { user: '<' }
});

// DIRECTIVE: still needed for attribute behavior / DOM manipulation
app.directive('autoFocus', function() {
  return { restrict: 'A', link: function(scope, el) { el[0].focus(); } };
});
16

$q Promise-Service

$q.defer()-Grundlagen

$q ist Angulars Promise-Implementierung (Promises/A+). Erzeugen mit $q.defer(), dann resolve(value) oder reject(reason). Das Promise ist digest-bewusst: die Erfüllung triggert einen $digest, damit die View aktualisiert wird. $q gegenüber nativem Promise bevorzugen, wenn Angulars Auto-Digest gebraucht wird; sonst funktioniert auch natives Promise.

angularjs
app.factory('AsyncWork', ['$q', function($q) {
  return function() {
    var deferred = $q.defer();

    setTimeout(function() {
      if (success) deferred.resolve('done');
      else         deferred.reject(new Error('failed'));
    }, 100);

    return deferred.promise;     // { then, catch, finally }
  };
}]);

// consume
AsyncWork().then(function(v) { console.log(v); })
          .catch(function(e) { console.error(e); });

$q.when / $q.all / $q.reject

$q.when umwickelt einen normalen Wert oder ein Nicht-$q-Promise. $q.all wartet auf ein Array oder Objekt von Promises und erfüllt mit derselben Form von Ergebnissen. $q.reject(reason) ist ein bequemer Weg, ein abgelehntes Promise zurückzugeben (z. B. für frühe Validierung in einer Kette). Alle sind digest-bewusst.

angularjs
// $q.when: wrap a value (or foreign promise) in an Angular promise
$q.when(42).then(function(v) { /* v === 42 */ });

// $q.all: wait for many promises in parallel
$q.all([getUser(), getPosts(), getFriends()]).then(function(results) {
  var user = results[0], posts = results[1], friends = results[2];
});

// $q.all with an object (named results)
$q.all({ user: getUser(), posts: getPosts() }).then(function(r) {
  r.user; r.posts;
});

// $q.reject: shortcut to return a rejected promise
return $q.reject(new Error('bad input'));

Promises verketten

Ein Rückgabewert aus .then geht an den nächsten Handler; ein zurückgegebenes Promise lässt die Kette warten. Ein einzelnes .catch behandelt jede Ablehnung stromaufwärts. .finally läuft bei Erfolg wie bei Fehlschlag — perfekt, um Loader zu verbergen. Jeder Handler läuft in Angulars Digest, also funktionieren Scope-Updates einfach.

angularjs
getUser(id)
  .then(function(user) {
    return getOrders(user);    // return a promise -> chain waits
  })
  .then(function(orders) {
    return orders.filter(paid); // return a value -> next step
  })
  .then(function(paidOrders) {
    $scope.paid = paidOrders;
  })
  .catch(function(err) {
    // any rejection above lands here
    console.error(err);
  })
  .finally(function() {
    $scope.loading = false;    // runs regardless
  });

$http gibt Promises zurück

$http gibt bereits ein $q-Promise zurück, also .then verketten, um die Antwort zu transformieren (oft .data extrahieren) und einen saubereren Wert zurückzugeben. $http in einem Service zu umwickeln gibt Aufrufern eine ordentliche API und zentralisiert URL/Base-URL/Fehler-Behandlung. Interceptors sind ein anderer Weg für Querschnittsverhalten von $http.

angularjs
app.factory('UserApi', ['$http', function($http) {
  return {
    list: function() { return $http.get('/users').then(function(r) { return r.data; }); },
    get:  function(id) { return $http.get('/users/' + id).then(function(r) { return r.data; }); }
  };
}]);

// caller doesn't deal with response.data, just the user
UserApi.get(42).then(function(user) { $scope.user = user; });

$q-Konstruktor (ES6-Stil)

Seit 1.6 unterstützt $q die ES6-Promise-Konstruktor-Form: $q(function(resolve, reject){...}). Kompakter als $q.defer() und entsprechend der nativen Promise-Syntax. Beim Umwickeln einer einzelnen asynchronen API. Das resultierende Promise bleibt digest-bewusst, also feuern View-Updates beim resolve automatisch.

angularjs
// Angular 1.6+ supports the resolver-style constructor, like native Promise
app.factory('loadImg', ['$q', function($q) {
  return function(src) {
    return $q(function(resolve, reject) {
      var img = new Image();
      img.onload  = function() { resolve(img); };
      img.onerror = function() { reject(new Error('load failed')); };
      img.src = src;
    });
  };
}]);

$q vs. natives Promise

Der Kernunterschied: $q triggert beim Erfüllen einen $digest, natives Promise nicht. In modernen AngularJS-Apps auf Evergreen-Browsern kann natives Promise genutzt werden, aber Modell-Updates müssen in $apply (oder $evalAsync) gewickelt werden. Für Konsistenz und Bequemlichkeit $q innerhalb Angular-Codes bevorzugen.

angularjs
// native Promise: no auto-digest; you must $apply manually
Promise.resolve().then(function() {
  $scope.x = 1;
  $scope.$apply();           // otherwise the view won't update
});

// $q promise: resolves inside a $digest automatically
$q.when().then(function() { $scope.x = 1; });   // view updates
17

Animationen (ngAnimate)

ngAnimate-Setup

ngAnimate ist ein eigenes Modul (eigene JS-Datei). Als Dependency ergänzt, erweitert es automatisch die eingebauten Directives, sodass sie CSS-Klassen bei enter/leave/move-Übergängen ergänzen — man schreibt nur CSS. Für den Standardfall kein JS nötig. Ohne ngAnimate ändern diese Directives das DOM sofort.

angularjs
<!-- include angular-animate.js, then depend on 'ngAnimate' -->
<script src="angular-animate.js"></script>

var app = angular.module('myApp', ['ngAnimate']);

<!-- ngAnimate now adds classes automatically to:
     ng-repeat (enter/leave/move), ng-if, ng-show, ng-hide,
     ng-class, ng-view, ng-include, ui-view -->

CSS-Transition-Klassen

ngAnimate ergänzt pro Ereignis zwei Klassen: eine Startklasse (z. B. .ng-enter) und eine -active-Klasse (.ng-enter-active) einen Frame später. Eine CSS-Transition auf der Startklasse und den Endzustand auf der active-Klasse definieren — Angular entfernt beide, wenn die Transition endet. Der einfachste, performanteste Animationsansatz.

angularjs
/* .ng-enter / .ng-leave / .ng-move are added automatically */
.fade.ng-enter        { transition: opacity 0.3s; opacity: 0; }
.fade.ng-enter-active { opacity: 1; }

.fade.ng-leave        { transition: opacity 0.3s; opacity: 1; }
.fade.ng-leave-active { opacity: 0; }

<!-- apply the .fade class to your ng-if / ng-repeat element -->
<div class="fade" ng-if="show">Hello</div>

CSS-Keyframe-Animationen

Statt Transitions lassen sich CSS-@keyframes-Animationen nutzen — ngAnimate kippt dieselben .ng-enter/.ng-leave/.ng-move-Klassen, und das Keyframe läuft. Mit Keyframes reicht die einzelne Startklasse (kein -active nötig), weil die Animation die ganze Sequenz treibt. Gut für Bounce-/Spring-Effekte.

angularjs
/* use @keyframes; ngAnimate still toggles the classes */
.pop.ng-enter { animation: pop-in 0.3s; }

@keyframes pop-in {
  0%   { transform: scale(0); }
  100% { transform: scale(1); }
}

<div class="pop" ng-if="visible">Pop!</div>

ng-repeat enter / leave / move

ng-repeat-Elemente bekommen .ng-enter (neu), .ng-leave (entfernt) und .ng-move (umsortiert) Klassen. track by verwenden, damit Angular Elemente über Änderungen hinweg matchen und Moves korrekt animieren kann. Stagger-Animationen sind mit .ng-enter-stagger / .ng-leave-stagger möglich, um jedes Element zu verzögern — ideal für Listen-Reveal-Effekte.

angularjs
/* list items animate when added, removed, or reordered */
.list-item.ng-enter        { transition: all 0.3s; opacity: 0; transform: translateY(-10px); }
.list-item.ng-enter-active { opacity: 1; transform: translateY(0); }

.list-item.ng-leave-active { opacity: 0; transform: translateX(20px); }

/* .ng-move animates reordering (track by recommended) */
.list-item.ng-move        { transition: transform 0.3s; }
.list-item.ng-move-active { }

<ul><li class="list-item" ng-repeat="t in todos track by t.id">{{ t.text }}</li></ul>

$animate-Service (JS-Animationen)

app.animation(cssSelector, factory) registriert eine JS-Animation für Elemente, die zum Selektor passen. Die enter/leave/move/class-Methoden erhalten das Element und einen done-Callback. Nützlich, wenn CSS nicht reicht (z. B. jQuery.animate oder eine Physik-Bibliothek). Eine cancel-Funktion fürs Aufräumen zurückgeben. JS-Animationen sind schwerer als CSS — wenn möglich CSS bevorzugen.

angularjs
app.animation('.fade-js', ['$animate', function($animate) {
  return {
    enter: function(element, done) {
      element.css('opacity', 0);
      element.animate({ opacity: 1 }, 300, done);
      return function(cancelled) { /* cleanup if cancelled */ };
    },
    leave: function(element, done) {
      element.animate({ opacity: 0 }, 300, done);
    }
  };
}]);

<div class="fade-js" ng-if="show">Hello</div>

Animationen deaktivieren

Animationen global oder pro Teilbaum abschalten mit $animate.enabled oder über die Klasse ng-animate-disabled. Nützlich für Performance bei großen Listen oder zum Deaktivieren von Animationen beim Testen. ng-animate-children lässt ein Parent seine Kinder gemeinsam animieren (standardmäßig überspringt eine Eltern-Animation Kinder-Animationen).

angularjs
<!-- ng-animate-ref / ng-animate-sref control animation between routes -->

<!-- opt out per-element -->
<div ng-if="x" ng-animate-children>...</div>
<div ng-if="y" class="ng-animate-disabled">...</div>

// programmatically
$animate.enabled(false);                    // globally off
$animate.enabled(false, element);           // off for subtree
$animate.enabled(true, element);            // back on
18

Testen (Karma & Jasmine)

Karma-Konfigurationsriss

Karma ist AngularJS' Standard-Test-Runner: er startet echte Browser, lädt die Skripte plus angular-mocks und meldet Jasmine-Ergebnisse. angular-mocks liefert module() und inject() Helfer und Mock-Services ($httpBackend). singleRun:true beendet nach einem Lauf (CI); weglassen für Watch-Modus.

angularjs
// karma.conf.js (sketch)
module.exports = function(config) {
  config.set({
    frameworks: ['jasmine'],
    files: [
      'node_modules/angular/angular.js',
      'node_modules/angular-mocks/angular-mocks.js',
      'src/**/*.js',
      'test/**/*.spec.js'
    ],
    browsers: ['ChromeHeadless'],
    singleRun: true
  });
};

// run: karma start karma.conf.js

Jasmine-Grundlagen

Jasmine liefert describe (Suite), it (Spec), beforeEach/afterEach (Setup/Teardown) und expect mit Matchern (toBe, toEqual, toContain, toBeTruthy, toThrow usw.). xit/xdescribe überspringen Specs. Tests sind standardmäßig synchron; für asynchron done-Callback oder Jasmines async/await-Unterstützung nutzen.

angularjs
describe('UserService', function() {
  beforeEach(function() { /* setup */ });
  afterEach(function() { /* teardown */ });

  it('isLoggedIn is false by default', function() {
    var svc = makeService();
    expect(svc.isLoggedIn()).toBe(false);
  });

  it('greets by name', function() {
    expect(greet('Ada')).toEqual('Hi, Ada');
  });

  // pending / disabled
  xit('not yet implemented', function() {});
});

Einen Controller testen

module('myApp') lädt das Angular-Modul; inject() löst Services auf (oft mit führenden/nachgestellten Unterstrichen aliasiert). Einen Controller mit $controller('Name', { $scope: scope }) erzeugen, mit Fake-Dependencies. Dann auf dem Scope assertionen. Das Muster funktioniert auch für controllerAs: this-gebundene Methoden durchreichen und die zurückgegebene Instanz prüfen.

angularjs
describe('TodoCtrl', function() {
  beforeEach(module('myApp'));

  var $controller, $scope;
  beforeEach(inject(function(_$controller_, _$rootScope_) {
    $scope = _$rootScope_.$new();
    $controller = _$controller_;
  }));

  it('starts with two todos', function() {
    $controller('TodoCtrl', { $scope: $scope });
    expect($scope.todos.length).toBe(2);
  });

  it('addTodo pushes and clears the input', function() {
    $controller('TodoCtrl', { $scope: $scope });
    $scope.todoText = 'New';
    $scope.addTodo();
    expect($scope.todos.length).toBe(3);
    expect($scope.todoText).toBe('');
  });
});

Einen Service testen

Den zu testenden Service und $httpBackend aus angular-mocks injizieren. expectGET(url).respond(data) setzt eine Fake-Antwort auf; flush() löst ausstehende Anfragen synchron auf. verifyNoOutstandingExpectation() in afterEach fängt unerfüllte Erwartungen. So sind $http-basierte Services vollständig testbar ohne echten Server.

angularjs
describe('UserService', function() {
  var UserService, $httpBackend;

  beforeEach(module('myApp'));
  beforeEach(inject(function(_UserService_, _$httpBackend_) {
    UserService = _UserService_;
    $httpBackend = _$httpBackend_;
  }));

  afterEach(function() { $httpBackend.verifyNoOutstandingExpectation(); });

  it('list() fetches users', function() {
    $httpBackend.expectGET('/api/users').respond([{ name: 'Ada' }]);
    var users;
    UserService.list().then(function(u) { users = u; });
    $httpBackend.flush();          // resolve the pending request
    expect(users.length).toBe(1);
  });
});

Eine Directive testen

Ein Stück HTML mit $compile(html)(scope) kompilieren, dann scope.$digest() ausführen, um Bindings auszuwerten und Directives zu verlinken. Auf dem resultierenden jqLite-Element assertionen (el.find, el.text, el.attr). Für templateUrl $httpBackend.expectGET verwenden, um das Template zu liefern, dann vor dem Digest flushen. Isolate-Scope über el.isolateScope() testen.

angularjs
describe('greeting directive', function() {
  var $compile, $rootScope;
  beforeEach(module('myApp'));
  beforeEach(inject(function(_$compile_, _$rootScope_) {
    $compile = _$compile_; $rootScope = _$rootScope_;
  }));

  it('renders the template', function() {
    var scope = $rootScope.$new();
    scope.name = 'Ada';
    var el = $compile('<greeting name="name"></greeting>')(scope);
    scope.$digest();              // process watchers / bindings
    expect(el.find('h1').text()).toContain('Ada');
  });
});

$httpBackend-Mocking

expectGET (und expectPOST/usw.) assertionen die Anfrage und schlagen fehl, wenn sie nicht gemacht wird; whenGET liefert still Daten, wenn aufgerufen, und ignoriert sonst. expect für 'das sollte passieren'-Assertionen, when fürs Setup. flush() löst ausstehende Anfragen der Reihe nach auf. verifyNoOutstanding* immer in afterEach aufrufen, um Abweichungen zu finden.

angularjs
// EXPECT: a specific request must happen (asserts it was made)
$httpBackend.expectGET('/api/users').respond(200, [{ id: 1 }]);
// WHEN:  just stub a request if it happens (no assertion)
$httpBackend.whenGET('/api/users').respond(200, [{ id: 1 }]);

// flush triggers all pending requests:
$httpBackend.flush();

// verify nothing was left unflushed:
$httpBackend.verifyNoOutstandingExpectation();
$httpBackend.verifyNoOutstandingRequest();
19

Dependency Injection

DI-Grundlagen

Angulars DI löst Dependencies, indem es Funktionsparameternamen inspiziert. Dieser 'implizite' Stil ist kurz, bricht aber bei Minification (Parameternamen werden verkürzt). Für Prototypen/Demos okay. In Produktion einen der Annotations-Stile verwenden — Inline-Array oder $inject — oder mit ng-annotate automatisieren.

angularjs
// services are injected by NAME into the constructor's parameters
app.controller('A', function($scope, $http, UserService) { /* ... */ });

// Angular inspects the parameter names to resolve dependencies.
// works in development but BREAKS after minification (see below).

Inline-Array-Annotation

Der verbreitetste minification-sichere Stil: ein Array übergeben, dessen Elemente die Service-Namen (als Strings) sind, mit dem Konstruktor am Ende. Die Strings überstehen die Minification, also löst Angular korrekt auf. Für jeden Code verwenden, der minifiziert wird. Von Hand mühsam — ng-annotate oder babel-Plugins ergänzen es automatisch.

angularjs
app.controller('A', ['$scope', '$http', 'UserService',
  function($scope, $http, UserService) {
    // parameter names no longer matter; the strings drive DI
    $scope.users = UserService.list();
  }
]);

$inject-Eigenschafts-Annotation

Ein $inject-Array mit Service-Namen-Strings an die Konstruktorfunktion hängen. Angular liest es zur Auflösung der Dependencies und ignoriert die Parameternamen. Das hält die Funktionsdeklaration lesbar und erlaubt Wiederverwendung desselben Konstruktors. ng-annotate kann $inject beim Build automatisch aus Parameternamen erzeugen.

angularjs
function ACtrl($scope, UserService) {
  $scope.users = UserService.list();
}
ACtrl.$inject = ['$scope', 'UserService'];   // explicit list

app.controller('A', ACtrl);

// equivalent to the inline array form; useful when you want
// a separately-declared, reusable constructor function.

$injector-Service

$injector ist der DI-Container: .get(name) gibt ein Singleton zurück, .annotate(fn) die Dependency-Liste, .instantiate/.invoke bauen/ruft Funktionen mit ihren Dependencies auf. In App-Code selten nötig, aber nützlich in dynamischen Szenarien (Services nach Namen laden) und in eigenen Directives oder Router-Resolve.

angularjs
// resolve and instantiate on demand
var svc = $injector.get('UserService');          // retrieve singleton
var fn  = $injector.annotate(MyCtrl);            // [' $scope', ...] via reflection
var inst = $injector.instantiate(MyCtrl);        // 'new' with DI
var res  = $injector.invoke(MyCtrl, context);    // call with DI

// list all registered service names (debug)
// $injector has modules / providers info

ng-annotate (Build-Zeit)

ng-annotate ist ein Build-Zeit-Tool, das Inline-Array-Annotationen automatisch ergänzt, sodass man sauberes implizites DI schreibt und minification-sicheren Code ausliefert. /* @ngInject */ für knifflige Fälle verwenden. Integriert sich mit gulp, grunt, webpack, babel. Der Nachfolger ng-annotate-patched pflegt die Unterstützung moderner Toolchains.

angularjs
// Write clean code with a hint comment:
app.controller('A', /* @ngInject */ function($scope, UserService) {
  $scope.users = UserService.list();
});

// ng-annotate (run by your build tool) rewrites it to:
app.controller('A', ['$scope', 'UserService', function($scope, UserService) {
  $scope.users = UserService.list();
}]);

Strict-DI-Modus

ng-strict-di lässt implizite (unannotierte) Dependency-Injection zur Laufzeit werfen, sodass man minification-unsicheren Code in der Entwicklung statt in Produktion findet. In Dev und Tests aktiv lassen. Es kostet leicht Performance (zusätzliche Checks), wird in Produktions-Builds meist entfernt.

angularjs
<html ng-app="myApp" ng-strict-di>
  ...
</html>

// or when bootstrapping manually:
angular.bootstrap(root, ['myApp'], { strictDi: true });

// in strict-DI mode, any service using IMPLICIT (unannotated) DI
// throws an error, catching minification bugs during development.
20

Best Practices & Performance

controllerAs verwenden

controllerAs macht explizit, welcher Controller jede Eigenschaft besitzt, vermeidet Primitive-Shadowing durch Scope-Vererbung und bringt näher ans Angular-2+-'Component'-Modell. An this (aliasiert) binden statt $scope. Für Components ist $ctrl der Standard-Alias — konsistent verwenden.

angularjs
<!-- prefer controllerAs over $scope -->
<div ng-controller="UsersCtrl as users">
  <li ng-repeat="u in users.list">{{ u.name }}</li>
</div>

app.controller('UsersCtrl', function(UserService) {
  // 'this' is exposed as 'users' in the template
  this.list = UserService.list();
  this.remove = function(id) { UserService.remove(id); };
});

One-time-Binding (::)

Einen Ausdruck mit :: präfixieren, um ihn zum one-time binding zu machen: Angular wertet ihn einmal aus und entfernt den Watcher, sobald er definiert ist. Für Daten, die sich nicht ändern (Titel, Zeitstempel, statische Listen), senkt das die Watcher-Zahl deutlich — der größte einzelne Performance-Hebel in AngularJS-Apps.

angularjs
<!-- static data: bind once, drop the watcher -->
<h1>{{ ::conference.name }}</h1>
<span>{{ ::user.createdAt | date }}</span>

<!-- ng-repeat over a static list -->
<li ng-repeat="item in ::staticItems">{{ item.label }}</li>

<!-- less watchers = faster digest for the whole app -->

track by in ng-repeat

Ohne track by nutzt Angular einen internen $$hashKey zum Matchen von Elementen — bei Array-Änderungen kann es DOM für unveränderte Elemente neu rendern und neu erzeugen, wobei Kind-Zustand verloren geht. track by u.id gibt eine stabile Identität, damit Angular Knoten wiederverwendet. Essenziell für Performance bei großen Listen und behebt 'ng-repeat duplicates'-Fehler.

angularjs
<!-- BAD: Angular uses $$hashKey, re-renders everything on change -->
<li ng-repeat="u in users">{{ u.name }}</li>

<!-- GOOD: stable identity -> Angular reuses DOM nodes -->
<li ng-repeat="u in users track by u.id">{{ u.name }}</li>

<!-- for primitives, use $index (only if list doesn't reorder) -->
<li ng-repeat="n in nums track by $index">{{ n }}</li>

Logik in Services verlagern

Controller sind schwer testbar und an $scope gebunden; Services sind Singletons, injizierbar und unit-testbar. Geschäftslogik, Datenzugriff und gemeinsamer Zustand in Services; Controller konzentrieren sich aufs Verdrahten der View mit diesen Services. Diese Trennung erlaubt auch mehreren Controllern, dieselbe Logik zu nutzen.

angularjs
// BAD: logic crammed in the controller
app.controller('BadCtrl', function($scope) {
  $scope.calc = function() { /* 50 lines of business logic */ };
});

// GOOD: controller delegates to a testable service
app.controller('GoodCtrl', function(PriceService) {
  this.total = PriceService.calcTotal(this.items);   // thin
});

app.factory('PriceService', function() {
  return { calcTotal: function(items) { /* ... */ } };
});

Bind once / Watcher reduzieren

Jedes {{ }} und die meisten Bindings erzeugen einen Watcher, der bei jedem Digest läuft. Funktionsaufrufe in Bindings vermeiden (sie laufen je Digest neu, auch bei unveränderten Inputs) — vorab berechnen und das Ergebnis speichern. one-time binding (::), track by und Controller-seitige Berechnung kombinieren, um Watcher-Zahlen auf großen Seiten niedrig zu halten.

angularjs
<!-- compute once in the controller, render many times -->
app.controller('Ctrl', function() {
  this.sortedUsers = this.users.slice().sort(byName); // do it once
});

<!-- avoid function calls in bindings: they re-run each digest -->
<!-- BAD:  {{ heavyCompute() }} -->
<!-- GOOD: compute once, bind the result -->
<p>{{ cachedResult }}</p>

Modul-Organisation

Nach Feature organisieren (nicht nach Dateityp), sodass jedes Feature ein in sich geschlossenes Modul mit Controller, Service, Template, Routen und Tests ist. Das Root-App-Modul komponiert nur die Feature-Module. Das hält zusammengehörigen Code zusammen, macht Features app-übergreifend wiederverwendbar und skaliert weit besser als ein einzelnes Riesenmodul.

angularjs
// split features into sub-modules, each self-contained
angular.module('myApp.users', ['myApp.common']);
angular.module('myApp.posts', ['myApp.common']);
angular.module('myApp', ['myApp.users', 'myApp.posts', 'ngRoute']);

// file layout per feature:
//   users/users.module.js
//   users/users.controller.js
//   users/users.service.js
//   users/users.html
//   users/users.routes.js
//   users/users.spec.js

Was this helpful?