HTML Academy · Les

Templates klonen met cloneNode

Maak efficiënt instanties van template-inhoud met cloneNode(true)

Les 2 van 413 stappen

Templates klonen met cloneNode is een gratis HTML Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject HTML Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus HTML Academy bevat in totaal 4 lessen.

Diepe versus oppervlakkige kloon

De methode cloneNode accepteert een Booleaanse parameter:

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

Meerdere instanties vanuit één template

Je kunt templates een onbeperkt aantal keer klonen:

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 en prestaties

Voer DOM-updates in batches uit met DocumentFragment voor betere prestaties:

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

Klonen en eventlisteners

Eventlisteners op het oorspronkelijke template worden NIET gekopieerd:

// 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

Listeners toevoegen na het klonen

Koppel gebeurtenissen na het klonen:

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));

importNode gebruiken

document.importNode is een alternatief voor 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

Voorbeeld van slots in templates

Web Components gebruiken benoemde slots om inhoud in templates te injecteren:

<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 -->

Gekloonde inhoud bijwerken

Methoden om de inhoud van een gekloond template in te vullen:

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}`;

Vergelijking met document.createElement

template versus createElement voor herhaalde items:

// 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

Geheugen en templates

Geheugengedrag van templates:

  • Templates worden in het geheugen opgeslagen als DocumentFragments
  • Klonen zijn onafhankelijke kopieën — ze worden door de garbagecollector verwijderd wanneer ze uit de DOM worden verwijderd
  • De templates zelf blijven bestaan zolang het DOM-element bestaat
  • Bij dynamische templates cache je de templateverwijzing buiten de functie

Browserondersteuning

Ondersteuning voor het element template:

  • Ondersteund in alle moderne browsers sinds ongeveer 2014
  • Geen ondersteuning in IE (IE is niet meer in gebruik)
  • Voor moderne projecten is geen polyfill nodig

Korte toets

Waarom moeten eventlisteners opnieuw worden toegevoegd nadat je een template hebt gekloond?

Samenvatting: cloneNode

De belangrijkste punten van cloneNode:

  • cloneNode(true) — diepe kopie inclusief alle afstammelingen
  • Eventlisteners worden NIET gekopieerd — koppel ze na het klonen opnieuw
  • Voeg elementen in batches toe met DocumentFragment voor betere prestaties
  • Cache de templateverwijzing buiten weergavelussen
  • Gebruik textContent om tekst veilig in te voegen
Gratis beginnen

Leer HTML met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
40
Lessen
159

Veelgestelde vragen

Is de les “Templates klonen met cloneNode” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad HTML Academy, waaronder “Templates klonen met cloneNode”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus HTML Academy bevat in totaal 4 lessen.

Wat leer ik in “Templates klonen met cloneNode”?

Maak efficiënt instanties van template-inhoud met cloneNode(true) Je oefent met HTML Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met HTML Academy te beginnen?

Ervaring vooraf is niet nodig. HTML Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Templates klonen met cloneNode”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over HTML Academy?

Ja. Elke les over HTML Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. Het template-element: inactieve inhoud
  2. Templates klonen met cloneNode
  3. template gebruiken voor rendering met JavaScript
  4. Templates versus innerHTML: beveiliging
← Terug naar HTML Academy