You've seen that Angular signals are here, and know that signal-components are coming up.

This marks a paradigm-shift towards reactive programming in Angular.

Are you ready?

What if you could start learning signals and feel pleased with your progress? And reach a point where you feel confident when using signals in production?

And feel ready when signal-based components come?

Changes are coming, and you can get ahead of them.

By taking this cousre you will learn how to:

- Create computed signals
- Share your signals in services
- Use and cleanup signal effects
- Turn signals into observables and vice versa
- ... and more

In 52 minutes over the course of 20 bite-sized lessons, you'll learn everything you need to know to take advantage of signals now and be prepared for signal-based components!

This lesson teaches how to create a signal in Angular with the signal function from @angular/core. Signals need an initial value, which can be a primitive, object, or any other valid expression in JavaScript. 

TypeScript infers the signal's type and catches errors during compilation.

Create an Angular Signal Which Stores a Value

Signals are functions that return their current value. The component template is guaranteed to be updated when the signal value changes. 

TypeScript helps catch errors when using signals of different types. Signals can also be used with Angular's `ngFor` directive to loop over arrays.

Access an Angular Signal's Value and Display It Within the Component Template

In some cases, using the optional chaining operator may not be sufficient to narrow down a signal's value type, such as from `string | undefined` to `string`. To achieve type narrowing, you can use Angular's `@if` directive in combination with a getter expression.

By moving the signal to a private property and exposing its value through a public getter property, you can ensure that TypeScript correctly narrows down the type within the `@if` block. 

This approach guarantees that the same value is used throughout the template, allowing TypeScript to compile the code without errors.

Narrow Down Angular's Signal Value Type Within an If Statement

Event handlers can be created in Angular components to interact with signals. By defining a method in the component class and binding it to an event in the template, the current value of a signal can be accessed and logged when the event occurs.

It's important to note the difference between:
- Reactive signal calls in the template, which automatically update the view when the signal value changes
- Imperative signal calls in the TypeScript class code, which retrieve the current value only when the event is triggered


Access an Angular Signal's Value Inside Event Handler Methods

Computed signals in Angular allow for the creation of derived values based on existing signals. By defining a new property and assigning it a computed signal, you can perform calculations or transformations on top of an existing signal's value.

To create a computed signal that remains responsive to changes in its dependencies, it's essential to:
* Define the computed signal's callback function, which calculates the derived value based on other signals
* Ensure that the computed signal is consumed by a live consumer, such as a template, to trigger re-evaluation when dependencies change

The reactivity flow in Angular ensures that whenever a dependency of a computed signal changes, the computed value is automatically re-evaluated. This re-evaluation only occurs if there is a live consumer, such as a template, that depends on the computed signal.



Create an Angular Computed Signal Which Depends on Another Signal

Computed signals in Angular allow for the creation of derived values based on other signals, including other computed signals. This enables the composition of complex calculations and transformations by building upon existing signals.

When creating computed signals that depend on other computed signals, it's crucial to:
* Ensure that there are no cyclic dependencies, where two or more computed signals directly or indirectly depend on each other
* Consume the computed signal by a live consumer, such as a template, to trigger re-evaluation when dependencies change

Angular's reactivity system automatically detects and prevents cyclic dependencies in computed signals, throwing an error if such a scenario is encountered. 


Create an Angular Computed Signal on Top of Another Computed

Signal values can be updated using the `set` or `update` methods. When updating signal values, it's crucial to follow immutable practices.

Key points to keep in mind:
* Use the `set` method for updating primitive values like strings or numbers
* Use the `update` method with a callback that returns a new object or array when updating complex values
* Avoid mutating signal values directly

Failure to follow immutable practices can result in stale data being displayed in the template.

Update an Angular Signal's Value and Make Computed Signal Emit Updates

Read-only signals in Angular let you share values between components safely. They update automatically when the original signal changes. 

They can't be changed directly, like computed signals. And, they are useful in services.

Make an Angular Signal Readonly

Moving a signal and related methods to an Angular service allows sharing between components. 

The service we create will expose a read-only property for the signal and methods to update it.

Share Angular Signal State Using Services

The `effect` function in Angular runs a callback when a signal value it depends on changes. The callback is also invoked when the component first renders.

An `effect` can depend on multiple signals or computed signals. When any of these signals change, the `effect` callback executes.

Instead of running `effect` in the constructor, it's best to assign it to a component property. This allows for manual interaction with the `EffectRef` if needed.

Create an Angular Signal Effect

The `untracked` function in Angular allows you to read a signal's value without causing the effect or computed signal to re-evaluate when that signal changes.

Effects will only re-evaluate when tracked dependencies change.

`untracked` always accepts a callback function that returns the value of the underlying signal. Outside `untracked`, reading the signal is reactive, but inside `untracked`, the same read becomes non-reactive.

Read an Angular Signal Value While Being Untracked

Angular's reactive signals provide a way to manage state and automatically update the view when the signal value changes. However, you can customize how Angular determines if a signal's value has changed by configuring the signal's `equal` property.

For example, you can use the `lodash.isEqual` function to perform a deep equality check, ignoring changes in object or array references if the contents remain the same. 

Make an Angular Signal Compare Object Values Instead of References

Angular's reactive signals provide a way to manage state, but you may also want to persist that state across page refreshes or browser sessions. 

This can be achieved by synchronizing the signal's value with the browser's local storage using an `effect`

Synchronize Angular Signal or Computed Value With LocalStorage Using Effect

You may find that you need to implement similar effects across multiple components or services. To avoid code duplication, you can create reusable effect functions.

A reusable effect function should:

1. Accept any necessary configuration parameters (e.g., a key for local storage synchronization).
2. Accept a function that retrieves the reactive value(s) to track (e.g., a signal getter).
3. Set up and return the effect, using the provided configuration and reactive value getter.

Create a Reusable Angular Effect

Sometimes you will need to properly clean up your effects to prevent memory leaks. Like if you use timeouts or intervals. 

Implement cleanup logic using the `onCleanup` callback. In your effect you can call `onCleanup`, pass it a callback, and define actions like clearing intervals or unsubscribing from observables when effects are no longer needed. 

Set up an Angular Signal Effect Cleanup Handler

Angular provides a `manualCleanup` configuration option for effects, preventing automatic cleanup when the owner component/service is destroyed. 

With `manualCleanup: true`, you gain control but must manually call `.destroy()` on the `EffectRef` that is returned by your `effect` to release resources like intervals or subscriptions. 

Remember, with great power comes great responsibility!

Destroy an Angular Signal Effect Automatically or Manually

In Angular, effects are often assigned to class properties during the constructor phase. However, there may be cases where the effect needs to be parameterized with values from parent components, which are not available during construction.

When running effects outside the constructor, such as in the `ngOnInit` lifecycle hook, you need to manually provide the `injector` instance to the `effect` configuration.

Bind an Angular Signal Effect to an Injector for Automatic Cleanup

Angular's `toObservable` function enables converting signals to RxJS observables. This allows creating observable properties that stay synchronized with signal values. 

Whenever the signal value changes, the corresponding observable emits a notification, facilitating the interoperability between signals and observables.

Turn an Angular Signal Into an RxJS Observable

The `toSignal` function in Angular enables the conversion of an RxJS observable into a signal. 

It allows you to wrap an observable and handle the initial value of the resulting signal. You can explicitly define the initial value, require a synchronous emission from the observable, and more! 

Turn an RxJS Observable Into an Angular Signal With toSignal

Using Angular's `toSignal` function with the HTTP client enables components to reactively fetch and display data from external services. 

This approach simplifies code and handles undefined initial values, but note that `toSignal` immediately subscribes and makes the HTTP request when used. So, keep in mind if you're using it in a component or some root level service.

Modernize State Management in Angular with Signals

Instructor

Course Content