KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / JavaScript

`contains()` en `parentElement`: afstammelingen en directe ouders in de DOM

`contains()` controleert of een knoop dezelfde knoop of een afstammeling daarvan is. `parentElement` geeft de directe ouder alleen terug als die een element is.

Versie: ECMAScript 2024 and the current web platform; runtime support varies

Syntax

container.contains(otherNode) // boolean; pass a Node or null
node.parentElement            // Element or null; read-only

container.contains(otherNode) geeft true terug als otherNode dezelfde knoop is als container of er op willekeurige diepte van afstamt, bijvoorbeeld als tekstknoop. Bij null geeft de methode false terug. Laat je het verplichte argument weg of geef je een tekenreeks door, dan krijg je een TypeError. Gebruik otherNode !== container && container.contains(otherNode) om container zelf uit te sluiten.

node.parentElement is een alleen-lezen eigenschap, geen methode. Deze geeft de directe ouder terug als die een Element is. Het resultaat is null als er geen ouder is of als de ouder een ander type heeft, zoals Document of DocumentFragment. De eigenschap zoekt niet verder omhoog in de boom. Gebruik node.parentNode om de directe ouder te krijgen, ongeacht het type.

Beide bewerkingen geven de huidige boomstructuur weer, ook als de boom losstaat van het document. Het verplaatsen van een knoop kan het resultaat veranderen. Geen van beide gaat van een shadow tree naar de host: volgens contains() bevat de host zijn shadow-knooppunten niet en voor een direct kind van een ShadowRoot is parentElement gelijk aan null.

Beide horen bij de DOM-interface Node en niet bij de taal ECMAScript 2024. De beschikbaarheid hangt ervan af of de uitvoeromgeving de bijbehorende DOM-API’s biedt.

Voorbeelden

<!doctype html>
<meta charset="utf-8">
<title>Node.contains() and Node.parentElement</title>
<script>
  const fragment = document.createDocumentFragment();
  const section = document.createElement("section");
  const span = document.createElement("span");
  const text = document.createTextNode("Hello");

  fragment.appendChild(section);
  section.appendChild(span);
  span.appendChild(text);

  console.log(`section.contains(text): ${section.contains(text)}`);
  console.log(`section.contains(section): ${section.contains(section)}`);
  console.log(`section.contains(null): ${section.contains(null)}`);
  console.log(`text.parentElement === span: ${text.parentElement === span}`);
  console.log(`section.parentElement: ${section.parentElement}`);
  console.log(`section.parentNode === fragment: ${section.parentNode === fragment}`);
</script>

Resultaat

section.contains(text): true
section.contains(section): true
section.contains(null): false
text.parentElement === span: true
section.parentElement: null
section.parentNode === fragment: true

Sla het voorbeeld op als `.html`-bestand, open het in een browser en bekijk de uitvoer in de ontwikkelaarsconsole. Het losstaande fragment bevat `section`, maar is geen `Element`. Daarom is `section.parentElement` gelijk aan `null`, hoewel `section.parentNode` het fragment is.

Gerelateerde lessen

  • JavaScript · Les 18 · Gevorderd · Versie: 4

Bronnen