0Pricing
HTML Academy · Lezione

Clonare i template con cloneNode

Generare efficientemente il contenuto di un template con cloneNode(true)

Clonare i template con cloneNode è una lezione HTML Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento HTML Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso HTML Academy include 4 lezioni in totale.

Clonazione profonda e superficiale

Il metodo cloneNode accetta un argomento booleano:

const template = document.getElementById('card-tmpl');

// Deep clone (true): copies all descendants
const deep = template.content.cloneNode(true);

// Shallow clone (false): only the root node, no children
const shallow = template.content.cloneNode(false);
// shallow has no children — use deep for templates

Più copie da un unico template

I template possono essere clonati un numero qualsiasi di volte:

const tmpl = document.getElementById('item-tmpl');
const container = document.getElementById('list');

['Alpha', 'Beta', 'Gamma'].forEach((name, i) => {
  const clone = tmpl.content.cloneNode(true);
  clone.querySelector('.item-name').textContent = name;
  clone.querySelector('.item-num').textContent = i + 1;
  container.appendChild(clone);
});
// 3 separate clones — modifying one doesn't affect others

DocumentFragment e prestazioni

Raggruppi gli aggiornamenti del DOM usando DocumentFragment per migliorare le prestazioni:

const frag = document.createDocumentFragment();
const tmpl = document.getElementById('row-tmpl');

rows.forEach(row => {
  const clone = tmpl.content.cloneNode(true);
  // fill in clone...
  frag.appendChild(clone);
});

// ONE DOM append instead of many:
document.getElementById('table-body').appendChild(frag);
// Appending to a fragment doesn't trigger layout; append once for performance

Clonazione e gestori di eventi

I gestori di eventi del template originale NON vengono copiati:

// Template definition:
const tmpl = document.getElementById('btn-tmpl');
const origBtn = tmpl.content.querySelector('.btn');
origBtn.addEventListener('click', () => console.log('click'));

// Clone:
const clone = tmpl.content.cloneNode(true);
const cloneBtn = clone.querySelector('.btn');
// cloneBtn does NOT have the click listener!
// You must re-add listeners after cloning

Aggiunta di gestori dopo la clonazione

Colleghi gli eventi dopo la clonazione:

function createCard(data) {
  const clone = document.getElementById('card-tmpl').content.cloneNode(true);

  const deleteBtn = clone.querySelector('.delete-btn');
  deleteBtn.addEventListener('click', () => deleteItem(data.id));

  clone.querySelector('.title').textContent = data.title;

  return clone;  // return the fragment
}

document.getElementById('list').appendChild(createCard(item));

Uso di importNode

document.importNode è un'alternativa a cloneNode:

const tmpl = document.getElementById('card-tmpl');

// Equivalent to tmpl.content.cloneNode(true):
const clone = document.importNode(tmpl.content, true);
// importNode adopts the node into the current document
// In the same document, this is functionally identical to cloneNode

Anteprima degli slot di template

I Web Components usano slot denominati per inserire contenuti nei template:

<template id="card-tmpl">
  <div class="card">
    <slot name="title">Default Title</slot>
    <slot name="body">Default body text.</slot>
  </div>
</template>
<!-- slot elements become placeholders for projected content -->
<!-- Covered in full in the Shadow DOM course -->

Aggiornamento del contenuto clonato

Metodi per completare il contenuto di un template clonato:

const clone = tmpl.content.cloneNode(true);

// textContent — safe, no HTML parsing:
clone.querySelector('.name').textContent = user.name;

// innerHTML — only if content is trusted:
clone.querySelector('.bio').innerHTML = trustedHTML;

// setAttribute:
clone.querySelector('.avatar').src = user.avatar;
clone.querySelector('.profile-link').href = `/users/${user.id}`;

Confronto con document.createElement

template a confronto con createElement per elementi ripetuti:

// createElement: verbose for complex structures
const card = document.createElement('div');
card.className = 'card';
const title = document.createElement('h2');
card.appendChild(title);
// ... many lines for nested structure

// template: define once, clone efficiently
const clone = tmpl.content.cloneNode(true);
// Complex structure defined in HTML once
// Clone is fast and the template handles nesting

Memoria e template

Comportamento dei template in memoria:

  • I template vengono memorizzati in memoria come DocumentFragment
  • I cloni sono copie indipendenti — vengono rimossi dal garbage collector quando sono eliminati dal DOM
  • I template persistono finché esiste l'elemento DOM
  • Per i template dinamici, memorizzi il riferimento al template all'esterno della funzione

Supporto nei browser

Supporto dell'elemento template:

  • Supportato da tutti i browser moderni dal 2014 circa
  • Nessun supporto in IE (IE non è più supportato)
  • Non è necessario alcun polyfill per i progetti moderni

Verifica rapida

Perché è necessario aggiungere nuovamente i gestori di eventi dopo aver clonato un template?

Riepilogo: cloneNode

Elementi essenziali di cloneNode:

  • cloneNode(true) — copia profonda che include tutti i discendenti
  • I gestori di eventi NON vengono copiati — li ricolleghi dopo la clonazione
  • Raggruppi le aggiunte con DocumentFragment per migliorare le prestazioni
  • Memorizzi il riferimento al template all'esterno dei cicli di rendering
  • Usi textContent per inserire testo in modo sicuro

Domande Frequenti

La lezione «Clonare i template con cloneNode» è gratuita?

Sì — il testo completo di «Clonare i template con cloneNode» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso HTML Academy, passa a CoddyKit PRO. Il corso HTML Academy include 4 lezioni in totale.

Cosa imparerò in «Clonare i template con cloneNode»?

Generare efficientemente il contenuto di un template con cloneNode(true) Eserciti HTML Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare HTML Academy?

Non è richiesta alcuna esperienza precedente. HTML Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Clonare i template con cloneNode»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione HTML Academy?

Sì. Ogni lezione HTML Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. L’elemento template: contenuto inattivo
  2. Clonare i template con cloneNode
  3. Usare template per il rendering con JavaScript
  4. Template e sicurezza di innerHTML
← Torna a HTML Academy