Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-pro· GoogleHugging Face LMArena Human Preference 140K

Sei uno sviluppatore web. Elenca diversi approcci con cui implementeresti la…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with grok-3-preview-02-24’s answer.
  1. User

    Sei uno sviluppatore web. Elenca diversi approcci con cui implementeresti la funzionalità di ridimensionamento delle colonne in una tabella html

  2. Gemini Assistant

    Certamente! In qualità di sviluppatore web, affronto questo problema valutando diversi fattori: la complessità richiesta, le dipendenze esistenti nel progetto e il tempo a disposizione.

    Ecco un elenco di approcci, dal più basilare al più avanzato e robusto, con cui implementerei il ridimensionamento delle colonne di una tabella HTML.


    Approccio 1: JavaScript Puro (Vanilla JS) - Il Metodo "Da Zero"

    Questo approccio offre il massimo controllo ma richiede più codice. È un'ottima scelta per progetti senza dipendenze da framework o per capire a fondo la meccanica del processo.

    Concetto

    1. Si aggiunge un piccolo elemento "handle" (una maniglia) sul bordo destro di ogni intestazione di colonna (<th>).
    2. Quando l'utente clicca e tiene premuto (mousedown) su questa maniglia, registriamo la posizione iniziale del mouse e la larghezza corrente della colonna.
    3. Mentre l'utente sposta il mouse (mousemove), calcoliamo la differenza di posizione e applichiamo dinamicamente una nuova larghezza alla colonna.
    4. Quando l'utente rilascia il pulsante del mouse (mouseup), l'operazione termina e gli event listener vengono rimossi.

    Implementazione

    HTML: La struttura è una tabella standard. La parte chiave è la maniglia (<div class="resizer">) all'interno di ogni <th>.

    <table id="resizable-table">
        <thead>
            <tr>
                <th>Nome <th>Cognome <div class="resizer"></div></th>
                <th>Email <div class="resizer"></div></th>
                <th>Data di Nascita <div class="resizer"></div></th>
            </tr>
        </thead>
        <tbody>
            <!-- Dati della tabella -->
        </tbody>
    </table>
    

    CSS: È fondamentale usare table-layout: fixed; per permettere al browser di rispettare le larghezze che impostiamo via JS, senza ricalcolare tutto automaticamente.

    #resizable-table {
        width: 100%;
        border-collapse: collapse;
        table-layout: fixed; /* Cruciale! */
    }
    
    #resizable-table th {
        position: relative; /* Necessario per posizionare la maniglia */
        border: 1px solid #ccc;
        padding: 8px;
    }
    
    .resizer {
        position: absolute;
        top: 0;
        right: 0;
        width: 5px;
        height: 100%;
        cursor: col-resize; /* Indica che l'elemento è ridimensionabile */
        user-select: none; /* Impedisce la selezione del testo durante il drag */
    }
    

    JavaScript: Questa è la logica principale che gestisce gli eventi.

    document.addEventListener('DOMContentLoaded', function () {
        const table = document.getElementById('resizable-table');
        const resizers = table.querySelectorAll('.resizer');
        let th, startX, startWidth;
    
        resizers.forEach(resizer => {
            resizer.addEventListener('mousedown', function (e) {
                e.preventDefault(); // Evita effetti indesiderati come la selezione del testo
                th = e.target.parentElement;
                startX = e.pageX;
                startWidth = th.offsetWidth;
    
                document.addEventListener('mousemove', onMouseMove);
                document.addEventListener('mouseup', onMouseUp);
            });
        });
    
        function onMouseMove(e) {
            const deltaX = e.pageX - startX;
            th.style.width = (startWidth + deltaX) + 'px';
        }
    
        function onMouseUp() {
            document.removeEventListener('mousemove', onMouseMove);
            document.removeEventListener('mouseup', onMouseUp);
        }
    });
    
    • Vantaggi:
      • Nessuna dipendenza esterna.
      • Controllo totale sul comportamento e sull'aspetto.
      • Ottimo per imparare i meccanismi del DOM.
    • Svantaggi:
      • Richiede più codice da scrivere e mantenere.
      • Bisogna gestire manualmente i casi limite (es. larghezza minima/massima, performance su tabelle molto grandi).

    Approccio 2: CSS Puro con la proprietà resize - Il Metodo Semplice ma Limitato

    Questo è un "trucco" CSS che non offre una vera esperienza di "trascinamento del bordo", ma permette di ridimensionare il contenuto della cella.

    Concetto

    La proprietà CSS resize può essere applicata a elementi con overflow diverso da visible. La useremo su un div wrapper all'interno delle celle dell'intestazione.

    Implementazione

    HTML: Ogni <th> contiene un div che avvolge il testo.

    <th><div class="resizable-content">Nome</div></th>
    <th><div class="resizable-content">Cognome</div></th>
    

    CSS:

    /* Assicurati che la tabella rispetti le dimensioni dei div interni */
    table {
        table-layout: fixed;
        width: 100%;
    }
    
    th .resizable-content {
        resize: horizontal; /* Abilita il ridimensionamento orizzontale */
        overflow: auto;    /* Necessario perché 'resize' funzioni */
        display: block;
        width: 100%;       /* Occupa tutta la cella inizialmente */
        height: 20px;      /* Imposta un'altezza fissa */
    }
    
    • Vantaggi:
      • Estremamente semplice, nessuna riga di JavaScript.
    • Svantaggi:
      • Pessima User Experience (UX): La maniglia di ridimensionamento appare in basso a destra della cella, non sul bordo della colonna. Non è intuitivo.
      • Il ridimensionamento riguarda il div interno, non direttamente la colonna <th>, anche se l'effetto visivo è simile con table-layout: fixed.
      • Supporto cross-browser non sempre perfetto per tutti gli elementi.

    Approccio 3: Utilizzo di una Libreria JavaScript - Il Metodo "Production-Ready"

    Per progetti professionali, reinventare la ruota è spesso inefficiente. Esistono librerie eccellenti che hanno già risolto questo problema in modo robusto e performante.

    Concetto

    Si include una libreria esterna e la si inizializza sulla tabella. La libreria si occupa di tutta la logica di eventi, calcoli e aggiornamenti del DOM.

    Esempi di Librerie

    1. interact.js: Una potente libreria per interazioni complesse (drag-and-drop, resize, gesture). È moderna, senza dipendenze (no jQuery) e molto flessibile.
    2. colResizable (Plugin jQuery): Una soluzione classica, molto leggera e specifica per questo compito. Richiede jQuery. Ottima se il progetto lo usa già.
    3. Grid.js / AG Grid / Tabulator: Queste sono librerie di "data grid" complete. Offrono il ridimensionamento delle colonne come una delle tante funzionalità (insieme a ordinamento, filtro, paginazione, etc.). Sono la scelta migliore se la tabella è il cuore della tua applicazione.

    Esempio con interact.js

    HTML: Aggiungi un ID alla tabella e includi la libreria.

    <script src="https://cdn.jsdelivr.net/npm/interactjs/dist/interact.min.js"></script>
    <table id="my-interactive-table">
        <!-- ... -->
    </table>
    

    JavaScript: L'inizializzazione è molto concisa.

    interact('#my-interactive-table th')
      .resizable({
        edges: { right: true }, // Attiva il ridimensionamento solo sul bordo destro
        listeners: {
          move: function (event) {
            let { x, y } = event.target.dataset
            x = (parseFloat(x) || 0) + event.deltaRect.left
            
            Object.assign(event.target.style, {
              width: event.rect.width + 'px'
            })
    
            Object.assign(event.target.dataset, { x, y })
          }
        },
        modifiers: [
          // Limita la dimensione minima
          interact.modifiers.restrictSize({
            min: { width: 50 }
          })
        ],
        inertia: true
      });
    
    • Vantaggi:
      • Veloce da implementare.
      • Robusto, testato e cross-browser.
      • Spesso include funzionalità extra (es. inerzia, limiti di dimensione).
      • Le librerie complete di data grid offrono un valore immenso per applicazioni complesse.
    • Svantaggi:
      • Aggiunge una dipendenza esterna al progetto (aumento del "bundle size").
      • Può essere eccessivo per una tabella molto semplice.

    Riepilogo e Raccomandazioni

    ApproccioIdeale per...ComplessitàDipendenze
    Vanilla JSImparare, progetti piccoli, avere controllo totale.Media/AltaNessuna
    CSS resizePrototipi veloci o soluzioni "quick and dirty" dove la UX non è prioritaria.Molto BassaNessuna
    Libreria JSApplicazioni professionali e progetti seri. Risparmio di tempo e robustezza.BassaSì

    Il mio consiglio da sviluppatore:

    • Per un progetto personale o per imparare, prova assolutamente l'approccio Vanilla JS.
    • Per qualsiasi applicazione professionale, utilizza una libreria. Se hai solo bisogno del ridimensionamento, interact.js è una scelta fantastica e moderna. Se la tua tabella necessita di più funzionalità (filtri, ordinamento), vai direttamente su una libreria di data grid come Grid.js (leggera) o AG Grid (estremamente potente).

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.