Blog
Dopo il segnale: derivati scrivibili, dati asincroni, effetti e oggetti annidati nei framework
Illustrazione di copertina: Festival of Embers di Cory Godbey
SviluppoVueNuxtFramework19 nov 2026 — 9 min di lettura

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

Emanuele Nardi

Gli esempi usano la sintassi più recente di ogni framework, letta dalle pagine ufficiali il 19 novembre 2026. Le versioni considerate sono Angular 22, Vue 3.5.45 (la 3.6 è in release candidate) con Nuxt 4.6, Solid 2.0, Svelte 5 (le espressioni 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')

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 set si può anche far scrivere un linkedSignal su un'altra sorgente. I tipi vanno scritti a mano quando si usa previous.
  • Solid 2: createSignal(fn) è nuovo in questa versione. Il valore scritto vale finché fn non viene rieseguita, e a quel punto fn lo 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 $derived si può riassegnare. La documentazione parla di sovrascrittura temporanea.
  • Vue: dalla 3.4 il getter di un computed riceve il valore precedente, utile per un confronto, ma la scrittura passa sempre dal setter.
  • Preact: la guida che ho letto dice che il computed restituito è 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()

Quello che le pagine ufficiali dicono:

  • Angular dà una primitiva con stati espliciti e la richiesta annullata quando cambiano i parametri. httpResource è la variante sopra HttpClient, con gli interceptor.
  • Nuxt copre lo stesso caso con useAsyncData e useFetch, che restituiscono data, status, error e refresh. 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. Un createMemo può restituire una promessa, e refresh, latest e isPending prendono il posto di refetch, latest e loading.
  • Svelte permette await dentro $derived e nel markup dalla 5.36. È sperimentale e va attivato con experimental.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 espone pending ed error. Le letture prima del primo await sono tracciate da sole, quelle dopo vanno dichiarate con track().
  • 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())
})

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 computed e linkedSignal.
  • 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.pre gira 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 consiglia useComputed$ 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'
  • Vue usa un Proxy con ref e reactive, e shallowRef quando la profondità è un costo inutile.
  • Svelte rende $state un proxy profondo per oggetti semplici e array. Le istanze di classe non vengono rese reattive, $state.raw accetta solo riassegnazioni e $state.snapshot restituisce una copia statica.
  • Qwik: useStore traccia in profondità di default, e { deep: false } lo disattiva.
  • Solid separa la questione in uno store. Il setter di createStore riceve una bozza, e reconcile fa 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 funzione equal personalizzata. 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:

FrameworkCosa dice la documentazione
VueI callback dei watcher sono raggruppati; flush: 'sync' toglie il raggruppamento; nextTick() aspetta l'aggiornamento del DOM
SvelteLe riesecuzioni degli effetti sono raggruppate; tick() aspetta le modifiche in sospeso, flushSync() le applica subito
Solid 2Le 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
Preactbatch(fn) applica tutto alla fine; dentro il batch la lettura di un segnale modificato dà il valore nuovo
AngularGli 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

ProblemaAngularVue e NuxtSolid 2Svelte 5PreactQwik
Derivato scrivibilelinkedSignalcomputed con settercreateSignal(fn)$derived riassegnabilenon documentatonon documentato
Dato asincronoresource, httpResourceuseAsyncData, useFetchmemo asincronoawait in $derived (sperimentale)non documentatouseComputed$ asincrono
Pulizia dell'effettoonCleanuponCleanup, onWatcherCleanupfunzione restituitafunzione restituitafunzione restituitacleanup
Oggetto annidatoaggiornamento immutabileref e reactive profondicreateStore$state profondoaggiornamento immutabileuseStore profondo
Raggruppamentoeffetti asincroniflush, nextTickmicrotask, flush()microtask, tick()batchnon 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

build 631 • 009a823

© 2026 Emanuele Nardi