
Dopo il segnale: derivati scrivibili, dati asincroni, effetti e oggetti annidati nei framework
Angular ha linkedSignal e resource, Solid 2 ha un createSignal che accetta una funzione, Svelte permette di riassegnare un $derived. Quattro problemi che ogni framework con i segnali incontra, e la primitiva con cui ciascuno li risolve.
Emanuele Nardi
await dalla 5.36, ancora sperimentali), Qwik v2 (documentazione di next.qwik.dev) e Preact con la guida della v10, perché la v11 non l'ho letta. Con versioni diverse nomi e comportamenti possono cambiare, e Solid 2 ha rimosso API di Solid 1 come createResource e batch.Nell'articolo precedente abbiamo trattato i segnali: il tracciamento automatico delle dipendenze, i valori derivati e gli effetti. Qui vediamo cosa succede quando un'applicazione vera mette davanti altri problemi, e ogni framework ha dovuto inventare una risposta:
- un valore derivato da altri, che però l'utente deve poter cambiare (una selezione che resta valida quando cambia la lista);
- un dato che arriva dalla rete, con caricamento, errore e richieste che si accavallano;
- un effetto che apre una risorsa e deve chiuderla;
- un oggetto annidato, di cui cambia una proprietà in fondo.
Qui metto a confronto le risposte di Angular, Vue e Nuxt, Solid, Svelte, Preact e Qwik, con lo stesso esempio per ciascuna.
Dove una pagina ufficiale non dice una cosa, scrivo che non la dice.
Un derivato che l'utente può cambiare
Un menu di spedizione mostra le opzioni disponibili e ne tiene una selezionata. Per default la selezione è la prima opzione. Se l'utente ne sceglie un'altra, quella resta finché le opzioni non cambiano, e a quel punto la selezione deve rimanere valida.
Un computed non basta, perché è di sola lettura. Un signal non basta, perché non si aggiorna quando cambiano le opzioni. Serve un valore che sia entrambe le cose.
Angular ha una primitiva dedicata, linkedSignal. La documentazione la descrive come un segnale che si comporta come signal, ma riceve una funzione di calcolo: quando cambia ciò da cui dipende, il valore torna al risultato del calcolo, e nel frattempo si può scrivere con set e update. La funzione riceve anche il valore precedente, e con quello si può tenere la scelta se è ancora valida.
import { linkedSignal, signal } from '@angular/core'
const options = signal(['standard', 'express'])
const selected = linkedSignal<string[], string>({
source: options,
computation: (currentOptions, previous) => {
const stillValid = previous && currentOptions.includes(previous.value)
return stillValid ? previous.value : currentOptions[0]
}
})
selected.set('express')
import { computed, ref } from 'vue'
const options = ref(['standard', 'express'])
const chosen = ref<string>()
// Un computed con getter e setter: il setter scrive su un ref vero
const selected = computed({
get: () => chosen.value && options.value.includes(chosen.value)
? chosen.value
: options.value[0],
set: (value) => {
chosen.value = value
}
})
selected.value = 'express'
import { createSignal } from 'solid-js'
const [options, setOptions] = createSignal(['standard', 'express'])
// Con una funzione al posto del valore, il segnale è derivato ma scrivibile
const [selected, setSelected] = createSignal(() => options()[0])
setSelected('express')
<script>
let options = $state(['standard', 'express'])
let selected = $derived(options[0])
</script>
<button onclick={() => (selected = 'express')}>
{selected}
</button>
Gli esempi sono scritti da me, semplificati. Quello di Vue è il più lungo perché non c'è una primitiva dedicata: la documentazione offre il computed con getter e setter, e il setter deve scrivere su uno stato vero, qui chosen.
Le differenze sono documentate:
- Angular: il calcolo rigira quando cambia la sorgente o un segnale che legge. Con l'opzione
setsi può anche far scrivere unlinkedSignalsu un'altra sorgente. I tipi vanno scritti a mano quando si usaprevious. - Solid 2:
createSignal(fn)è nuovo in questa versione. Il valore scritto vale finchéfnnon viene rieseguita, e a quel puntofnlo riceve come valore precedente. La pagina di migrazione dice che sostituisce i derivati che prima scrivevano su un altro segnale. - Svelte: dalla 5.25 un
$derivedsi può riassegnare. La documentazione parla di sovrascrittura temporanea. - Vue: dalla 3.4 il getter di un
computedriceve il valore precedente, utile per un confronto, ma la scrittura passa sempre dal setter. - Preact: la guida che ho letto dice che il
computedrestituito è di sola lettura e non descrive un derivato scrivibile. - Qwik: tra le primitive che ho letto,
useComputed$non ha un setter.
Un dato che arriva dalla rete
Si carica un utente a partire da un identificatore. Quando l'identificatore cambia, la richiesta in corso va annullata e se ne fa una nuova. Intanto l'interfaccia mostra caricamento o errore.
Angular ha resource: una funzione params reattiva e un loader asincrono. Il loader rigira a ogni nuovo valore di params e riceve un abortSignal; se params restituisce undefined, non parte e lo stato è idle. Lo stato (idle, loading, reloading, resolved, error, local) e il valore sono segnali.
import { resource, signal } from '@angular/core'
const userId = signal(1)
const user = resource({
params: () => ({ id: userId() }),
loader: async ({ params, abortSignal }) => {
const response = await fetch(`/api/users/${params.id}`, { signal: abortSignal })
return response.json()
}
})
// user.value(), user.isLoading(), user.error(), user.reload()
<script setup lang="ts">
const userId = ref(1)
// L'URL è una funzione: quando userId cambia, Nuxt rifà la richiesta
const {
data, status, error, refresh
} = await useFetch(() => `/api/users/${userId.value}`)
</script>
import { createMemo, createSignal } from 'solid-js'
const [userId, setUserId] = createSignal(1)
// In Solid 2 non c'è più createResource: un memo può restituire una promessa
const user = createMemo(() => fetchUser(userId()))
// Chi legge user() sospende fino al confine Loading più vicino
<script>
import { getAbortSignal } from 'svelte'
let userId = $state(1)
// Richiede experimental.async; il caricamento si mostra con <svelte:boundary>
const user = $derived(await fetchUser(userId, getAbortSignal()))
</script>
<p>{user.name}</p>
export default component$(() => {
const userId = useSignal(1)
const user = useComputed$(async ({ track, abortSignal }) => {
const id = track(() => userId.value)
const response = await fetch(`/api/users/${id}`, { signal: abortSignal })
return response.json()
})
return <p>{user.value.name}</p>
})
Quello che le pagine ufficiali dicono:
- Angular dà una primitiva con stati espliciti e la richiesta annullata quando cambiano i parametri.
httpResourceè la variante sopraHttpClient, con gli interceptor. - Nuxt copre lo stesso caso con
useAsyncDataeuseFetch, che restituisconodata,status,errorerefresh. L'URL può essere una funzione, e i valori reattivi tra le opzioni vengono osservati: la richiesta si rifà da sola. Più chiamate con la stessa chiave condividono gli stessi ref. Vue da solo, nelle pagine che ho letto, non ha una primitiva asincrona. - Solid 2 ha tolto
createResource. UncreateMemopuò restituire una promessa, erefresh,latesteisPendingprendono il posto direfetch,latesteloading. - Svelte permette
awaitdentro$derivede nel markup dalla 5.36. È sperimentale e va attivato conexperimental.async; la documentazione dice che il flag sparirà in Svelte 6 e che i dettagli possono cambiare fuori da un rilascio maggiore.getAbortSignal()si annulla quando il derivato rigira o viene distrutto. - Qwik fa lo stesso con
useComputed$asincrono, che esponependingederror. Le letture prima del primoawaitsono tracciate da sole, quelle dopo vanno dichiarate contrack(). - Preact: nella guida che ho letto non c'è una primitiva asincrona.
Un effetto che deve ripulire
Chi apre una connessione, un timer o un listener deve chiuderlo prima della prossima esecuzione e alla distruzione. Tutti i framework hanno la stessa forma, con cinque modi di scriverla:
effect((onCleanup) => {
const connection = chat.connect(room())
onCleanup(() => connection.close())
})
watchEffect((onCleanup) => {
const connection = chat.connect(room.value)
onCleanup(() => connection.close())
})
// In Solid 2 la lettura e l'effetto sono due funzioni
createEffect(
() => room(),
(value) => {
const connection = chat.connect(value)
return () => connection.close()
}
)
<script>
$effect(() => {
const connection = chat.connect(room)
return () => connection.close()
})
</script>
effect(() => {
const connection = chat.connect(room.value)
return () => connection.close()
})
useTask$(({ track, cleanup }) => {
const value = track(() => room.value)
const connection = chat.connect(value)
cleanup(() => connection.close())
})
Angular, Vue, Svelte e Qwik documentano la stessa trappola: le dipendenze si tracciano solo nella parte sincrona. Una lettura dopo un await non viene tracciata, e in Vue onWatcherCleanup va chiamato prima di qualsiasi await.
Sul quando girano, le pagine dicono cose diverse:
- Angular: gli effetti girano in modo asincrono, durante il rilevamento dei cambiamenti. La pagina avverte di non usarli per propagare stato, cioè di preferire
computedelinkedSignal. - Vue: di default il callback gira prima dell'aggiornamento del DOM del componente.
flush: 'post'lo sposta dopo,flush: 'sync'lo rende sincrono e senza raggruppamento. - Svelte: l'effetto gira dopo il montaggio e in un microtask dopo ogni cambiamento di stato.
$effect.pregira prima degli aggiornamenti del DOM. - Solid 2: la parte di calcolo è tracciata, quella dell'effetto no.
- Qwik:
useTask$gira prima del render, anche sul server, e blocca il render; per un caricamento non bloccante la documentazione consigliauseComputed$asincrono.
Un oggetto annidato
Un oggetto utente ha un indirizzo, e si cambia la città. Qui i framework si dividono in due famiglie: quelli che rendono reattivo l'oggetto in profondità e quelli che chiedono di sostituirlo.
const user = ref({ name: 'Ada', address: { city: 'Milano' } })
user.value.address.city = 'Roma'
<script>
let user = $state({ name: 'Ada', address: { city: 'Milano' } })
user.address.city = 'Roma'
</script>
const user = useStore({ name: 'Ada', address: { city: 'Milano' } })
user.address.city = 'Roma'
const [user, setUser] = createStore({ name: 'Ada', address: { city: 'Milano' } })
// Il setter riceve una bozza da modificare sul posto
setUser((draft) => {
draft.address.city = 'Roma'
})
const user = signal({ name: 'Ada', address: { city: 'Milano' } })
user.update(current => ({
...current,
address: { ...current.address, city: 'Roma' }
}))
const user = signal({ name: 'Ada', address: { city: 'Milano' } })
user.value = {
...user.value,
address: { ...user.value.address, city: 'Roma' }
}
- Vue usa un
Proxyconrefereactive, eshallowRefquando la profondità è un costo inutile. - Svelte rende
$stateun proxy profondo per oggetti semplici e array. Le istanze di classe non vengono rese reattive,$state.rawaccetta solo riassegnazioni e$state.snapshotrestituisce una copia statica. - Qwik:
useStoretraccia in profondità di default, e{ deep: false }lo disattiva. - Solid separa la questione in uno store. Il setter di
createStorericeve una bozza, ereconcilefa combaciare i dati nuovi con quelli vecchi per chiave, così gli oggetti già presenti mantengono la loro identità.createProjectionè la versione derivata e di sola lettura. - Angular confronta con
Object.is. Le pagine che ho letto mostrano aggiornamenti immutabili e dicono che un segnale non impedisce di mutare in profondità il valore; per un confronto profondo serve una funzioneequalpersonalizzata. Un'API di store non la documentano. - Preact: gli esempi della guida riassegnano l'array con una copia. Per raggruppare stato e metodi c'è
createModel, i cui metodi sono azioni, cioè raggruppati e non tracciati.
Aggiornamenti raggruppati: quando si vede il nuovo valore
Scrivere tre volte di fila lo stesso segnale non deve far girare tre volte tutti gli effetti. Tutti raggruppano, ma il momento in cui si vede il valore nuovo cambia:
| Framework | Cosa dice la documentazione |
|---|---|
| Vue | I callback dei watcher sono raggruppati; flush: 'sync' toglie il raggruppamento; nextTick() aspetta l'aggiornamento del DOM |
| Svelte | Le riesecuzioni degli effetti sono raggruppate; tick() aspetta le modifiche in sospeso, flushSync() le applica subito |
| Solid 2 | Le scritture vengono messe in coda e applicate al microtask successivo; una lettura subito dopo una scrittura restituisce il valore vecchio; flush() applica subito; batch è stato rimosso |
| Preact | batch(fn) applica tutto alla fine; dentro il batch la lettura di un segnale modificato dà il valore nuovo |
| Angular | Gli effetti girano in modo asincrono durante il rilevamento dei cambiamenti; un'API di batch non è documentata nelle pagine che ho letto |
La riga di Solid 2 è quella che contraddice di più l'abitudine di Vue, dove count.value dopo una scrittura è già il valore nuovo.
La stessa mappa, in una tabella
| Problema | Angular | Vue e Nuxt | Solid 2 | Svelte 5 | Preact | Qwik |
|---|---|---|---|---|---|---|
| Derivato scrivibile | linkedSignal | computed con setter | createSignal(fn) | $derived riassegnabile | non documentato | non documentato |
| Dato asincrono | resource, httpResource | useAsyncData, useFetch | memo asincrono | await in $derived (sperimentale) | non documentato | useComputed$ asincrono |
| Pulizia dell'effetto | onCleanup | onCleanup, onWatcherCleanup | funzione restituita | funzione restituita | funzione restituita | cleanup |
| Oggetto annidato | aggiornamento immutabile | ref e reactive profondi | createStore | $state profondo | aggiornamento immutabile | useStore profondo |
| Raggruppamento | effetti asincroni | flush, nextTick | microtask, flush() | microtask, tick() | batch | non letto |
Cosa si ripete
Leggendoli uno accanto all'altro, i framework fanno lo stesso percorso, con nomi diversi. Partono da un valore che sa chi lo legge, aggiungono il derivato pigro, poi l'effetto, e a quel punto si trovano davanti gli stessi quattro problemi. Angular li affronta con primitive dedicate, Svelte e Solid allargando quelle che hanno, Vue con una combinazione di computed e Nuxt, Preact e Qwik con scelte più piccole.
Un'altra cosa si ripete: una scelta nuova arriva di solito per correggere un errore frequente. Il valore scritto a mano e dimenticato dopo un cambio di lista ha dato linkedSignal, e la richiesta che arriva fuori ordine ha dato i parametri e l'annullamento di resource. Gli effetti che propagano stato spiegano l'avvertimento della documentazione di Angular.
Fonti
- Angular: segnali, linkedSignal, resource, effect
- Vue: computed, watcher, API di reattività, nextTick
- Nuxt:
useAsyncData,useFetch - Solid: reattività,
createSignal,createMemo,createEffect,createStore, migrazione da Solid 1 - Svelte:
$state,$derived,$effect, espressioni await - Preact Signals
- Qwik: stato, task