Nel prima paragrafo vedremo come i Signals si inseriscono nell'ecosistema di Angular, fornendo una panoramica sui concetti di base e sui casi d'uso più comuni. Successivamente, analizzeremo le due categorie principali – component signals e service signals – illustrando le differenze operative e gli scenari in cui è consigliabile scegliere l'una o l'altra. Infine, presenteremo esempi concreti di creazione, emissione e sottoscrizione di un Signal, mostrando passo passo come integrarlo in un componente Angular.

Concluderemo con una riflessione sui benefici di adottare i Signals rispetto ai metodi tradizionali, evidenziando come questa feature possa contribuire a una struttura di codice più pulita, manutenibile e scalabile. Se sei uno sviluppatore che desidera approfondire le potenzialità di Angular, questo articolo ti fornirà tutte le informazioni necessarie per sfruttare al meglio i Signals nelle tue applicazioni.

Che cosa sono i Signals in Angular

I Signals sono oggetti che permettono a un componente o a un servizio di emettere valori e di notificare gli iscritti ogni volta che questi cambiano. Si tratta di un’alternativa più leggera e dichiarativa rispetto ai classici Observable, in quanto non richiedono la gestione di stream complessi né la cancellazione manuale delle sottoscrizioni.

Un Signal è definito da una classe che eredita da una classe astratta chiamata Signal, la quale espone i due metodi fondamentali subscribe e emit. Il metodo emit invia un valore a tutti gli ascoltatori, mentre subscribe consente di registrare una callback che verrà eseguita ogni qual volta il valore viene pubblicato.

Grazie a questo modello, la logica di aggiornamento dei dati diventa più chiara: il produttore di informazioni utilizza emit per comunicare, e i consumer rispondono mediante la loro funzione registrata con subscribe, mantenendo il flusso di dati sempre sincronizzato.

Tipi di Signals: component e service

Component signals sono pensati per facilitare la comunicazione tra elementi appartenenti allo stesso contesto di visualizzazione, come un template e il suo controller. Questo tipo di Signal è ideale quando si desidera condividere rapidamente dati tra parti di un singolo componente senza introdurre dipendenze esterne.

Al contrario, service signals operano a livello di servizio e permettono lo scambio di informazioni tra componenti differenti o persino tra moduli diversi dell’applicazione. Utilizzando un service signal, è possibile creare un canale di comunicazione centralizzato, riducendo la necessità di passare dati attraverso catene di input e output.

La scelta tra component e service signals dipende dalla portata della comunicazione: se il flusso di dati è locale, si preferisce il primo; se è globale o deve attraversare più livelli di gerarchia, il secondo offre una soluzione più pulita e scalabile.

Come funziona la classe Signal

La classe astratta Signal definisce l’interfaccia di base per tutti i segnali disponibili in Angular. Essa contiene due metodi chiave:

subscribe(callback): registra una funzione di callback che verrà eseguita ogni volta che il segnale emette un nuovo valore. La sottoscrizione può essere gestita in modo da essere automaticamente rimossa quando il componente viene distrutto, evitando perdite di memoria.
emit(value): pubblica un valore sul segnale, triggerando tutte le callback attive. Questo metodo è il punto di ingresso per i dati che devono essere distribuiti ai consumer.

La separazione di questi due metodi consente di mantenere una chiara distinzione tra produttore e consumatore, facilitando il debugging e rendendo l’interfaccia più intuitiva per gli sviluppatori.

Vantaggi nell'uso dei Signals

Uno dei principali vantaggi dei Signals è la riduzione della complessità nella comunicazione inter‑component. Poiché non è necessario gestire stream di dati, il codice risulta più lineare e più facile da leggere. Inoltre, i Signals eliminano la necessità di creare servizi di passaggio dati aggiuntivi in molti scenari, snellendo l’architettura dell’applicazione.

Grazie al modello di publish‑subscribe integrato, i Signals migliorano le prestazioni, poiché le notifiche avvengono solo quando effettivamente necessario, evitando aggiornamenti superflui del DOM. Questo si traduce in un’esperienza utente più fluida, soprattutto in applicazioni con elevato carico di interazioni.

Infine, l’adozione dei Signals favorisce una migliore separazione delle responsabilità. I componenti possono concentrarsi sulla loro logica di presentazione, mentre i servizi gestiscono la logica di business, mantenendo il codice modulare e più semplice da testare.

Creare un Signal: esempio pratico

import { Signal } from '@angular/core';
import { Injectable } from '@angular/core';

@Injectable()
export class MySignalService {
  private readonly signal = new Signal<string>();

  emit(value: string): void {
    this.signal.emit(value);
  }

  subscribe(callback: (value: string) => void): void {
    this.signal.subscribe(callback);
  }
}

Nel snippet sopra, la classe MySignalService incapsula un'istanza di Signal parametrizzata con il tipo string. Il metodo emit pubblica un valore, mentre subscribe consente a qualsiasi componente di registrare una callback per ricevere le notifiche. La presenza del decoratore @Injectable() rende il servizio disponibile per l’iniezione dipendente in tutta l’applicazione.

Questo approccio mantiene il segnale ben isolato, rendendo più semplice la sua riusabilità in più punti del progetto e garantendo una gestione centralizzata delle comunicazioni.

Utilizzare il Signal in un componente

import { Component, AfterViewInit } from '@angular/core';
import { MySignalService } from './my-signal.service';

@Component({
  selector: 'app-my-component',
  template: `<p>{{ value }}</p>`
})
export class MyComponent implements AfterViewInit {
  value = '';

  constructor(private readonly mySignal: MySignalService) {}

  ngAfterViewInit(): void {
    this.mySignal.subscribe((val) => {
      this.value = val;
    });
  }
}

In questo esempio, il componente MyComponent si iscrive al Signal definito in MySignalService all’interno del ciclo di vita ngAfterViewInit. Quando il servizio chiama emit, la callback aggiorna la proprietà value, provocando la visualizzazione in tempo reale del nuovo dato nel template.

Questo pattern dimostra come la comunicazione attraverso i Signals sia semplice, diretta e priva di boilerplate aggiuntivo, mantenendo il flusso di dati coerente e reattivo.

Altri meccanismi di comunicazione in Angular

Oltre ai Signals, Angular offre diverse soluzioni per lo scambio di informazioni tra componenti:

Servizi: classi singleton che possono contenere stato condiviso e metodi di manipolazione, spesso usati con Dependency Injection.
Observable (RxJS): flussi di dati asincroni più potenti, ideali per gestire eventi complessi, cancellazioni e combinazioni di più sorgenti.
EventEmitter: utilizzato soprattutto per la comunicazione padre‑figlio tramite gli output dei componenti.

Sebbene ciascuna di queste tecniche abbia i propri casi d’uso, i Signals si distinguono per la loro leggerezza e per l’assenza di dipendenze reattive, rendendoli una scelta eccellente quando si desidera un meccanismo di comunicazione semplice e performante.

Conclusioni

I Signals rappresentano una risorsa strategica per chi sviluppa SPA con Angular, offrendo un metodo pulito e ottimizzato per far dialogare componenti e servizi. Attraverso l’uso di emit e subscribe, è possibile costruire flussi di dati chiari, riducendo la necessità di codici boilerplate e migliorando la manutenibilità dell’applicazione.

Integrando i Signals nella tua architettura, potrai sfruttare una comunicazione più immediata, diminuzione del carico di lavoro del framework e una maggiore coerenza nella gestione dello stato. Prova a sperimentare con i component signals e i service signals nei tuoi prossimi progetti: vedrai come la tua base di codice diventerà più modulare, leggibile e pronta a crescere.