Change Detection

markForCheck() only marks the view and its ancestors dirty and notifies the scheduler, so the next change-detection pass refreshes them; detectChanges() synchronously checks this view and its descendants right now, without touching ancestors.

An Eager component is refreshed every time a change detection pass reaches it; an OnPush component is refreshed only when its view has been marked dirty. Since Angular 22, a component that omits changeDetection is OnPush.

zone.js patches async browser APIs such as timers, promises and event listeners, so NgZone sees each callback run in the Angular zone; when its microtask queue drains, NgZone emits onMicrotaskEmpty and Angular calls ApplicationRef.tick().

Since v21, Angular schedules change detection from its own notifications (template-read signal writes, markForCheck, bound listeners, setInput) instead of zone.js patching browser APIs. Dropping zone.js means fewer needless checks, a smaller bundle, faster startup and readable stack traces.

A template-bound input receiving a new reference, an Angular-bound event firing in the component or a descendant, a markForCheck() call, or a change to a signal its template reads. Mutations and plain field writes mark nothing.

A zoneless Angular app checks only after a notification: a template-read signal is set, markForCheck() runs, a bound listener fires, setInput() is called, or a dirty view is attached. A setTimeout callback assigning a plain field sends none, so nothing refreshes.

Code started in runOutsideAngular(), and every callback it schedules, runs outside the Angular zone and triggers no checks. run() re-enters for the update that matters; forget it and a plain-field update, even in a parent's output handler, never renders.

The parent's header binding was evaluated before the child's ngAfterViewInit ran, so the child changed a value already rendered. Hold the title in a signal the header reads, so Angular re-renders it in the same tick, or set it earlier; setTimeout only hides it.

push() mutates the array in place, so the [orders] binding sees the same reference, the OnPush table is never marked dirty, and its @for never re-runs. Replace the array instead, ideally held in a signal and updated with a new copy.

zone.js patches setInterval, so each callback that runs inside the Angular zone looks like work that might have changed state, and Angular checks the whole view tree afterwards. Starting the timer with NgZone.runOutsideAngular() stops those needless checks.

NG0100 comes from state changed after its view was checked: writes in ngAfterViewInit or ngAfterViewChecked, children changing parent-bound state, and non-deterministic template expressions. The dev check compares arrays element by element and treats plain objects as equal, so a rebuilt array passes while a new random number throws.

ApplicationRef.tick() synchronously runs change detection for every view attached to the application, plus root effects and render hooks, with a dev-mode verification pass; detectChanges() checks one subtree. Schedulers already call tick(), so manual calls usually duplicate work or fail as recursive ticks.

onMicrotaskEmpty fires, possibly several times per turn, whenever the Angular zone's microtask queue drains, and drives ApplicationRef.tick(); onStable fires once after the last onMicrotaskEmpty, outside the Angular zone, and says nothing about timers or requests still pending.

Call detach() so ticks skip the widget, then call detectChanges() from a one-second interval to render the latest quotes; while detached, nothing else refreshes it, not input changes, markForCheck() or signal reads, until reattach() or the next manual check.

It hides state Angular cannot track: each call is an unbatched synchronous subtree check that leaves ancestors stale and papers over leaking subscriptions. Replace it with signals, toSignal() or the async pipe, and markForCheck() only for unavoidable callbacks.

Audit every way template data changes without marking the view: fields set in subscriptions, timers or promises, mutated input objects, inputs written through @ViewChild, and mutable service state. Convert those to signals or immutable updates, starting with leaf components.

Zoneless became the default in v21, so without provideZoneChangeDetection() a timer triggers no tick; and since v22 components are OnPush by default, so even a zone tick skips a new component whose plain field changed. A signal fixes both.

In a zoneless Angular app, NgZone.onStable, onMicrotaskEmpty and onUnstable never emit and NgZone.isStable is always true. Code waiting for a check to finish should use afterNextRender (one render) or afterEveryRender (each render), or a direct DOM API.

The widget calls back through its own event API, not an Angular-bound listener, and no zone.js observes it, so assigning a plain field notifies nothing. Store the value in a signal the template reads and set() it in the callback.

Angular DevTools' profiler shows a run of change detection cycles whose source is mousemove, scroll or requestAnimationFrame while the pointer moves. Initialise the chart inside NgZone.runOutsideAngular() and re-enter with run(), or set a signal, only for events that change Angular-rendered state.

Make components notify Angular first (signals, AsyncPipe, markForCheck, OnPush-compatible), remove NgZone observable dependencies, switch tests to zoneless, verify with exhaustive dev checks, then drop provideZoneChangeDetection and zone.js from polyfills, one app or shell at a time.

eventCoalescing merges the ticks from several DOM event handlers into one change detection; runCoalescing does the same for repeated NgZone.run() calls. Both defer that tick to the next animation frame or timeout, so views update slightly later.

The default NG0100 check skips OnPush views that are not dirty, so with OnPush as the v22 default many late writes go unreported. exhaustive: true verifies every attached view as if Eager; interval also re-runs the check periodically.

Only the view whose template read the signal is refreshed; its ancestors are flagged just so the pass can reach it, so OnPush ancestors are not re-checked because of it. markForCheck() marks the view and every ancestor dirty, so the whole path is refreshed.

Without zone.js, Angular cannot see arbitrary async work, so SSR might serialize before data arrives. PendingTasks registers work that must finish first: add() returns a cleanup function to call when done, and run() wraps an async function and removes the task when it settles.

Mostly yes: without zone.js, timers, animation frames and third-party listeners trigger no checks, and runOutsideAngular() becomes a plain call. What remains are high-frequency template or host listeners, which still notify on each event, and code that writes signals on every event.