Primeros pasos
Configuración y bootstrap
AngularJS (1.x) se incluye mediante una etiqueta script. ng-app arranca la aplicación y ng-controller conecta un controlador a un subárbol del DOM. Las llaves dobles {{ }} son expresiones de Angular que renderizan los datos del modelo.
<!-- 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 y auto-bootstrap
ng-app con un nombre de módulo auto-arranca AngularJS en DOMContentLoaded. ng-strict-di exige anotaciones de dependencia explícitas, detectando temprano los errores de minificación en desarrollo. Solo un ng-app se auto-arranca por página.
<!-- 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) -->Bootstrap manual
Usa angular.bootstrap() cuando necesites retrasar el arranque (por ejemplo, esperando la carga asíncrona de módulos o una configuración obtenida por red). Así puedes arrancar varias apps de Angular en una misma página, cada una sobre su propio elemento raíz.
<!-- HTML has NO ng-app attribute -->
<div id="appRoot">
{{ message }}
</div>
<script>
angular.element(document).ready(function() {
angular.bootstrap(document.getElementById('appRoot'), ['myApp']);
});
</script>Primer data binding
Con ng-app y sin nombre de módulo, Angular se ejecuta en modo 'auto' con el módulo ng por defecto. ng-model enlaza el input a una propiedad llamada 'name' en el scope implícito, y {{ }} la renderiza en vivo. Este es el data binding bidireccional en su forma más simple.
<div ng-app>
<label>Your name:
<input type="text" ng-model="name">
</label>
<p>Hello {{ name || 'stranger' }}!</p>
</div>Fundamentos de módulos y controladores
angular.module('name', [deps]) crea un módulo; angular.module('name') recupera uno existente. La anotación de array en línea ['$scope', function($scope){}] mantiene el controlador a salvo de la minificación. Pasa siempre las dependencias explícitamente al módulo al crearlo.
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;
};
}]);Módulos
Crear vs recuperar un módulo
La forma con dos argumentos angular.module(name, deps) crea un módulo nuevo. La forma con un argumento angular.module(name) recupera uno definido previamente. Pasar [] dos veces por accidente borra en silencio los registros del módulo.
// 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 moduleDependencias del módulo
El array de dependencias lista los módulos cuyos providers se inyectan en este. Los módulos integrados como ngRoute son opcionales y deben listarse explícitamente (y cargar su script). Los submódulos permiten dividir una app grande en piezas reutilizables.
var app = angular.module('myApp', [
'ngRoute', // built-in routing
'ngAnimate', // animation hooks
'ui.router', // 3rd-party router
'myApp.common', // your own sub-module
]);Bloque config
config() se ejecuta durante el registro de providers, antes de crear cualquier instancia de servicio. Es el único lugar donde puedes inyectar y configurar Providers (por ejemplo, $routeProvider, $locationProvider). Úsalo para configurar rutas, activar el modo HTML5 o registrar validadores personalizados.
app.config(['$routeProvider', function($routeProvider) {
$routeProvider
.when('/home', { templateUrl: 'home.html' })
.when('/about', { templateUrl: 'about.html' })
.otherwise({ redirectTo: '/home' });
}]);Bloque run
run() se ejecuta después de crear el injector y configurar los providers — es el punto de entrada 'main' de la app. Inyecta instancias (no providers). Se suele usar para registrar listeners globales de $rootScope para cambios de ruta o comprobaciones de autenticación.
app.run(['$rootScope', 'AuthService', function($rootScope, AuthService) {
$rootScope.$on('$routeChangeStart', function(event, next) {
if (!AuthService.isAuthenticated()) {
event.preventDefault();
}
});
}]);Constants y values
constant() registra un valor que también puede inyectarse en bloques config() — ideal para configuración que los providers necesitan. value() solo es inyectable en construcciones de la fase run (servicios, controladores). Usa constant para la configuración que debe estar disponible pronto.
// 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 */ } };
}]);Controladores
Controlador básico
Los controladores establecen el estado inicial de $scope y añaden comportamiento (funciones). Mantén los controladores ligeros — la lógica de negocio pertenece a los servicios. El constructor del controlador se ejecuta cada vez que se necesita una nueva instancia (por ejemplo, por cada uso de ng-controller).
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;
};
}]);Sintaxis controllerAs
controllerAs publica la instancia del controlador en el scope bajo un alias (main). Usa this en lugar de $scope para propiedades y funciones. Esto evita las trampas de la herencia de $scope y hace explícito de qué controlador viene cada propiedad en vistas anidadas.
<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>DI a salvo de la minificación
Los minificadores renombran los parámetros de las funciones, rompiendo la inferencia de dependencias por nombre de Angular. La anotación de array en línea lista los nombres de los servicios como cadenas antes de la función, así los nombres sobreviven a la minificación. Usa siempre esta anotación o ng-annotate / $inject.
// 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) { /* ... */ });Anotación con la propiedad $inject
Una alternativa al array en línea: adjunta un array $inject con los nombres de los servicios a la función constructora. Esto mantiene la declaración de la función legible y reutilizable. Ambos estilos son equivalentes — elige uno y sé consistente (o automatízalo con ng-annotate).
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);Controladores anidados y herencia
Los scopes hijos heredan prototípicamente de los scopes padres, así que un controlador hijo lee las propiedades del padre. Sin embargo, asignar un primitivo en el hijo crea una nueva propiedad local que oculta a la del padre en lugar de actualizarla — una trampa común. Prefiere objetos (notación de punto) o controllerAs para evitarlo.
<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
}]);Limpieza del controlador ($destroy)
Escucha el evento $destroy en $scope para ejecutar la limpieza cuando el scope del controlador se destruye (por ejemplo, al navegar fuera). Cancela los temporizadores $interval/$timeout, desvincula listeners de window y libera referencias para evitar fugas de memoria. Angular limpia automáticamente sus propios watchers del scope.
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
Fundamentos de $scope
$scope es el pegamento entre el controlador y la vista — contiene el modelo y el comportamiento a los que la plantilla se enlaza. Angular crea un scope nuevo para cada controlador; las expresiones de la plantilla se evalúan contra ese scope (y sus padres).
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()"Herencia de scopes (prototípica)
Los scopes hijos heredan del scope padre mediante la cadena de prototipos de JavaScript. Leer una propiedad del padre funciona, pero asignar un primitivo (por ejemplo, $scope.name = 'x') en el hijo crea una copia local que oculta al padre. Enlaza a objetos (user.name) para que las escrituras se propaguen por la cadena.
<!-- 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 es la cima de la jerarquía de scopes; los demás descienden de él. Las propiedades puestas aquí son visibles en todas las plantillas. Úsalo con moderación para valores verdaderamente globales (nombre de la app, flag de sesión) — el abuso crea acoplamiento oculto y hace difícil rastrear el estado.
app.run(['$rootScope', function($rootScope) {
$rootScope.appName = 'MyApp'; // available everywhere
$rootScope.version = '1.0';
}]);
<!-- any template -->
<footer>© {{ appName }} {{ version }}</footer>Eventos del scope: $emit / $broadcast / $on
$emit dispara un evento que sube hasta $rootScope; $broadcast baja hasta los scopes hijos. $on registra un listener y devuelve una función de desregistro. Pasa datos mediante el segundo argumento. Desvincula los listeners en $destroy para evitar fugas.
// 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) crea un scope hijo (o aislado); $id es un id numérico único; $parent referencia al scope padre. Se usan principalmente dentro de directivas. Llama siempre a $destroy() en los scopes creados manualmente para eliminar watchers y evitar fugas de memoria.
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 hierarchyScope aislado (avance de directivas)
Definir scope: {} en una directiva crea un scope aislado que NO hereda prototípicamente de su padre — esencial para componentes reutilizables. El padre se comunica solo mediante los enlaces declarados (@, =, &). Esto evita que los componentes lean o contaminen accidentalmente el scope circundante.
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>Expresiones
Expresiones básicas
Las expresiones de Angular son parecidas a JavaScript pero se evalúan contra $scope (no contra window). Soportan aritmética, concatenación de cadenas, acceso a miembros y ternarios. A diferencia de JS, undefined/null se muestran como cadena vacía (sin el texto 'undefined'). El operador de encadenamiento opcional NO está soportado.
<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 ?. -->Expresión vs JavaScript
Las expresiones son más limitadas que JS: sin sentencias (if/for/while), sin new/throw, sin comas, sin definiciones de funciones, sin operadores bit a bit en algunas versiones. Se evalúan con $scope como contexto y se tragan los errores en silencio (se registran en $exceptionHandler). Esto mantiene la plantilla segura y declarativa.
<!-- 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 -->Enlace de un solo uso (::)
El prefijo :: crea un enlace de un solo uso: Angular evalúa la expresión y, una vez definida (no undefined), elimina el watcher. Esto reduce drásticamente el número de watchers en el ciclo de digest, mejorando el rendimiento de los datos que no cambian tras la carga inicial.
<!-- 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 y $parse
$scope.$eval(expr) analiza y ejecuta una cadena de expresión contra el scope. $parse compila una expresión una vez en una función getter/setter reutilizable — mucho más eficiente que reevaluar una cadena repetidamente. Usa $parse dentro de directivas/servicios que consumen enlaces de expresión.
// 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.nameFiltros en expresiones
El pipe | aplica un filtro a la expresión; varios filtros se encadenan de izquierda a derecha. Los argumentos se pasan con dos puntos. Los filtros son cómodos pero se reejecutan en cada digest — para listas grandes, filtra en el controlador mediante $filter o una propiedad calculada para mejor rendimiento.
<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 y ng-cloak
Antes de que Angular arranque, el navegador muestra el texto crudo {{ }} ('flash de contenido sin compilar'). ng-bind escribe el valor en el texto del elemento solo después de que Angular se ejecute, evitando el destello. ng-cloak combinado con una regla CSS oculta los elementos hasta que Angular los ha compilado.
<!-- 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>Directivas integradas
ng-model (enlace bidireccional)
ng-model enlaza los inputs del formulario a una propiedad del scope con sincronización bidireccional: los cambios del input actualizan el modelo, y los del modelo actualizan el input. Funciona con input, textarea, select y checkbox/radio. Enlaza siempre a una propiedad con punto (user.name) para evitar problemas de ocultamiento de primitivos.
<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 clona el elemento por cada ítem de una colección. Se exponen $index, $first, $last, $middle, $even, $odd. Usa siempre track by para dar a Angular una identidad estable y que pueda reutilizar nodos del DOM cuando el array cambia — así evitas re-renderizaciones innecesarias y corriges los errores de claves duplicadas.
<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 inserta o elimina condicionalmente el elemento (y sus scopes hijos) del DOM — costoso de alternar pero barato cuando está oculto. ng-show/ng-hide solo cambian una clase CSS, manteniendo el elemento en el DOM — barato de alternar pero el elemento siempre está compilado. Prefiere ng-if para contenido que casi nunca se muestra.
<!-- 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 y ng-style
ng-class acepta un objeto (las claves verdaderas se vuelven clases), un array de nombres de clase o una cadena. ng-style toma un objeto que mapea nombres de propiedades CSS a valores. Ambos se reevalúan en cada digest, así que para estilos estáticos prefiere un atributo class normal — usa estos para estilos guiados por estado.
<!-- 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 y ng-init
ng-bind-template enlaza varias expresiones al texto de un elemento sin {{ }} crudo. ng-init evalúa una expresión una vez cuando el elemento se inicializa — útil para demos pero desaconsejado en apps reales porque pone lógica en el marcado. Establece el estado inicial en el controlador en su lugar.
<!-- 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
Usa ng-src y ng-href en lugar de src='{{ }}' para que el navegador no haga una petición contra la URL literal '{{ }}' antes de que Angular la interpole. ng-disabled alterna el atributo disabled según una expresión — perfecto para desactivar botones de envío mientras el formulario es inválido o hay una petición en curso.
<!-- 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>Directivas personalizadas
Directiva básica
Una directiva extiende el HTML. restrict: 'E' la convierte en un elemento personalizado (<greeting>); 'A' en un atributo. Las directivas más simples solo devuelven una plantilla. Usa por defecto los restrict de elemento/atributo; los de clase/comentario son raros. La buena práctica moderna favorece componentes para directivas basadas en plantillas.
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> -->Objeto de definición de directiva (DDO)
El Directive Definition Object configura cada aspecto: restrict, scope (aislado o no), template/templateUrl, transclude, controller y la función link. templateUrl carga la plantilla vía $http (con caché); template va en línea. Mantén la manipulación del DOM en link y la lógica del view-model en el controlador.
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 */ }
};
});Enlaces de scope aislado (@ = &)
@ lee el atributo como cadena (unidireccional, padre->hijo, interpolado). = crea un enlace bidireccional a la expresión del padre. & expone una función que ejecuta una expresión en el scope del padre — se usa para callbacks de eventos. Estos tres enlaces son el corazón de los componentes de directivas reutilizables.
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>Función link
La función link se ejecuta después de compilar el elemento de la directiva. Úsala para manipulación directa del DOM, listeners de eventos (mediante el .on de jQuery Lite) y para observar atributos interpolados con attrs.$observe. scope es el scope de la directiva, element es el nodo del DOM envuelto en jqLite y attrs son los atributos normalizados.
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
});
}
};
});Función compile
La función compile se ejecuta una vez sobre el elemento de la plantilla original antes de que Angular lo clone para ng-repeat, etc. Úsala para transformaciones a nivel de plantilla que no necesitan el scope. Devuelve una función link (o un objeto pre/post link). La mayoría de directivas no necesitan compile — prefiere link para el trabajo por instancia.
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');
};
}
};
});Transclusión
transclude: true captura el contenido original del elemento y lo inserta en la plantilla donde aparezca ng-transclude. El contenido transcluido conserva su scope original (el del padre), no el scope aislado de la directiva. Esto permite a una directiva envolvente (panel, modal, tarjeta) envolver contenido arbitrario suministrado por quien la usa.
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>Filtros
Filtros integrados
Angular trae number, currency, date, lowercase, uppercase, json, limitTo, orderBy y filter. El argumento tras los dos puntos configura el filtro. currency acepta un símbolo ISO o un carácter personalizado. Los filtros se reejecutan en cada digest, así que cachea los cálculos pesados o calcula en el controlador.
<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 -->Filtro date
El filtro date formatea un objeto Date, una cadena ISO 8601 o milisegundos de época. Los formatos predefinidos incluyen 'short','medium','long','full','shortDate','mediumDate','shortTime'. Los formatos personalizados usan tokens: y (año), M (mes), d (día), H (hora), m (minuto), s (segundo), EEEE (día de la semana completo).
<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 -->Filtro filter (búsqueda en arrays)
El filtro filter selecciona los ítems del array que coinciden con una cadena, un objeto o una función predicado. Un objeto coincide con los ítems cuyos campos especificados contienen los valores dados. El tercer argumento true opcional fuerza coincidencia exacta. Para arrays grandes, filtra en el controlador para evitar reejecutar en cada digest.
<!-- 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>Filtro orderBy
orderBy ordena un array por un nombre de campo (prefijo '-' para descendente), un array de esos campos o una función comparadora. Crea un nuevo array ordenado en cada digest — para listas grandes, ordena una vez en el controlador y reutiliza. Combinado con filter permite interfaces de búsqueda + ordenación.
<!-- 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>Filtro personalizado
Registra una factoría de filtro con app.filter. La factoría devuelve una función que transforma el input (el valor antes del pipe) más los argumentos extra. Los filtros deben ser puros y sin efectos secundarios. Son inyectables, así que puedes depender de otros servicios dentro de la factoría.
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 -->Servicio $filter en controladores
Inyecta $filter para aplicar un filtro dentro de JS (controladores, servicios). Llama a $filter('name')(value, arg1, arg2). Esto evita reejecutar el filtro en cada digest y permite reutilizar el resultado. Útil cuando necesitas el valor filtrado en la lógica, no solo en la vista.
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, '$');
}]);Servicios ($http, $location, ...)
Fundamentos de $http
$http realiza peticiones XHR y devuelve una Promise. El valor resuelto es un objeto de respuesta con data, status, headers y config. .then maneja el éxito, .catch los errores. Desde Angular 1.6, los callbacks .success/.error se eliminaron — usa .then/.catch de promesas de forma consistente.
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 con configuración
Existen funciones de conveniencia para get/post/put/delete/patch/jsonp/head. Para control total, pasa un objeto de configuración: params se convierte en query string, headers fija las cabeceras de la petición y responseType controla cómo se parsea el body. $http aplica automáticamente las transformaciones por defecto (parseo JSON).
$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 */ });Servicio $location
$location es un envoltorio de window.location que se mantiene sincronizado con la URL del navegador y el ciclo de digest. Úsalo para leer o cambiar path, parámetros de búsqueda y hash. Para activar las URLs bonitas de HTML5, configura $locationProvider.html5Mode(true) y añade una etiqueta <base>.
// 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 y $interval
$timeout y $interval son envoltorios conscientes del digest de setTimeout/setInterval — disparan $apply para que los cambios del scope se detecten. Cancélalos siempre en $destroy para evitar fugas y errores de 'digest sobre un scope destruido'. Pasa false como tercer argumento para saltarte el digest si no lo necesitas.
// $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 y $window / $document
$log es un envoltorio ligero de console que soporta log/info/warn/error/debug y puede decorarse para logging en producción. $window y $document envuelven los globales — inyéctalos siempre en lugar de llamar a window/document directamente, así las pruebas pueden simularlos y tu código se mantiene independiente del entorno.
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 y eventos globales
Usa $rootScope.$broadcast para eventos de toda la app (login/logout, cambio de tema). Los listeners de cualquier scope lo reciben. Para eventos que solo deben escuchar los listeners de $rootScope, $rootScope.$emit es más barato (no desciende). Evita abusar de los eventos globales — prefiere servicios con APIs explícitas para la mayoría de la comunicación.
// 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 y providers
factory()
factory() toma una función que devuelve la instancia del servicio — la factoría se ejecuta una vez (singleton) y el valor devuelto se comparte. Es la forma más común de crear un servicio: ideal para encapsular estado privado tras una API limpia. Lo que devuelvas (objeto, función, primitivo) se convierte en el servicio.
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() instancia el constructor con new, así que adjuntas las propiedades a this. Equivale a una factoría que devuelve una nueva instancia — ambos son singletons. Usa service() si prefieres el estilo constructor/clase; usa factory() cuando necesites devolver un objeto concreto o envolver algo.
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() es la receta de más bajo nivel: expone un objeto de fase de configuración (con setters) y una factoría $get que construye la instancia. Solo los providers son inyectables en bloques config() (con el sufijo 'Provider'). Usa provider() cuando un servicio necesita configuración antes de instanciarse; si no, prefiere factory().
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()
Ambos registran un valor inyectable simple. constant() está disponible durante la fase de configuración (así los providers pueden usarlo) y es inmutable. value() solo está disponible en la fase run. Regla práctica: usa constant para la configuración de la que dependen los providers; usa value para datos compartidos en tiempo de ejecución o helpers.
// 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
En el fondo, toda receta es un provider: la función de factory se convierte en $get, y service es una factoría que instancia el constructor con new. Elige por legibilidad: factory para la mayoría de los casos, service para clases estilo constructor, provider cuando necesites configuración previa a la instanciación. Los componentes solo consumen, así que la elección es interna.
// 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() intercepta la instanciación de un servicio existente — $delegate es la instancia original, que puedes envolver, extender o reemplazar. Úsalo para preocupaciones transversales (logging, caché, reporte de errores) sin tocar el servicio original. Los decoradores se ejecutan de forma perezosa, solo cuando el servicio se inyecta por primera vez.
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
}]);Enrutado (ngRoute y ui-router)
Configuración de ngRoute
ngRoute es el router integrado (en un archivo angular-route.js aparte). Registra rutas con .when(path, config) y un respaldo con .otherwise(). ng-view es el outlet donde se renderizan la plantilla y el controlador coincidentes. ngRoute solo soporta un outlet y URLs simples con :param — para vistas anidadas usa ui-router.
<!-- 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>Parámetros de ruta de ngRoute
$routeParams expone los segmentos de la URL (:id) como un objeto con claves de cadena — los valores son siempre cadenas, así que convierte los números con parseInt. Se actualiza tras un cambio de ruta. Para enlaces dinámicos usa ng-href. El prefijo hashbang por defecto es #! (desde 1.6); configúralo con $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" -->Eventos del ciclo de vida de ngRoute
ngRoute emite $routeChangeStart (cancelable con event.preventDefault), $routeChangeSuccess y $routeChangeError. Los argumentos 'next'/'current' llevan la configuración de la ruta (con los resultados de resolve). Úsalos para guards de autenticación, indicadores de carga y títulos de migas de pan. Los rechazos de resolve disparan $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);
});
}]);Estados de ui-router
ui-router organiza la app en estados con nombre (no rutas URL). ui-sref enlaza por nombre de estado y parámetros, y ui-view es el outlet. Los estados pueden anidarse y tener sus propias URLs. Esto desacopla la navegación de las URLs y soporta vistas múltiples/con nombre — mucho más potente que ngRoute para apps reales.
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>resolve y estados anidados de ui-router
resolve mapea claves a promesas; el controlador no se instancia hasta que todas se resuelven. Si un resolve se rechaza, se dispara $stateChangeError y no se entra al estado. Los valores de resolve son inyectables en el controlador por su clave. Los estados hijos heredan y pueden acceder a los resolve del padre — útil para precargar datos.
$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
}]);Vistas con nombre múltiples de ui-router
ui-router puede renderizar varios outlets ui-view con nombre por estado. Las claves del mapa views coinciden con los nombres de los ui-view en la plantilla; la clave de cadena vacía apunta al outlet sin nombre. Esto permite que un solo estado componga varias regiones (header, sidebar, main) — imposible con el único ng-view de ngRoute.
$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 -->Formularios y validación
Formulario con ng-model
Dale al formulario un atributo name para exponer su estado de validación en el scope. novalidate desactiva las burbujas integradas del navegador para que Angular controle la validación. Cada input con nombre publica su propio estado (myForm.email.$valid, $dirty, $error). ng-model es necesario para que la validación siga al input.
<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 -->Estados de validación
Cada input expone $pristine/$dirty (¿cambió?), $touched/$untouched (¿perdió el foco?), $valid/$invalid y $error (un mapa de validadores fallidos). El formulario agrega estas propiedades: myForm.$invalid es true si algún input es inválido. Muestra los mensajes solo tras $touched o $dirty para no regañar al usuario antes de que escriba.
<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 -->Validadores integrados
Validadores integrados: required, type=email/url/number, min/max, ng-minlength/ng-maxlength, ng-pattern. Cada validador fallido establece una clave en $error (por ejemplo, $error.required, $error.minlength, $error.pattern). Escapa las barras invertidas en las expresiones regulares de ng-pattern dentro de atributos HTML.
<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}$/">Validador personalizado (directiva)
Añade validadores personalizados mediante una directiva que requiere ngModel y registra una función en ctrl.$validators. Devuelve true si es v álido, false si no — el fallo aparece en $error bajo tu clave (aquí 'even'). Para validación asíncrona, usa ctrl.$asyncValidators que devuelve una promesa.
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 muestra el primer error que coincide (o varios a la vez con ng-messages-multiple). Es mucho más limpio que apilar ng-if por cada validador. Extrae los mensajes compartidos a un parcial e inclúyelo con ng-messages-include='messages.html'. Funciona bien tanto con claves de validadores integrados como personalizados.
<!-- 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 -->Envío del formulario
ng-submit se dispara al enviar el formulario (tecla Enter o un botón type='submit') y solo si las validaciones de ng-model pasan, salvo que lo anules. Pasa myForm.$valid al manejador como comprobación de seguridad. novalidate garantiza que Angular (y no el navegador) dirige la validación. Desactiva el botón con ng-disabled para evitar envíos dobles.
<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
};
}]);Eventos (ng-click, ng-change, ...)
ng-click
ng-click evalúa una expresión al hacer clic en el elemento. $event es el evento nativo del DOM, así que puedes llamar stopPropagation/preventDefault sobre él — aunque prefiere ng-submit para formularios y las directivas integradas cuando sea posible. ng-click funciona en cualquier elemento, no solo en botones.
<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 se dispara después de que ng-model haya actualizado el modelo — así que $scope.country ya tiene el nuevo valor. Requiere ng-model en el mismo elemento. Úsalo para reaccionar a cambios de input/select/checkbox (dropdowns en cascada, filtrado en vivo) sin montar tu propio listener de change.
<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 y la familia ng-focus/blur
ng-submit maneja el envío del formulario. Angular también expone directivas de evento para muchos eventos del DOM: ng-focus, ng-blur, ng-change, ng-copy, ng-cut, ng-paste, ng-keydown/up/press, ng-mousedown/up/enter/over/leave/move y ng-dblclick. Cada una evalúa una expresión, con $event disponible.
<!-- 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">Eventos de teclado y ratón
Angular ofrece ng-keydown/ng-keypress/ng-keyup y ng-mousedown/up/enter/leave/over/move, además de ng-dblclick. Cada una pasa $event, así que puedes inspeccionar $event.keyCode o $event.shiftKey. Para atajos en toda la app, enlaza en $document o $window dentro de un servicio en lugar de esparcir manejadores por las plantillas.
<!-- 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>Objeto $event
$event es el evento nativo del DOM reenviado a tu manejador. Puedes leer target, coordenadas, teclas modificadoras y llamar preventDefault/stopPropagation. Resiste la tentación de meter lógica pesada en los manejadores de clic — llama a una función del controlador/servicio en su lugar. $event está disponible en todas las directivas de evento.
<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();
};
}]);Modificadores de eventos (manual)
A diferencia de Vue/Angular 2+, AngularJS no tiene modificadores .stop/.prevent/.once — llamas tú a las funciones del evento dentro del manejador. Es más verboso pero explícito. Para comportamientos frecuentes (preventDefault automático al enviar), ng-submit ya lo hace por ti en los formularios.
<!-- 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 registra un listener que se ejecuta cada vez que el valor observado cambia durante un digest. El primer argumento puede ser una expresión de cadena o una función; el callback recibe (newVal, oldVal). $watch devuelve una función de desregistro — llámala para dejar de observar y evitar fugas, especialmente en directivas.
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 observa un nivel de un array u objeto: se dispara cuando se añaden/eliminan/reemplazan ítems, pero NO compara profundamente las propiedades de los ítems. Es mucho más barato que el $watch profundo (tercer argumento true). Úsalo para arrays de primitivos o cuando solo te importa la pertenencia a la lista, no el contenido profundo.
$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.$watch profundo (tercer argumento)
Pasar true como tercer argumento hace que $watch haga una comparación profunda de valores — se dispara cuando cambia cualquier propiedad anidada. Es costoso (recorre el objeto entero en cada digest). Prefiere observar una ruta específica o usar $watchCollection. Reserva la observación profunda para objetos pequeños donde de verdad la necesites.
$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
El código fuera del mundo de Angular (setTimeout crudo, XHR sin $http, eventos de jQuery, callbacks de Promise) actualiza el modelo pero Angular no se entera — llama a $apply() para disparar un $digest. La forma de función envuelve los cambios con manejo de excepciones y ejecuta un solo digest. Dentro de los servicios de Angular ($http, $timeout) el $apply ya está hecho — no lo apliques dos veces.
// 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 y $timeout (apply seguro)
Prefiere $evalAsync o $timeout(fn, 0) a un $apply manual cuando no estés seguro de si ya hay un digest en curso — evitan los errores de 'digest already in progress'. $evalAsync lo agrupa en el digest actual; $timeout lo difiere al siguiente tick. Usa $timeout cuando además necesites que el DOM ya se haya renderizado.
// $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);El ciclo $digest explicado
$digest es el bucle que propaga los cambios del modelo a la vista: reevalúa cada watcher hasta que los valores dejan de cambiar (dirty-checking), con un límite de 10 iteraciones. Como cada watcher se ejecuta en cada digest, el rendimiento escala con la cantidad de watchers. Reduce los watchers con el enlace de un solo uso (::), track by y moviendo los cálculos al controlador.
// 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.Componentes (.component())
Fundamentos de .component()
.component() es azúcar sobre directive, optimizado para componentes basados en plantillas. Por defecto usa restrict 'E', scope aislado y controllerAs '$ctrl' — así que usa this (con el alias $ctrl) en lugar de $scope. bindings reemplaza a scope:{...}; '<' (entrada unidireccional) se prefiere sobre '=' para los inputs desde la 1.5.
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>Componente con controlador y bindings
El controlador de un componente usa this (con el alias $ctrl en la plantilla). bindings declara inputs ('<', '=') y outputs ('&'). El unidireccional '<' se prefiere para los inputs. Los outputs usan '&' — llámalos con un objeto de argumento que se convierte en las variables locales de la expresión del padre: 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 }); };
}
});Hooks del ciclo de vida del componente
Los hooks de componentes de AngularJS 1.5+ reflejan el ciclo de vida de Angular 2+: $onInit (inicialización), $onChanges (cambios de bindings, con isFirstChange), $doCheck (cada digest), $postLink (tras enlazar el DOM hijo), $onDestroy (limpieza). Úsalos en lugar de meter lógica en el constructor — hacen el comportamiento del componente explícito y testeable.
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 */ };
}
});Detalle de $onChanges
$onChanges se dispara cada vez que cambia la referencia de un enlace unidireccional ('<'), con un objeto changes: cada clave tiene currentValue, previousValue e isFirstChange(). NO se dispara por mutaciones del mismo objeto (porque la referencia no cambia) — para eso usa $doCheck. Siempre se dispara una vez en la inicialización con isFirstChange() en 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());
}
};
}
});Transclusión en componentes
Define transclude: true e incluye ng-transclude en la plantilla para permitir que quien usa el componente inyecte contenido. En componentes, la transclusión multi-slot también está soportada vía transclude: { slotName: 'elementName' }. La transclusión te permite construir envoltorios reutilizables (paneles, modales, tarjetas) cuyo cuerpo lo aporta el padre.
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>Componente vs directiva
Usa componentes para cualquier cosa que renderice una plantilla — son más simples y te acercan al modelo de Angular 2+ (scope aislado, this/controllerAs, hooks de ciclo de vida). Reserva las directivas para comportamientos tipo atributo sin plantilla (autofocus, disparador de tooltip, máscara de input) y para manipulación directa del DOM en 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(); } };
});Servicio de promesas $q
Fundamentos de $q.defer()
$q es la implementación de Promises de Angular (Promises/A+). Crea con $q.defer() y luego resolve(value) o reject(reason). La promesa es consciente del digest: la resolución dispara un $digest para que la vista se actualice. Prefiere $q sobre la Promise nativa cuando necesites el auto-digest de Angular; si no, la Promise nativa también sirve.
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 envuelve un valor simple o una promesa que no es de $q. $q.all espera un array u objeto de promesas y se resuelve con la misma forma de resultados. $q.reject(reason) es una forma cómoda de devolver una promesa rechazada (por ejemplo, para validación temprana en una cadena). Todas estas utilidades son conscientes del digest.
// $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'));Encadenar promesas
Devolver un valor desde .then lo pasa al siguiente manejador; devolver una promesa hace que la cadena espere. Un solo .catch maneja cualquier rechazo aguas arriba. .finally se ejecuta tanto en éxito como en fallo — perfecto para ocultar loaders. Cada manejador corre dentro del digest de Angular, así que las actualizaciones del scope funcionan sin más.
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 devuelve promesas
$http ya devuelve una promesa de $q, así que encadena .then para transformar la respuesta (a menudo extrayendo .data) y devolver un valor más limpio. Envolver $http en un servicio da a quienes lo llaman una API ordenada y centraliza el manejo de URL/base-url/errores. Los interceptores son otra forma de aplicar comportamiento transversal a $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; });Constructor de $q (estilo ES6)
Desde la 1.6, $q soporta la forma del constructor de Promise de ES6: $q(function(resolve, reject){...}). Es más conciso que $q.defer() y coincide con la sintaxis de la Promise nativa. Úsalo al envolver una única API asíncrona. La promesa resultante sigue siendo consciente del digest, así que las actualizaciones de la vista se disparan automáticamente al resolver.
// 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 Promise nativa
La diferencia clave: $q dispara un $digest al resolverse, la Promise nativa no. En apps modernas de AngularJS sobre navegadores evergreen, puedes usar la Promise nativa pero debes envolver las actualizaciones del modelo en $apply (o $evalAsync). Por consistencia y comodidad, prefiere $q dentro del código de Angular.
// 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 updatesAnimaciones (ngAnimate)
Configuración de ngAnimate
ngAnimate es un módulo aparte (su propio archivo JS). Una vez añadido como dependencia, mejora automáticamente las directivas integradas para que añadan clases CSS durante las transiciones enter/leave/move — tú solo escribes CSS. No hace falta JS para el caso común. Sin ngAnimate, estas directivas cambian el DOM al instante.
<!-- 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 -->Clases de transición CSS
ngAnimate añade dos clases por evento: una clase de inicio (por ejemplo, .ng-enter) y una clase -active (.ng-enter-active) un fotograma después. Define una transición CSS en la clase de inicio y el estado final en la clase activa — Angular elimina ambas cuando la transición termina. Es el enfoque de animación más simple y eficiente.
/* .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>Animaciones CSS keyframe
Puedes usar animaciones CSS @keyframes en lugar de transiciones — ngAnimate alterna las mismas clases .ng-enter/.ng-leave/.ng-move y el keyframe se ejecuta. Con keyframes solo necesitas la clase de inicio (no hace falta la -active) porque la animación dirige toda la secuencia. Ideal para efectos de rebote/spring.
/* 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>enter / leave / move de ng-repeat
Los ítems de ng-repeat reciben las clases .ng-enter (nuevos), .ng-leave (eliminados) y .ng-move (reordenados). Usa track by para que Angular pueda emparejar ítems entre cambios y animar los movimientos correctamente. Las animaciones escalonadas son posibles con .ng-enter-stagger / .ng-leave-stagger para retrasar cada ítem — genial para efectos de revelado de listas.
/* 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>Servicio $animate (animaciones JS)
app.animation(cssSelector, factory) registra una animación JS para los elementos que coinciden con el selector. Las funciones enter/leave/move/class reciben el elemento y un callback done. Útil cuando el CSS no basta (por ejemplo, jQuery.animate o una librería de física). Devuelve una función cancel para la limpieza. Las animaciones JS son más pesadas que CSS — prefiere CSS cuando puedas.
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>Desactivar animaciones
Desactiva las animaciones globalmente o por subárbol con $animate.enabled, o mediante la clase ng-animate-disabled. Es útil por rendimiento en listas grandes o para desactivar animaciones durante las pruebas. ng-animate-children permite a un padre optar por animar junto a sus hijos (por defecto, la animación de un padre omite las animaciones de los hijos).
<!-- 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 onTesting (Karma y Jasmine)
Esquema de configuración de Karma
Karma es el test runner estándar de AngularJS: lanza navegadores reales, carga tus scripts más angular-mocks y reporta los resultados de Jasmine. angular-mocks proporciona los helpers module() e inject() y servicios mock ($httpBackend). singleRun:true sale tras una ejecución (CI); omítelo para el modo watch.
// 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.jsFundamentos de Jasmine
Jasmine proporciona describe (suite), it (spec), beforeEach/afterEach (preparación/limpieza) y expect con matchers (toBe, toEqual, toContain, toBeTruthy, toThrow, etc.). xit/xdescribe saltan specs. Las pruebas son sincrónicas por defecto; para lo asíncrono, usa el callback done o el soporte de async/await de Jasmine.
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() {});
});Probar un controlador
module('myApp') carga el módulo de Angular; inject() resuelve los servicios (a menudo con alias de guiones bajos al inicio/final). Crea un controlador con $controller('Name', { $scope: scope }) pasando dependencias falsas. Luego haz aserciones sobre el scope. Este patrón también sirve para controllerAs: pasa funciones enlazadas a this e inspecciona la instancia devuelta.
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('');
});
});Probar un servicio
Inyecta el servicio bajo prueba y $httpBackend de angular-mocks. expectGET(url).respond(data) configura una respuesta falsa; flush() resuelve las peticiones pendientes de forma sincrónica. verifyNoOutstandingExpectation() en afterEach detecta expectativas incumplidas. Esto hace que los servicios basados en $http sean totalmente testeables sin servidor real.
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);
});
});Probar una directiva
Compila un fragmento de HTML con $compile(html)(scope) y luego ejecuta scope.$digest() para evaluar los bindings y enlazar las directivas. Haz aserciones sobre el elemento jqLite resultante (el.find, el.text, el.attr). Para templateUrl, usa $httpBackend.expectGET para proveer la plantilla y haz flush antes del digest. Prueba el scope aislado con el.isolateScope().
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');
});
});Mocking con $httpBackend
expectGET (y expectPOST, etc.) verifican que la petición se hace y fallan si no; whenGET devuelve los datos en silencio si se llama, ignorando si no. Usa expect para aserciones de 'esto debe pasar' y when para la preparación. flush() resuelve las peticiones pendientes en orden. Llama siempre a verifyNoOutstanding* en afterEach para detectar desajustes.
// 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();Inyección de dependencias
Fundamentos de la DI
La DI de Angular resuelve dependencias inspeccionando los nombres de los parámetros de las funciones. Este estilo 'implícito' es conciso pero se rompe con la minificación (los nombres de los parámetros se acortan). Está bien para prototipos/demos. Para producción, usa uno de los estilos de anotación — array en línea o $inject — o automatízalo con ng-annotate.
// 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).Anotación de array en línea
El estilo más común a salvo de la minificación: pasa un array cuyos elementos son los nombres de los servicios (como cadenas), con el constructor al final. Las cadenas sobreviven a la minificación, así que Angular resuelve correctamente. Úsalo siempre en código que vaya a minificarse. Es tedioso mantenerlo a mano — ng-annotate o plugins de babel pueden añadirlo automáticamente.
app.controller('A', ['$scope', '$http', 'UserService',
function($scope, $http, UserService) {
// parameter names no longer matter; the strings drive DI
$scope.users = UserService.list();
}
]);Anotación con la propiedad $inject
Adjunta un array $inject con los nombres de los servicios como cadenas a la función constructora. Angular lo lee para resolver las dependencias, ignorando los nombres de los parámetros. Esto mantiene la declaración de la función legible y permite reutilizar el mismo constructor. ng-annotate puede generar el $inject automáticamente a partir de los nombres de los parámetros durante la compilación.
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.Servicio $injector
$injector es el contenedor de DI: .get(name) devuelve un singleton, .annotate(fn) devuelve la lista de dependencias, y .instantiate/.invoke construyen/llaman funciones con sus dependencias. Rara vez se necesita en el código de la app, pero es útil en escenarios dinámicos (cargar servicios por nombre) y dentro de directivas personalizadas o resolve del router.
// 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 (en tiempo de compilación)
ng-annotate es una herramienta de build que añade automáticamente las anotaciones de array en línea, así escribes DI implícita limpia y publicas código a salvo de la minificación. Usa /* @ngInject */ para desambiguar casos delicados. Se integra con gulp, grunt, webpack y babel. El sucesor ng-annotate-patched mantiene el soporte para toolchains modernos.
// 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();
}]);Modo strict DI
ng-strict-di hace que la inyección de dependencias implícita (sin anotar) lance un error en tiempo de ejecución, así detectas el código inseguro ante la minificación durante el desarrollo y no en producción. Mantenlo activado en dev y pruebas. Impacta ligeramente el rendimiento (comprobaciones extra), así que suele retirarse en las compilaciones de producción.
<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.Buenas prácticas y rendimiento
Usa controllerAs
controllerAs hace explícito qué controlador posee cada propiedad, evita el ocultamiento de primitivos por herencia de scope y te acerca al modelo de 'componente' de Angular 2+. Enlaza a this (con alias) en lugar de $scope. En los componentes, $ctrl es el alias por defecto — úsalo de forma consistente.
<!-- 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); };
});Enlace de un solo uso (::)
Antepón :: a una expresión para convertirla en un enlace de un solo uso: Angular la evalúa una vez y, cuando está definida, elimina su watcher. Para datos que no cambian (títulos, marcas de tiempo, listas estáticas), esto recorta significativamente la cantidad de watchers — la mayor ganancia de rendimiento individual en apps de 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 en ng-repeat
Sin track by, Angular usa un $$hashKey interno para emparejar ítems — cuando el array cambia puede re-renderizar y recrear el DOM de ítems que no cambiaron de verdad, perdiendo el estado de los hijos. track by u.id da una identidad estable para que Angular reutilice los nodos. Es esencial para el rendimiento en listas grandes y corrige los errores de 'ng-repeat duplicates'.
<!-- 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>Mueve la lógica a los servicios
Los controladores son difíciles de probar y están atados a $scope; los servicios son singletons, inyectables y testeables unitariamente. Empuja la lógica de negocio, el acceso a datos y el estado compartido hacia los servicios, y mantén los controladores enfocados en conectar la vista con esos servicios. Esta separación también permite que varios controladores compartan la misma lógica.
// 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 / reducir watchers
Cada {{ }} y la mayoría de los bindings añaden un watcher que se ejecuta en cada digest. Evita las llamadas a funciones dentro de los bindings (se reejecutan en cada digest aunque los inputs no cambien) — precalcula y guarda el resultado. Combina el enlace de un solo uso (::), track by y el cálculo en el controlador para mantener bajo el número de watchers en páginas grandes.
<!-- 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>Organización de módulos
Organiza por funcionalidad (no por tipo de archivo) para que cada feature sea un módulo autosuficiente con su controlador, servicio, plantilla, rutas y pruebas. El módulo raíz de la app solo compone los módulos de features. Esto mantiene junto el código relacionado, hace las features reutilizables entre apps y escala mucho mejor que un único módulo gigante.
// 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.jsFragmentos de AngularJS relacionados
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?