
Segnali, ref, reactive, useState: una mappa della reattività
Nomi diversi per la stessa idea, e lo stesso nome per idee diverse, come lo useState di React e quello di Nuxt. Dal segnale a ref e reactive di Vue, allo useState di Nuxt e React, fino ai segnali nativi proposti per JavaScript.
Emanuele Nardi
Apri un progetto Vue e trovi ref() e reactive(). Apri un progetto Nuxt e compare anche useState(). Apri un progetto React e useState() c'è di nuovo, ma fa un'altra cosa. Angular e Solid parlano di signal, Svelte di rune, e TC39 sta discutendo di aggiungere i segnali al linguaggio.
Sono tutti modi di rispondere alla stessa domanda: come fa un'interfaccia a sapere che un valore è cambiato? Parto dall'idea comune, il segnale, e poi passo strumento per strumento, con un occhio di riguardo a Vue e Nuxt.
Senza reattività
Per capire cosa ci risparmiano questi strumenti, parto da un contatore in JavaScript puro. Il numero compare in tre posti: nel pulsante, in un'etichetta con il doppio e nel titolo della pagina.
let count = 0
const button = document.querySelector('#counter')
const doubleLabel = document.querySelector('#double')
function updateButton() {
button.textContent = `clicks: ${count}`
}
function updateDouble() {
doubleLabel.textContent = `doppio: ${count * 2}`
}
function updateTitle() {
document.title = `clicks: ${count}`
}
button.addEventListener('click', () => {
count++
// Ogni scrittura deve ricordarsi di tutti quelli che leggono count
updateButton()
updateDouble()
updateTitle()
})
updateButton()
updateDouble()
updateTitle()
Funziona, ma il legame tra count e chi lo mostra esiste solo nella testa di chi scrive. Basta un secondo punto che modifica count (un pulsante "azzera", una risposta del server) e dimentica una delle tre chiamate, e la pagina mostra valori diversi in posti diversi. Ogni sistema reattivo è un modo per non dover tenere quell'elenco a mano.
L'idea comune: il segnale
Un segnale è un valore che sa chi lo sta leggendo. Quando lo leggi, si annota chi l'ha letto; quando lo scrivi, avvisa tutti quelli che si era annotato. La documentazione di Angular lo definisce "un involucro attorno a un valore che notifica i consumatori interessati quando il valore cambia".
Il meccanismo sta in poche righe. Questa è una versione didattica, senza valori derivati, senza pulizia delle dipendenze e senza raggruppamento degli aggiornamenti:
let currentEffect = null
export function signal(initialValue) {
let value = initialValue
const subscribers = new Set()
return {
get value() {
if (currentEffect) subscribers.add(currentEffect)
return value
},
set value(nextValue) {
value = nextValue
for (const subscriber of [...subscribers]) subscriber()
}
}
}
export function effect(callback) {
const run = () => {
const previousEffect = currentEffect
currentEffect = run
try {
callback()
} finally {
currentEffect = previousEffect
}
}
run()
}
import { signal, effect } from './signal.js'
const count = signal(0)
// Gira subito una volta, e di nuovo a ogni modifica di count
effect(() => {
document.title = `clicks: ${count.value}`
})
count.value++ // il titolo diventa "clicks: 1"
Nessuno dichiara che l'effetto dipende da count: lo scopre il segnale, perché l'effetto l'ha letto mentre era in esecuzione. Questo è il tracciamento automatico delle dipendenze.
Il contatore di prima diventa così, e un nuovo punto che scrive count.value aggiorna tutto senza sapere chi lo legge:
import { signal, effect } from './signal.js'
const count = signal(0)
const button = document.querySelector('#counter')
const doubleLabel = document.querySelector('#double')
effect(() => {
button.textContent = `clicks: ${count.value}`
})
effect(() => {
doubleLabel.textContent = `doppio: ${count.value * 2}`
})
effect(() => {
document.title = `clicks: ${count.value}`
})
button.addEventListener('click', () => count.value++)
Sopra il segnale i sistemi reattivi costruiscono altri due mattoni:
- i valori derivati (computed), calcolati da altri segnali e ricalcolati solo quando servono;
- gli effetti, funzioni che rieseguono quando cambia qualcosa che hanno letto: aggiornare un nodo del DOM, scrivere il titolo della pagina, fare una richiesta.
Sopra questi mattoni ogni framework aggiunge primitive proprie: derivati che si possono anche scrivere, dati asincroni, effetti con pulizia, oggetti annidati. Le confronto nell'articolo successivo.
Se step cambia, si ricalcola double e riparte l'effetto che aggiorna il DOM; quello del titolo non si muove, perché non ha mai letto step.
Cosa manca per arrivare a un ref vero
Le trenta righe di signal.js sono, nella sostanza, un ref di Vue. Anche un computed si ottiene in fretta, con un segnale aggiornato da un effetto:
import { signal, effect } from './signal.js'
// Ingenua: ricalcola a ogni modifica, anche se nessuno legge il risultato
export function computed(getter) {
const result = signal(undefined)
effect(() => {
result.value = getter()
})
return result
}
Per usarli in un'app vera mancano però parecchi pezzi, e sono quelli che il framework si prende in carico:
- Valori derivati pigri. Il
computedqui sopra ricalcola subito a ogni modifica. Quello di Vue segna il valore come "da ricalcolare" e lo ricalcola solo quando qualcuno lo legge, riusando il risultato finché le dipendenze non cambiano. - Pulizia delle dipendenze. Con
effect(() => showDetails.value ? details.value : ''), quandoshowDetailsdiventa falso l'effetto non dovrebbe più ripartire se cambiadetails. Nella versione didattica l'effetto resta iscritto per sempre: prima di ogni esecuzione andrebbe tolto dagli elenchi in cui si era iscritto. - Raggruppamento degli aggiornamenti. Tre scritture di fila (
count.value++tre volte) fanno partire tre volte ogni effetto. Vue le accoda e aggiorna il DOM una volta sola, al microtask successivo: è per questo che esistenextTick(). - Nessun aggiornamento inutile. Scrivere lo stesso valore non dovrebbe avvisare nessuno: Vue lo confronta con
Object.isprima di notificare. - Reattività profonda.
count.valueè tracciato, mauser.value.address.city = 'Roma'no: per gli oggetti Vue avvolge il contenuto in unProxy, cioè quello che fareactive(). - Cicli e ordine. Un effetto che scrive un segnale che lui stesso legge va in loop; un derivato che dipende da due segnali a loro volta derivati dallo stesso valore non deve vedere uno stato a metà (il problema del glitch).
La reattività di Vue (@vue/reactivity) risolve tutti questi casi, con un pacchetto intero e i suoi test al posto delle trenta righe qui sopra.
Vue: ref e reactive
La guida di Vue sulla reattività spiega che i ref usano getter e setter come signal.js: leggere .value traccia la dipendenza, scriverlo avvisa chi dipende.
ref
<script setup lang="ts">
import { ref, computed, watch } from 'vue'
const count = ref(0)
const double = computed(() => count.value * 2)
watch(count, (newCount) => {
console.log(`count è ora ${newCount}`)
})
</script>
<template>
<button @click="count++">
{{ count }} × 2 = {{ double }}
</button>
</template>
Il .value serve perché JavaScript non sa intercettare la lettura di una variabile qualsiasi: sa intercettare solo l'accesso alla proprietà di un oggetto. Nel template i ref vengono "scartati" da soli, per cui scrivi count e non count.value.
Un ref che contiene un oggetto lo rende reattivo in profondità: cambiare user.value.address.city aggiorna chi lo legge.
reactive
reactive() rende reattivo un oggetto intero tramite un Proxy, senza .value:
import { reactive } from 'vue'
const form = reactive({
email: '',
acceptedTerms: false
})
form.email = 'nome@esempio.it' // reattivo, nessun .value
Sembra più comodo, ma la documentazione elenca tre limiti:
- funziona solo con oggetti, array,
MapeSet, non con stringhe, numeri o booleani; - non puoi sostituire l'oggetto intero:
form = reactive({...})scollega chi stava leggendo quello vecchio; - destrutturarlo, o passarne una proprietà a una funzione, rompe il collegamento:
const { email } = formè una stringa e basta.
Per questo Vue stesso consiglia di usare ref() come API principale per dichiarare lo stato. Io uso reactive solo per gruppi di campi che viaggiano sempre insieme, come un form.
shallowRef
shallowRef() è reattivo solo sul .value: cambiare una proprietà interna non avvisa nessuno, sostituire il valore sì. Serve per dati grandi che tratti come immutabili, come la risposta di un'API o una lista di migliaia di elementi, dove rendere reattivo ogni campo avrebbe un costo senza alcun vantaggio.
import { shallowRef } from 'vue'
const results = shallowRef<Movie[]>([])
results.value.push(movie) // nessun aggiornamento
results.value = [...results.value, movie] // aggiornamento
Con Vue 3.6 il sistema reattivo è stato riscritto sulla base di alien-signals: l'API resta la stessa, cambiano prestazioni e memoria.
Nuxt: useState
Lo useState di Nuxt restituisce un normale ref, e quello che aggiunge è dove vive quel ref. La documentazione lo descrive come stato reattivo e "SSR-friendly", condiviso tra tutti i componenti che usano la stessa chiave.
export const useCounter = () => useState('counter', () => 0)
<script setup lang="ts">
const counter = useCounter()
</script>
<template>
<button @click="counter++">
{{ counter }}
</button>
</template>
Due componenti che chiamano useCounter() leggono e scrivono lo stesso valore. Ma per condividere uno stato basterebbe un ref dichiarato fuori dal componente:
// Da non fare con il rendering lato server
const counter = ref(0)
export const useCounter = () => counter
Con un sito solo lato client funziona. Con il rendering lato server no, per due motivi:
- Lo stato si mescola tra richieste. Sul server il modulo viene caricato una volta e resta in memoria: quel
refè unico per tutti i visitatori, e il valore scritto durante la richiesta di uno finisce nella pagina di un altro. La documentazione avverte che porta anche a perdite di memoria. - Il valore non arriva al browser. Se il server calcola
counter = 5, il browser riparte da0durante l'idratazione, e la pagina cambia sotto gli occhi dell'utente.
useState risolve entrambi: tiene il valore nel contesto dell'app Nuxt, che sul server è uno per richiesta, e lo serializza nel payload della pagina, da cui il browser lo riprende. Il prezzo è che il valore deve essere serializzabile in JSON: niente classi, funzioni o simboli. Per ripartire da zero c'è clearNuxtState().
Quando lo stato condiviso si porta dietro logica (azioni, valori derivati, strumenti di debug), il passo successivo è Pinia, che con il modulo per Nuxt gestisce lo stesso problema del server.
React: useState
Lo useState di React ha lo stesso nome ma un modello diverso. Non traccia chi legge il valore: quando chiami il setter, React riesegue il componente, e con lui i figli salvo memoizzazione. La documentazione lo chiama lo stato come un'istantanea: ogni esecuzione del componente vede un valore fisso, e impostare lo stato lo cambia "solo per il render successivo".
import { useState } from 'react'
export function Counter() {
const [count, setCount] = useState(0)
function addThree() {
// count vale 0 in tutte e tre le righe: il risultato è 1
setCount(count + 1)
setCount(count + 1)
setCount(count + 1)
}
function addThreeForReal() {
// Ogni funzione riceve il valore aggiornato dalla precedente: il risultato è 3
setCount(previous => previous + 1)
setCount(previous => previous + 1)
setCount(previous => previous + 1)
}
return (
<>
<button onClick={addThree}>+3 (sbagliato)</button>
<button onClick={addThreeForReal}>+3</button>
<p>clicks: {count}</p>
</>
)
}
Con un ref di Vue l'equivalente di addThree darebbe 3, perché count.value è sempre il valore attuale.
Uno useState in JavaScript puro
Anche il modello di React si può abbozzare in poche righe, ed è molto diverso da quello del segnale. Lo stato non sta nel componente (che è una funzione e a ogni esecuzione riparte da zero) ma in un elenco esterno, e ogni chiamata a useState prende il suo posto in base all'ordine in cui viene fatta:
const states = []
let cursor = 0
let renderScheduled = false
let rootComponent
let rootElement
export function useState(initialValue) {
const index = cursor++
if (!(index in states)) states[index] = initialValue
function setState(next) {
const value = typeof next === 'function' ? next(states[index]) : next
if (Object.is(value, states[index])) return
states[index] = value
scheduleRender()
}
return [states[index], setState]
}
function scheduleRender() {
// Più setState di fila producono un solo render
if (renderScheduled) return
renderScheduled = true
queueMicrotask(() => {
renderScheduled = false
render()
})
}
function render() {
cursor = 0
// Si riesegue tutto il componente e si ricrea tutto il suo DOM
rootElement.replaceChildren(rootComponent())
}
export function mount(component, element) {
rootComponent = component
rootElement = element
render()
}
import { useState, mount } from './mini-react.js'
function Counter() {
const [count, setCount] = useState(0)
const button = document.createElement('button')
button.textContent = `clicks: ${count}`
button.addEventListener('click', () => setCount(previous => previous + 1))
return button
}
mount(Counter, document.querySelector('#app'))
Qui count è davvero un'istantanea: è un numero copiato dall'elenco quando la funzione è partita, e cambiarlo vuol dire rieseguire tutto. Da questo abbozzo si capiscono due cose di React:
- Le regole degli hook. Lo stato si ritrova solo grazie all'ordine delle chiamate: se uno
useStatestesse dentro unif, al render successivo tutti quelli dopo leggerebbero il posto sbagliato. Per questo React vieta di chiamare gli hook in condizioni e cicli. - Il virtual DOM. Ricreare tutto il DOM a ogni clic è lento e fa perdere focus, selezione e scroll. React invece fa produrre al componente una descrizione leggera della pagina, la confronta con quella precedente e tocca solo i nodi cambiati.
E mancano ancora un elenco di stati per ogni istanza di ogni componente (in React è la fiber), gli effetti (useEffect) con la loro pulizia, le priorità tra aggiornamenti urgenti e rinviabili, la memoizzazione. In React per i valori derivati non serve un'API apposita: sono variabili calcolate a ogni esecuzione (const double = count * 2), e il React Compiler memoizza da solo quelle costose. La documentazione di React non parla di segnali.
Il nome uguale è il punto dove ci si confonde di più passando da un mondo all'altro: lo useState di Nuxt risponde a "dove vive questo stato condiviso?", quello di React a "come dichiaro lo stato di un componente?".
Gli altri: Solid, Angular, Svelte, Preact
Solid, Angular, Svelte e Preact hanno segnali veri e propri, con tre sintassi diverse per leggerli: una funzione da chiamare, una proprietà .value o una variabile normale, che il compilatore trasforma.
import { createSignal } from 'solid-js'
export function Counter() {
const [count, setCount] = createSignal(0)
const double = () => count() * 2
return (
<button onClick={() => setCount(count() + 1)}>
{count()} × 2 = {double()}
</button>
)
}
import { Component, computed, signal } from '@angular/core'
@Component({
selector: 'app-counter',
template: `
<button (click)="count.update(value => value + 1)">
{{ count() }} × 2 = {{ double() }}
</button>
`
})
export class Counter {
count = signal(0)
double = computed(() => this.count() * 2)
}
<script>
let count = $state(0)
let double = $derived(count * 2)
</script>
<button onclick={() => count++}>
{count} × 2 = {double}
</button>
import { signal, computed } from '@preact/signals'
const count = signal(0)
const double = computed(() => count.value * 2)
export function Counter() {
return (
<button onClick={() => count.value++}>
{count} × 2 = {double}
</button>
)
}
- Solid espone il segnale come coppia getter e setter:
count()legge e traccia. I componenti girano una volta sola, poi sono i segnali ad aggiornare i singoli nodi. Per oggetti annidati c'ècreateStore, che ricordareactivedi Vue. - Angular usa una funzione da chiamare per leggere (
count()) e i metodiseteupdateper scrivere, piùcomputed,effectelinkedSignal. - Svelte 5 dichiara lo stato con le rune (
$state,$derived): nel codice è una variabile normale, ed è il compilatore a trasformarla in segnale. L'annuncio delle rune dice esplicitamente che Svelte 5 è basato sui segnali. - Preact ha
@preact/signals, con il.valuecome Vue, e i segnali possono vivere fuori dai componenti.
Segnali nel linguaggio: la proposta TC39
Visto che ogni framework ha la sua versione dello stesso meccanismo, la proposta Signals vuole metterlo nel linguaggio. È arrivata allo stadio 1 di TC39 ad aprile 2024 ed è ancora lì: allo stadio 1 il comitato considera il problema degno di studio, ma la soluzione è ancora da scegliere. Secondo il README, il progetto è stato scritto con il contributo degli autori di Angular, Ember, MobX, Preact, Qwik, RxJS, Solid, Svelte, Vue e altri.
const count = new Signal.State(0)
const double = new Signal.Computed(() => count.get() * 2)
count.set(1)
double.get() // 2
Il modello è push-pull. Quando uno stato cambia, chi ne dipende viene segnato subito come da aggiornare (push), ma un Computed ricalcola il suo valore solo quando qualcuno lo legge con .get() (pull). Finché le sue dipendenze non cambiano tiene in memoria l'ultimo risultato, quindi leggerlo dieci volte costa un solo calcolo.
La proposta definisce lo stato e i valori derivati, ma volutamente non gli effetti: per reagire ai cambiamenti offre un Signal.subtle.Watcher di basso livello, pensato per gli autori dei framework più che per chi scrive applicazioni. L'obiettivo è dare a ref, createSignal e simili un nucleo comune, così che una libreria scritta con i segnali nativi funzioni in qualsiasi framework. Nessun browser lo implementa; per provarlo c'è un polyfill, sconsigliato in produzione.
Sulle prestazioni il README è prudente. Un'implementazione nativa potrebbe essere più veloce di una in JavaScript di un piccolo fattore costante, cosa ancora da dimostrare, e il codice risparmiato nei pacchetti sarebbe poco, perché le librerie di segnali sono già piccole. Il vantaggio su cui punta è l'interoperabilità, insieme a strumenti di debug che possano ispezionare i segnali.
A colpo d'occhio
| Strumento | Cos'è | Come si legge | Quando cambia |
|---|---|---|---|
Vue ref | Segnale | .value (nel template no) | Si aggiorna chi l'ha letto |
Vue reactive | Oggetto reattivo tramite Proxy | Proprietà normali | Si aggiorna chi ha letto quella proprietà |
Vue shallowRef | Segnale non profondo | .value | Solo sostituendo il valore |
Nuxt useState | Un ref per richiesta, trasferito al browser | .value | Come un ref |
React useState | Stato del componente, un'istantanea per render | Variabile | Si riesegue il componente |
Solid createSignal | Segnale | count() | Si aggiornano i nodi che lo leggono |
Angular signal | Segnale | count() | Si aggiorna chi lo legge (il componente, con OnPush) |
Svelte $state | Segnale generato dal compilatore | Variabile | Si aggiorna ciò che dipende da lui |
Preact signal | Segnale | .value | Si aggiornano i nodi o i componenti che lo leggono |
TC39 Signal.State | Proposta, stadio 1 | .get() | Lo decide il framework che lo usa |
Quale usare in Vue e Nuxt
Per come lavoro io:
refper tutto lo stato di un componente, di base;reactiveper un gruppo di campi che non destrutturo mai, come un form;computedper tutto ciò che si calcola da altro stato, invece di tenerlo sincronizzato a mano con unwatch;shallowRefper dati grandi che sostituisco in blocco;useStateper uno stato semplice condiviso tra componenti in un'app con rendering lato server;- Pinia quando quello stato condiviso comincia ad avere azioni e logica sua.
Fonti
- Vue: Reactivity Fundamentals, Reactivity in Depth,
shallowRef, alien-signals - Nuxt:
useState, State Management - Pinia
- React:
useState, State as a Snapshot, React Compiler - Solid: introduzione alla reattività, reattività fine-grained
- Angular: segnali
- Svelte:
$state,$derived, Introducing runes - Preact: Signals
- TC39: proposal-signals, signal-polyfill