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.
<!-- 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.
<!-- 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.
<!-- 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.
<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.
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;
};
}]);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.
// 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 moduleModul-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.
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.
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.
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.
// 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 */ } };
}]);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).
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.
<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.
// 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).
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.
<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.
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
});
}]);$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.
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.
<!-- 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.
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.
// 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.
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 hierarchyIsolate-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.
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>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.
<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.
<!-- 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 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.
// 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.nameFilter 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.
<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.
<!-- 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>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.
<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.
<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.
<!-- 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.
<!-- 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.
<!-- 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.
<!-- 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>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.
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.
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.
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.
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.
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.
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>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.
<p>{{ 1234.5 | number:2 }}</p> <!-- 1,234.50 -->
<p>{{ 9.99 | currency:'USD' }}</p> <!-- $9.99 -->
<p>{{ 128 | currency:'€' }}</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).
<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.
<!-- 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.
<!-- 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.
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.
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, '$');
}]);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.
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.
$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.
// 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.
// $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.
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.
// 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 thisFactories, 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.
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.
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.
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.
// 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.
// 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.
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
}]);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.
<!-- 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('').
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.
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.
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.
$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.
$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 -->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.
<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.
<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.
<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.
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.
<!-- 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.
<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
};
}]);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.
<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.
<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.
<!-- 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.
<!-- 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.
<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 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();
};
}]);$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.
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.
$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.
$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.
// 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.
// $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.
// 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.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.
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: ... }).
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.
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.
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.
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.
// 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(); } };
});$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.
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.
// $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.
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.
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.
// 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.
// 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 updatesAnimationen (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.
<!-- 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.
/* .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.
/* 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.
/* 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.
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).
<!-- 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 onTesten (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.
// 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.jsJasmine-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.
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.
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.
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.
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.
// 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();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.
// 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.
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.
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.
// 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 infong-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.
// 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.
<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.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.
<!-- 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.
<!-- 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.
<!-- 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.
// 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.
<!-- 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.
// 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.jsVerwandte AngularJS-Snippets
Copy-paste ready code for common tasks.
Module & Controller
Define a module and a controller with scope methods.
Scope Inheritance
Prototypal scope inheritance between parent and child controllers.
Custom Directives
Attribute directive and element directive with isolated scope.
Services & Factories
Factory and service singletons for shared state and logic.
Routing (ngRoute)
Configure routes with templates, controllers, and resolve guards.
Custom Filters
Chainable filters for formatting values in templates.
Forms & Validation
Form with required, minlength, email validation, and disabled submit.
$http Service
Promise-based HTTP requests with config object and error handling.
Was this helpful?