# Symfony Live Components e UX 3.0: Applicazioni Reattive Senza JavaScript nel 2026

> Questo tutorial mostra come creare interfacce reattive con Symfony Live Components e UX 3.0 senza scrivere JavaScript. Esempi pratici con componenti di ricerca, carrello e form dinamici.

- Published: 2026-05-10
- Updated: 2026-05-10
- Author: SharpSkill
- Tags: symfony, live components, symfony ux, php, twig, reactive ui
- Reading time: 8 min

---

I **Symfony Live Components** hanno rivoluzionato il modo in cui gli sviluppatori PHP costruiscono interfacce reattive, eliminando la necessità di scrivere codice JavaScript complesso. Con il rilascio di Symfony UX 3.0 nel 2026, questa libreria si è consolidata come la soluzione definitiva per creare applicazioni web dinamiche utilizzando esclusivamente PHP e Twig.

Questo tutorial presenta i concetti fondamentali dei Live Components, dimostra casi d'uso pratici e analizza le novità di UX 3.0 che hanno trasformato lo sviluppo di interfacce reattive nell'ecosistema Symfony.

> **Nota Importante**
>
> I Live Components funzionano inviando richieste AJAX automatiche al server ogni volta che una proprietà contrassegnata con `#[LiveProp(writable: true)]` viene modificata. Symfony ri-renderizza solo i frammenti del template che sono effettivamente cambiati, creando un'esperienza utente fluida senza ricaricare l'intera pagina.

## Installazione e Configurazione di Symfony UX 3.0

Il primo passo per lavorare con i Live Components è installare il pacchetto `symfony/ux-live-component`. La versione 3.0 offre piena compatibilità con PHP 8.4+ e Symfony 7.4+, oltre all'integrazione nativa con l'AssetMapper per la gestione delle dipendenze frontend senza bisogno di Webpack o Vite.

```bash
# terminal
composer require symfony/ux-live-component

# With AssetMapper (recommended for Symfony 7.4+)
php bin/console importmap:require @symfony/ux-live-component

# Verify installation
php bin/console debug:twig --filter=component
```

Dopo l'installazione, il comando `debug:twig` dovrebbe elencare tutti i componenti Twig disponibili nel progetto. L'AssetMapper semplifica drasticamente la configurazione eliminando la necessità di compilatori JavaScript, rendendo il processo di sviluppo più agile e in linea con la filosofia di Symfony.

## Creazione di un Componente di Ricerca Reattiva con LiveProp

Uno dei casi d'uso più comuni per i Live Components è l'implementazione di sistemi di ricerca che aggiornano i risultati in tempo reale mentre l'utente digita. L'esempio seguente mostra un componente di ricerca prodotti con filtri dinamici e sincronizzazione con l'URL.

```php
<?php
// src/Twig/Components/ProductSearch.php

namespace App\Twig\Components;

use App\Repository\ProductRepository;
use Symfony\UX\LiveComponent\Attribute\AsLiveComponent;
use Symfony\UX\LiveComponent\Attribute\LiveProp;
use Symfony\UX\LiveComponent\DefaultActionTrait;

#[AsLiveComponent]
class ProductSearch
{
    use DefaultActionTrait;

    // writable: true allows the frontend to modify this property
    // url: true syncs the value with ?query= in the address bar
    #[LiveProp(writable: true, url: true)]
    public string $query = '';

    #[LiveProp(writable: true)]
    public string $category = 'all';

    public function __construct(
        private ProductRepository $productRepository,
    ) {
    }

    public function getProducts(): array
    {
        if (strlen($this->query) < 2) {
            return [];
        }

        return $this->productRepository->search(
            query: $this->query,
            category: $this->category === 'all' ? null : $this->category,
            limit: 20,
        );
    }
}
```

L'attributo `#[AsLiveComponent]` trasforma una classe PHP in un componente dinamico. Le proprietà contrassegnate con `#[LiveProp(writable: true)]` possono essere modificate dal frontend tramite attributi `data-model` nell'HTML. L'opzione `url: true` abilita il deep linking, consentendo agli utenti di condividere URL con filtri già applicati.

Il template Twig corrispondente utilizza la direttiva `data-model` per collegare i campi di input alle proprietà del componente:

```twig
{# templates/components/ProductSearch.html.twig #}
<div {{ attributes }}>
    <input
        type="search"
        data-model="debounce(300)|query"
        placeholder="Search products..."
        class="form-input w-full"
    />

    <select data-model="category" class="form-select mt-2">
        <option value="all">All categories</option>
        <option value="electronics">Electronics</option>
        <option value="books">Books</option>
    </select>

    <div class="mt-4">
        {% for product in this.products %}
            <div key="{{ product.id }}" class="border-b py-2">
                <h3>{{ product.name }}</h3>
                <span>{{ product.price|format_currency('EUR') }}</span>
            </div>
        {% else %}
            {% if query|length >= 2 %}
                <p>No results for "{{ query }}".</p>
            {% endif %}
        {% endfor %}
    </div>
</div>
```

Il modificatore `debounce(300)` garantisce che le richieste al server vengano inviate solo dopo 300 ms di inattività, evitando il sovraccarico del backend durante la digitazione. Questa tecnica è particolarmente rilevante per le [domande di colloquio Symfony](/technologies/symfony/interview-questions/events-subscribers) relative all'ottimizzazione delle prestazioni.

## Implementazione del Carrello con LiveAction

Mentre `LiveProp` gestisce proprietà reattive, l'attributo `#[LiveAction]` permette di creare metodi che rispondono alle azioni dell'utente come i click sui pulsanti. Il componente carrello dimostra come coordinare più azioni e la comunicazione tra componenti.

```php
<?php
// src/Twig/Components/ShoppingCart.php

namespace App\Twig\Components;

use App\Entity\CartItem;
use App\Service\CartService;
use Symfony\UX\LiveComponent\Attribute\AsLiveComponent;
use Symfony\UX\LiveComponent\Attribute\LiveAction;
use Symfony\UX\LiveComponent\Attribute\LiveArg;
use Symfony\UX\LiveComponent\Attribute\LiveProp;
use Symfony\UX\LiveComponent\ComponentToolsTrait;
use Symfony\UX\LiveComponent\DefaultActionTrait;

#[AsLiveComponent]
class ShoppingCart
{
    use DefaultActionTrait;
    use ComponentToolsTrait;

    #[LiveProp]
    public array $items = [];

    public function __construct(
        private CartService $cartService,
    ) {
    }

    #[LiveAction]
    public function addItem(#[LiveArg] int $productId, #[LiveArg] int $quantity = 1): void
    {
        $this->cartService->add($productId, $quantity);
        $this->items = $this->cartService->getItems();

        // Notify other components on the page
        $this->emit('cart:updated', [
            'count' => count($this->items),
        ]);
    }

    #[LiveAction]
    public function removeItem(#[LiveArg] int $itemId): void
    {
        $this->cartService->remove($itemId);
        $this->items = $this->cartService->getItems();
        $this->emit('cart:updated', ['count' => count($this->items)]);
    }

    public function getTotal(): float
    {
        return array_sum(array_map(
            fn(CartItem $item) => $item->getPrice() * $item->getQuantity(),
            $this->items,
        ));
    }
}
```

Il metodo `emit()`, fornito dal `ComponentToolsTrait`, consente ai componenti di emettere eventi che altri componenti possono ascoltare. Questa funzionalità è fondamentale per creare interfacce complesse dove più componenti devono comunicare senza accoppiamento diretto.

```twig
{# templates/components/ShoppingCart.html.twig #}
<div {{ attributes }}>
    <h2>Cart ({{ items|length }})</h2>

    {% for item in items %}
        <div key="{{ item.id }}" class="flex justify-between py-2">
            <span>{{ item.name }} x{{ item.quantity }}</span>
            <span>{{ (item.price * item.quantity)|format_currency('EUR') }}</span>
            <button {{ live_action('removeItem', { itemId: item.id }) }}
                    class="text-red-600">
                Remove
            </button>
        </div>
    {% endfor %}

    <div class="border-t pt-2 font-bold">
        Total: {{ this.total|format_currency('EUR') }}
    </div>
</div>
```

La funzione Twig `live_action()` genera gli attributi HTML necessari per collegare i click dei pulsanti ai metodi `#[LiveAction]` nel componente PHP. Questo approccio dichiarativo elimina la necessità di scrivere event listener JavaScript manualmente.

## Integrazione con Symfony Forms e Validazione

Una delle caratteristiche più potenti dei Live Components è l'integrazione nativa con il sistema di form di Symfony. Il trait `ComponentWithFormTrait` permette di creare form che validano in tempo reale senza ricaricare la pagina, mantenendo tutta la logica di validazione centralizzata in PHP.

```php
<?php
// src/Twig/Components/RegistrationForm.php

namespace App\Twig\Components;

use App\Entity\User;
use App\Form\RegistrationType;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Form\FormInterface;
use Symfony\UX\LiveComponent\Attribute\AsLiveComponent;
use Symfony\UX\LiveComponent\Attribute\LiveAction;
use Symfony\UX\LiveComponent\Attribute\LiveProp;
use Symfony\UX\LiveComponent\ComponentWithFormTrait;
use Symfony\UX\LiveComponent\DefaultActionTrait;

#[AsLiveComponent]
class RegistrationForm extends AbstractController
{
    use DefaultActionTrait;
    use ComponentWithFormTrait;

    #[LiveProp]
    public ?User $initialFormData = null;

    protected function instantiateForm(): FormInterface
    {
        return $this->createForm(RegistrationType::class, $this->initialFormData ?? new User());
    }

    #[LiveAction]
    public function save(EntityManagerInterface $em): mixed
    {
        // Submits + validates — re-renders with errors if invalid
        $this->submitForm();
        $user = $this->getForm()->getData();

        $em->persist($user);
        $em->flush();

        $this->addFlash('success', 'Account created.');

        return $this->redirectToRoute('app_login');
    }
}
```

Il metodo `instantiateForm()` viene chiamato automaticamente dal trait e deve restituire l'istanza del form Symfony. Il metodo `submitForm()` esegue la validazione completa secondo i constraint definiti e ri-renderizza il componente mostrando i messaggi di errore se la validazione fallisce.

```twig
{# templates/components/RegistrationForm.html.twig #}
<div {{ attributes }}>
    {{ form_start(form, {
        attr: {
            'data-action': 'live#action:prevent',
            'data-live-action-param': 'save'
        }
    }) }}
        {{ form_row(form.email) }}
        {{ form_row(form.plainPassword, { label: 'Password' }) }}
        {{ form_row(form.fullName) }}

        <button type="submit"
                class="btn-primary w-full"
                data-loading="addAttribute(disabled) addClass(opacity-50)">
            <span data-loading="hide">Create Account</span>
            <span data-loading="show" class="animate-spin">Loading...</span>
        </button>
    {{ form_end(form) }}
</div>
```

L'attributo `data-loading` permette di controllare gli stati visivi durante le richieste AJAX, fornendo feedback immediato all'utente. Questa funzionalità è particolarmente importante nelle applicazioni dove le operazioni possono richiedere alcuni secondi.

## Caricamento Differito e Lazy Loading dei Componenti

Componenti che eseguono query pesanti al database o chiamate ad API esterne possono influire negativamente sul tempo di caricamento iniziale della pagina. UX 3.0 ha introdotto strategie sofisticate di caricamento differito che migliorano significativamente la performance percepita.

```php
<?php
// src/Twig/Components/AnalyticsDashboard.php

namespace App\Twig\Components;

use App\Service\AnalyticsService;
use Symfony\UX\LiveComponent\Attribute\AsLiveComponent;
use Symfony\UX\LiveComponent\Attribute\LiveProp;
use Symfony\UX\LiveComponent\DefaultActionTrait;

#[AsLiveComponent]
class AnalyticsDashboard
{
    use DefaultActionTrait;

    #[LiveProp]
    public string $period = '30d';

    public function __construct(
        private AnalyticsService $analytics,
    ) {
    }

    public function getMetrics(): array
    {
        // Expensive query — runs only after page load
        return $this->analytics->getMetrics($this->period);
    }
}
```

Per attivare il caricamento differito, si utilizza l'attributo `loading` quando si include il componente nel template:

```twig
{# Parent page: load the dashboard after the page renders #}
<twig:AnalyticsDashboard loading="defer" period="30d" />

{# Or load when scrolled into view #}
<twig:AnalyticsDashboard loading="lazy" period="30d" />
```

L'opzione `loading="defer"` renderizza inizialmente un segnaposto vuoto e carica il componente reale via AJAX dopo che il DOM è completamente caricato. `loading="lazy"` utilizza l'Intersection Observer API per caricare il componente solo quando entra nel viewport dell'utente.

Per personalizzare il segnaposto visualizzato durante il caricamento, si definisce una macro `placeholder` nel template del componente:

```twig
{# templates/components/AnalyticsDashboard.html.twig #}
<div {{ attributes }}>
    <h2>Analytics — {{ period }}</h2>
    {% for metric in this.metrics %}
        <div class="stat-card">
            <span class="stat-label">{{ metric.label }}</span>
            <span class="stat-value">{{ metric.value|number_format }}</span>
        </div>
    {% endfor %}
</div>

{% macro placeholder(props) %}
    <div class="animate-pulse space-y-4">
        <div class="h-6 bg-gray-200 rounded w-1/3"></div>
        <div class="h-20 bg-gray-200 rounded"></div>
        <div class="h-20 bg-gray-200 rounded"></div>
    </div>
{% endmacro %}
```

Questa tecnica è fondamentale per ottimizzare applicazioni con dashboard complesse o report pesanti, un argomento frequentemente trattato nelle [domande di colloquio Symfony](/blog/symfony/symfony-interview-questions) sulla performance.

## Comunicazione tra Componenti con LiveListener

Il sistema di eventi dei Live Components consente di creare architetture disaccoppiate dove i componenti comunicano attraverso messaggi. L'attributo `#[LiveListener]` definisce metodi che vengono eseguiti automaticamente quando specifici eventi vengono emessi.

```php
<?php
// src/Twig/Components/CartBadge.php

namespace App\Twig\Components;

use App\Service\CartService;
use Symfony\UX\LiveComponent\Attribute\AsLiveComponent;
use Symfony\UX\LiveComponent\Attribute\LiveListener;
use Symfony\UX\LiveComponent\Attribute\LiveProp;
use Symfony\UX\LiveComponent\DefaultActionTrait;

#[AsLiveComponent]
class CartBadge
{
    use DefaultActionTrait;

    #[LiveProp]
    public int $count = 0;

    public function __construct(CartService $cartService)
    {
        $this->count = $cartService->getItemCount();
    }

    // Automatically re-renders when ShoppingCart emits 'cart:updated'
    #[LiveListener('cart:updated')]
    public function onCartUpdated(#[LiveArg] int $count): void
    {
        $this->count = $count;
    }
}
```

Quando il componente `ShoppingCart` aggiunge o rimuove articoli, emette l'evento `cart:updated` con il nuovo totale. Il componente `CartBadge`, che può trovarsi in qualsiasi punto della pagina (tipicamente nell'header), ascolta questo evento e aggiorna automaticamente il suo conteggio senza necessità di codice JavaScript aggiuntivo.

Questa architettura basata su eventi facilita la manutenzione di applicazioni complesse e promuove il riutilizzo dei componenti, principi essenziali nello sviluppo moderno con Symfony.

## Modifiche Importanti in Symfony UX 3.0

Il rilascio di Symfony UX 3.0 ha portato cambiamenti significativi che migliorano sicurezza, performance e esperienza dello sviluppatore. La tabella seguente riassume le principali novità:

| Modifica | Prima (2.x) | Dopo (3.0) |
|----------|-------------|------------|
| Protezione CSRF | `csrf: true` su `#[AsLiveComponent]` | Same-Origin/CORS (automatico) |
| Funzione Twig CVA | `cva()` | `html_cva()` da twig/html-extra 3.12+ |
| Configurazione default | Opzionale | `twig_component.defaults` obbligatorio |
| Pacchetti rimossi | Swup, LazyImage, Typed, TogglePassword | API native o UX Toolkit |
| Requisito PHP | 8.1+ | 8.4+ |
| Requisito Symfony | 6.4+ | 7.4+ |

La rimozione della protezione CSRF esplicita a favore di policy Same-Origin automatiche semplifica la configurazione dei componenti. La funzione `html_cva()` sostituisce la precedente `cva()` e richiede l'installazione del pacchetto `twig/html-extra` 3.12+.

I pacchetti precedentemente inclusi in UX 2.x sono stati rimossi a favore di API native dei browser moderni o migrati nell'UX Toolkit. Questa decisione riduce la dimensione del bundle JavaScript e migliora la compatibilità con gli strumenti di build moderni.

L'innalzamento dei requisiti minimi a PHP 8.4+ e Symfony 7.4+ permette a UX 3.0 di sfruttare feature moderne del linguaggio come le proprietà readonly, gli enum migliorati e le ottimizzazioni del JIT compiler.

## Casi d'Uso Avanzati e Pattern Consigliati

Oltre gli esempi base, i Live Components supportano pattern avanzati che risolvono sfide comuni nello sviluppo web moderno. La combinazione di molteplici `#[LiveProp]`, validazione condizionale e integrazione con servizi esterni permette di creare esperienze ricche senza aggiungere complessità non necessaria.

Un pattern comune è la creazione di componenti autocomplete che interrogano API esterne mentre l'utente digita, implementano cache intelligente per ridurre richieste duplicate e mostrano suggerimenti contestuali basati sullo storico dell'utente. Questo tipo di componente dimostra la flessibilità del sistema nella combinazione di stato reattivo, azioni asincrone e comunicazione con altri componenti.

Un altro caso d'uso avanzato coinvolge form multi-step dove ogni passaggio del wizard è un Live Component indipendente che valida le proprie regole di business, ma condivide lo stato globale attraverso un servizio di sessione. Questa architettura mantiene ogni componente focalizzato su una singola responsabilità preservando al contempo un'esperienza utente fluida.

Per applicazioni enterprise che richiedono audit completo, i Live Components possono essere combinati con event subscriber di Symfony per registrare automaticamente tutte le azioni dell'utente, i timestamp delle modifiche e gli stati precedenti delle proprietà. Questa integrazione dimostra come UX 3.0 si integri perfettamente nell'ecosistema maturo di Symfony senza introdurre astrazioni incompatibili.

## Conclusione: Il Futuro delle Interfacce Reattive in PHP

I Symfony Live Components rappresentano un cambio di paradigma nello sviluppo di applicazioni web con PHP. Eliminando la necessità di scrivere codice JavaScript complesso per funzionalità reattive comuni, la libreria permette agli sviluppatori PHP di sfruttare tutta la loro conoscenza dell'ecosistema Symfony per creare interfacce moderne e responsive.

Il rilascio di UX 3.0 ha consolidato la libreria come soluzione matura e pronta per la produzione, con miglioramenti significativi in sicurezza, performance ed esperienza dello sviluppatore. L'integrazione nativa con Symfony Forms, il sofisticato sistema di caricamento differito e l'architettura basata su eventi forniscono gli strumenti necessari per costruire applicazioni complesse senza sacrificare la manutenibilità.

Per gli sviluppatori che desiderano approfondire l'ecosistema Symfony, padroneggiare i Live Components è essenziale sia per i progetti pratici sia per distinguersi nei colloqui tecnici. La capacità di creare interfacce reattive senza dipendere da framework JavaScript pesanti dimostra una conoscenza avanzata della piattaforma e allineamento con le tendenze moderne dello sviluppo web.

Il futuro delle interfacce web in PHP si concentra sempre più su soluzioni che mantengono la logica sul server offrendo al contempo esperienze utente paragonabili alle SPA JavaScript. Live Components e UX 3.0 guidano questa trasformazione, offrendo agli sviluppatori Symfony gli strumenti necessari per competere con i framework frontend moderni mantenendo i vantaggi dell'architettura server-side.

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/it/blog/symfony/symfony-live-components-ux-3-reactive-apps-without-javascript