recursal/MDN huggingface dataset:
CanvasRenderingContext2D.save()
===============================

La méthode **`CanvasRenderingContext2D.save()`** de l'API Canvas 2D API enregistre l'état complet du canvas en plaçant l'état courant dans une stack.

### L'état du dessin

L'état du dessin qui est sauvegardé dans une stack se compose de :

* La matrice de transformation actuelle.
* La région de détourage actuelle.
* Le tableau pour les tracés en pointillés.
* Les valeurs des attributs suivant : `strokeStyle`, `fillStyle`, `globalAlpha`, `lineWidth` (en-US), `lineCap`, `lineJoin`, `miterLimit` (en-US), `lineDashOffset` (en-US), `shadowOffsetX` (en-US), `shadowOffsetY` (en-US), `shadowBlur` (en-US), `shadowColor` (en-US), `globalCompositeOperation`, `font`, `textAlign`, `textBaseline`, `direction`, `imageSmoothingEnabled`.
Syntaxe
-------


```js
void ctx.save();
```

Exemples
--------

### Enregistrer l'état du dessin

Cet exemple utilise la méthode `save()` pour enregistrer l'état par défaut et `restore()` pour le rétablir plus tard, on pourra ainsi dessiner un rectangle avec l'état de base après.

#### HTML


```html
<canvas id="canvas"></canvas>
```


#### JavaScript


```js
const canvas = document.getElementById("canvas");
const ctx = canvas.getContext("2d");

// On sauvegarde l'état par défaut
ctx.save();

ctx.fillStyle = "green";
ctx.fillRect(10, 10, 100, 100);

// On restaure l'état par défaut
ctx.restore();

ctx.fillRect(150, 40, 100, 100);
```


#### Résultat

Spécifications
--------------

| Specification |
| --- |
| HTML Standard # dom-context-2d-save-dev |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* L'interface définissant cette méthode : `CanvasRenderingContext2D`
* `CanvasRenderingContext2D.restore()` (en-US)
CanvasRenderingContext2D.imageSmoothingEnabled
==============================================

**Expérimental:** **Cette fonction est expérimentale**  
Puisque cette fonction est toujours en développement dans certains navigateurs, veuillez consulter le tableau de compatibilité pour les préfixes à utiliser selon les navigateurs.  
Il convient de noter qu'une fonctionnalité expérimentale peut voir sa syntaxe ou son comportement modifié dans le futur en fonction des évolutions de la spécification.

La propriété `CanvasRenderingContext2D.imageSmoothingEnabled` de l'API Canvas 2D peut être affectée pour changer le fait que les images soient lissées (`true`, par défaut) ou non (`false`). Lors de la récupération de la propriété `imageSmoothingEnabled`, la dernière valeur à laquelle elle a été définie est renvoyée.

Cette propriété est utile pour les jeux à thème pixel-art, lors d'une mise à l'échelle du canvas par exemple. L'algorithme de redimensionnement par défaut peut créer des effets de flou et ruiner les jolis pixels. Mettez cette propriété à `false` dans ce cas. Voir aussi la propriété CSS `image-rendering`.

Syntaxe
-------


```js
ctx.imageSmoothingEnabled = valeur;
```

### Options

`valeur`

Un `Boolean` indiquant de lisser les images ou non.

Exemples
--------

### Désactiver le lissage d'image

Dans cet exemple, on compare trois images. La première image est dessinée avec sa taille naturelle, la deuxième est élargie pour obtenir 3 fois la taille originale et le lissage est activée, la troisième est élargie pour obtenir 3 fois la taille originale et le lissage est désactivé.

#### HTML


```html
<canvas id="canvas" width="460" height="210"></canvas>
```


#### JavaScript


```js
const canvas = document.getElementById("canvas");

const ctx = canvas.getContext("2d");
ctx.font = "16px sans-serif";
ctx.textAlign = "center";

const img = new Image();
img.src =
  "https://interactive-examples.mdn.mozilla.net/media/examples/star.png";
img.onload = function () {
  const w = img.width,
    h = img.height;

  ctx.fillText("Source", w \* 0.5, 20);
  ctx.drawImage(img, 0, 24, w, h);

  ctx.fillText("Smoothing = TRUE", w \* 2.5, 20);
  ctx.imageSmoothingEnabled = true;
  ctx.drawImage(img, w, 24, w \* 3, h \* 3);

  ctx.fillText("Smoothing = FALSE", w \* 5.5, 20);
  ctx.imageSmoothingEnabled = false;
  ctx.drawImage(img, w \* 4, 24, w \* 3, h \* 3);
};
```


#### Résultat

Spécifications
--------------

| Specification |
| --- |
| HTML Standard # dom-context-2d-imagesmoothingenabled-dev |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* L'interface la définissant, `CanvasRenderingContext2D`
* `image-rendering`
CanvasRenderingContext2D.translate()
====================================

La méthode **CanvasRenderingContext2D.translate()** de l'API Canvas 2D ajoute une transformation de translation en déplaçant le canevas et son origine x horizontalement et y verticalement sur la grille.

Syntaxe
-------


```js
void ctx.translate(x, y);
```


![](/fr/docs/Web/API/CanvasRenderingContext2D/translate/canvas_grid_translate.png)

### Paramètres

`x`

Distance de déplacement dans le sens horizontal.

y

Distance de déplacement dans le sens vertical.

Exemples
--------

### Utilisation de la méthode `translate`

Il s'agit seulement d'un extrait de code simple qui utilise la méthode translate.

#### HTML


```html
<canvas id="canevas"></canvas>
```


#### JavaScript


```js
var canevas = document.getElementById("canevas");
var ctx = canevas.getContext("2d");

ctx.translate(50, 50);
ctx.fillRect(0, 0, 100, 100);

// Réinitialise la matrice de transformation en cours à la matrice identité
ctx.setTransform(1, 0, 0, 1, 0, 0);
```


Modifiez le code ci-dessous et voyez vos modifications mises à jour en direct sur le canevas :

#### Code jouable
```

<canvas id="canvas" width="400" height="200" class="playable-canvas"></canvas>
<div class="playable-buttons">
  <input id="edit" type="button" value="Edit" />
  <input id="reset" type="button" value="Reset" />
</div>
<textarea id="code" class="playable-code">
ctx.translate(50, 50);
ctx.fillRect(0,0,100,100);
ctx.setTransform(1, 0, 0, 1, 0, 0);</textarea
>
```


```
var canvas = document.getElementById("canvas");
var ctx = canvas.getContext("2d");
var textarea = document.getElementById("code");
var reset = document.getElementById("reset");
var edit = document.getElementById("edit");
var code = textarea.value;

function drawCanvas() {
  ctx.clearRect(0, 0, canvas.width, canvas.height);
  eval(textarea.value);
}

reset.addEventListener("click", function () {
  textarea.value = code;
  drawCanvas();
});

edit.addEventListener("click", function () {
  textarea.focus();
});

textarea.addEventListener("input", drawCanvas);
window.addEventListener("load", drawCanvas);
```

Spécifications
--------------

| Specification |
| --- |
| HTML Standard # dom-context-2d-translate-dev |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* L'interface la définissant, `CanvasRenderingContext2D`
CanvasRenderingContext2D.closePath()
====================================

La méthode **`CanvasRenderingContext2D.closePath()`** de l'API Canvas 2D provoque le retour du stylo au point de départ du sous-traçé courant. Il le fait en ajoutant une ligne droite entre le point courant et le point rejoint. Si la figure a déjà été fermée ou n'est constituée que d'un seul point, cette méthode ne provoque rien.

Syntaxe
-------
```

void ctx.closePath();
```

Exemples
--------

### Utiliser la méthode `closePath`

Voici un exemple d'utilisation de la méthode closePath.

#### HTML


```html
<canvas id="canvas"></canvas>
```


#### JavaScript


```js
var canvas = document.getElementById("canvas");
var ctx = canvas.getContext("2d");

ctx.beginPath();
ctx.moveTo(20, 20);
ctx.lineTo(200, 20);
ctx.lineTo(120, 120);
ctx.closePath(); // ferme le triangle par une ligne droite
ctx.stroke();
```


Editez le code ci-dessous et observez les répercutions dans le canvas:

#### Code jouable
```

<canvas id="canvas" width="400" height="200" class="playable-canvas"></canvas>
<div class="playable-buttons">
  <input id="edit" type="button" value="Edit" />
  <input id="reset" type="button" value="Reset" />
</div>
<textarea id="code" class="playable-code" style="height:140px;">
ctx.beginPath();
ctx.moveTo(20,20);
ctx.lineTo(200,20);
ctx.lineTo(120,120);
ctx.closePath(); // draws last line of the triangle
ctx.stroke();</textarea
>
```


```
var canvas = document.getElementById("canvas");
var ctx = canvas.getContext("2d");
var textarea = document.getElementById("code");
var reset = document.getElementById("reset");
var edit = document.getElementById("edit");
var code = textarea.value;

function drawCanvas() {
  ctx.clearRect(0, 0, canvas.width, canvas.height);
  eval(textarea.value);
}

reset.addEventListener("click", function () {
  textarea.value = code;
  drawCanvas();
});

edit.addEventListener("click", function () {
  textarea.focus();
});

textarea.addEventListener("input", drawCanvas);
window.addEventListener("load", drawCanvas);
```

Spécifications
--------------

| Specification |
| --- |
| HTML Standard # dom-context-2d-closepath-dev |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* The interface defining it, `CanvasRenderingContext2D`
* `CanvasRenderingContext2D.beginPath()`
CanvasRenderingContext2D.stroke()
=================================

La méthode **`CanvasRenderingContext2D.stroke()`** de l'API Canvas 2D dessine le chemin actuel ou donné avec le style de trait actuel utilisant la règle d'enroulement non nulle.

Syntaxe
-------


```js
void ctx.stroke();
void ctx.stroke(path);
```

### Paramètres

`path`

Un chemin `Path2D` (en-US) à dessiner.

Exemples
--------

### Utilisation de la méthode `stroke`

Il s'agit d'un extrait de code simple utilisant la méthode `stroke` pour tracer un chemin.

#### HTML


```html
<canvas id="canvas"></canvas>
```


#### JavaScript


```js
var canvas = document.getElementById("canvas");
var ctx = canvas.getContext("2d");
ctx.rect(10, 10, 100, 100);
ctx.stroke();
```


Editer le code en dessous et voir vos modifications mises à jour en direct dans le canevas :

#### Code jouable
```

<canvas id="canvas" width="400" height="200" class="playable-canvas"></canvas>
<div class="playable-buttons">
  <input id="edit" type="button" value="Edit" />
  <input id="reset" type="button" value="Reset" />
</div>
<textarea id="code" class="playable-code">
ctx.rect(10, 10, 100, 100);
ctx.stroke();</textarea
>
```


```
var canvas = document.getElementById("canvas");
var ctx = canvas.getContext("2d");
var textarea = document.getElementById("code");
var reset = document.getElementById("reset");
var edit = document.getElementById("edit");
var code = textarea.value;

function drawCanvas() {
  ctx.clearRect(0, 0, canvas.width, canvas.height);
  eval(textarea.value);
}

reset.addEventListener("click", function () {
  textarea.value = code;
  drawCanvas();
});

edit.addEventListener("click", function () {
  textarea.focus();
});

textarea.addEventListener("input", drawCanvas);
window.addEventListener("load", drawCanvas);
```

Spécifications
--------------

| Specification |
| --- |
| HTML Standard # dom-context-2d-stroke-dev |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* L'interface qui le définit, `CanvasRenderingContext2D`.
CanvasRenderingContext2D.rect()
===============================

La méthode **`CanvasRenderingContext2D.rect()`** de l'API Canvas 2D crée un chemin de rectangle à la position *(x, y)* et de dimensions *width* et *height*. Ces quatre points sont connectés par des lignes droites et le sous-chemin est directement fermé, vous pouvez donc utiliser `fill` ou `stroke` pour dessiner ce rectangle.

Syntaxe
-------


```js
void ctx.rect(x, y, width, height);
```

### Paramètres

`x`

La coordonnée x pour le côté gauche du rectangle.

`y`

La coordonnée y pour le haut du rectangle.

`width`

La largeur du rectangle.

`height`

La hauteur du rectangle.

Exemples
--------

### Utiliser la méthode `rect`

Ceci est un simple bout de code qui utilise la méthode `rect` pour dessiner un chemin. Pour réellement dessiner ce chemin sur le canvas, vous devez utiliser la méthode `fill()` ou `stroke()`. Voir également les méthodes `fillRect()` et `strokeRect()`, qui peuvent le faire en une seule étape.

#### HTML


```html
<canvas id="canvas"></canvas>
```


#### JavaScript


```js
var canvas = document.getElementById("canvas");
var ctx = canvas.getContext("2d");
ctx.rect(10, 10, 100, 100);
ctx.fill();
```


Éditez le code ci-dessous pour voir vos mises à jour apportées au canvas directement:

#### Code jouable
```

<canvas id="canvas" width="400" height="200" class="playable-canvas"></canvas>
<div class="playable-buttons">
  <input id="edit" type="button" value="Edit" />
  <input id="reset" type="button" value="Reset" />
</div>
<textarea id="code" class="playable-code">
ctx.rect(10, 10, 100, 100);
ctx.fill();</textarea
>
```


```
var canvas = document.getElementById("canvas");
var ctx = canvas.getContext("2d");
var textarea = document.getElementById("code");
var reset = document.getElementById("reset");
var edit = document.getElementById("edit");
var code = textarea.value;

function drawCanvas() {
  ctx.clearRect(0, 0, canvas.width, canvas.height);
  eval(textarea.value);
}

reset.addEventListener("click", function () {
  textarea.value = code;
  drawCanvas();
});

edit.addEventListener("click", function () {
  textarea.focus();
});

textarea.addEventListener("input", drawCanvas);
window.addEventListener("load", drawCanvas);
```

Spécifications
--------------

| Specification |
| --- |
| HTML Standard # dom-context-2d-rect-dev |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* L'interface qui définit cette méthode, `CanvasRenderingContext2D`
* `CanvasRenderingContext2D.fillRect`
* `CanvasRenderingContext2D.strokeRect()`
* `CanvasRenderingContext2D.fill()`
* `CanvasRenderingContext2D.stroke()`
CanvasRenderingContext2D.lineTo()
=================================

La méthode **`CanvasRenderingContext2D.lineTo()`** de l'API Canvas 2D connecte le dernier point du sous-chemin en cours aux coordonnées `x, y` spécifiées avec une ligne droite (sans tracer réellement le chemin).

Syntaxe
-------


```js
void ctx.lineTo(x, y);
```

### Paramètres

`x`

L'abscisse *x* du point d'arrivée.

`y`

L'ordonnée *y* du point d'arrivée.

Exemples
--------

### Utilisation de la méthode `lineTo`

Ceci est un extrait de code utilisant la méthode `lineTo`. Il faut utiliser la méthode `beginPath()` pour débuter un dessin, pour ensuite pouvoir dessiner une ligne dessus. On peut déplacer le crayon avec la méthode `moveTo()` et utiliser la méthode `stroke()` pour rendre la ligne visible.

#### HTML


```html
<canvas id="canvas"></canvas>
```


#### JavaScript


```js
var canvas = document.getElementById("canvas");
var ctx = canvas.getContext("2d");

ctx.beginPath();
ctx.moveTo(50, 50);
ctx.lineTo(100, 100);
ctx.stroke();
```


Éditez le code suivant pour voir les changements en direct:

#### Code jouable
```

<canvas id="canvas" width="400" height="200" class="playable-canvas"></canvas>
<div class="playable-buttons">
  <input id="edit" type="button" value="Edit" />
  <input id="reset" type="button" value="Reset" />
</div>
<textarea id="code" class="playable-code">
ctx.beginPath();
ctx.moveTo(50,50);
ctx.lineTo(100, 100);
ctx.stroke();</textarea
>
```


```
var canvas = document.getElementById("canvas");
var ctx = canvas.getContext("2d");
var textarea = document.getElementById("code");
var reset = document.getElementById("reset");
var edit = document.getElementById("edit");
var code = textarea.value;

function drawCanvas() {
  ctx.clearRect(0, 0, canvas.width, canvas.height);
  eval(textarea.value);
}

reset.addEventListener("click", function () {
  textarea.value = code;
  drawCanvas();
});

edit.addEventListener("click", function () {
  textarea.focus();
});

textarea.addEventListener("input", drawCanvas);
window.addEventListener("load", drawCanvas);
```

Spécifications
--------------

| Specification |
| --- |
| HTML Standard # dom-context-2d-lineto-dev |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* l'interface qui la définit, `CanvasRenderingContext2D`
* `CanvasRenderingContext2D.moveTo()`
* `CanvasRenderingContext2D.stroke()`
CanvasRenderingContext2D.textBaseline
=====================================

La propriété **`CanvasRenderingContext2D.textBaseline`** de l'API Canvas 2D spécifie la ligne de base de texte à utiliser lors du dessin d'un texte.

Syntaxe
-------


```js
ctx.textBaseline =
  "top" || "hanging" || "middle" || "alphabetic" || "ideographic" || "bottom";
```

### Options

Valeurs possibles :

top

La ligne de base du texte est le haut du cadratin.

hanging

La ligne de base du texte est la ligne de base supérieure.

middle

La ligne de base du texte est le milieu du cadratin.

alphabetic

La ligne de base du texte est la ligne de base normale alphabétique.

ideographic

La ligne de base du texte est la ligne de base idéographique ; c'est le bas du corps des caractères, si le corps principal des caractères fait saillie en dessous de la ligne de base alphabétique.

bottom

La ligne de base du texte est le bas du cadre. Cela diffère de ligne de base idéographique en ce que la ligne de base idéographique ne prend pas en considération les jambages.

La valeur par défaut est `alphabetic`.

Exemples
--------

### Utilisation de la propritété `textBaseline`

Ceci est seulement un fragment de code simple utilisant la propriété `textBaseline` pour définir un réglage différent de ligne de base de texte.

#### HTML


```html
<canvas id="canvas"></canvas>
```


#### JavaScript


```js
var canvas = document.getElementById("canvas");
var ctx = canvas.getContext("2d");

ctx.font = "48px serif";
ctx.textBaseline = "hanging";
ctx.strokeText("Hello world", 0, 100);
```


Modifiez le code ci-dessous et voyez vos changements mis à jour en temps réel dans le canevas :

#### Code jouable
```

<canvas id="canvas" width="400" height="200" class="playable-canvas"></canvas>
<div class="playable-buttons">
  <input id="edit" type="button" value="Edit" />
  <input id="reset" type="button" value="Reset" />
</div>
<textarea id="code" class="playable-code">
ctx.font = '48px serif';
ctx.textBaseline = 'hanging';
ctx.strokeText('Hello world', 0, 100);</textarea
>
```


```
var canvas = document.getElementById("canvas");
var ctx = canvas.getContext("2d");
var textarea = document.getElementById("code");
var reset = document.getElementById("reset");
var edit = document.getElementById("edit");
var code = textarea.value;

function drawCanvas() {
  ctx.clearRect(0, 0, canvas.width, canvas.height);
  eval(textarea.value);
}

reset.addEventListener("click", function () {
  textarea.value = code;
  drawCanvas();
});

edit.addEventListener("click", function () {
  textarea.focus();
});

textarea.addEventListener("input", drawCanvas);
window.addEventListener("load", drawCanvas);
```

Spécifications
--------------

| Specification |
| --- |
| HTML Standard # dom-context-2d-textbaseline-dev |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* L'interface la définissant, `CanvasRenderingContext2D`.
NodeIterator.previousNode()
===========================

La méthode **`NodeIterator.previousNode()`** renvoie le noeud précédent dans l'ensemble représenté par le `NodeIterator` et déplace la position de l'itérateur vers l'arrière à l'intérieur de cet ensemble.

Cette méthode renvoie `null` si le noeud courant est le premier noeud dans l'ensemble.

Dans les navigateurs anciens, comme spécifié dans les anciennes version des spécifications, la méthode pouvait déclencher une `INVALID_STATE_ERR` `DOMException` si elle était appelée après la méthode `NodeIterator.detach()`. Les navigateurs récents ne lancent rien.

Syntaxe
-------


```js
node = nodeIterator.previousNode();
```

Exemple
-------


```js
var nodeIterator = document.createNodeIterator(
  document.body,
  NodeFilter.SHOW\_ELEMENT,
  {
    acceptNode: function (node) {
      return NodeFilter.FILTER\_ACCEPT;
    },
  },
  false, // cet argument facultatif n'est plus utilisé
);
currentNode = nodeIterator.nextNode(); // renvoie le noeud suivant
previousNode = nodeIterator.previousNode(); // même résultat, puisque nous sommes retournés au noeud précédent
```

Spécifications
--------------

| Specification |
| --- |
| DOM Standard # dom-nodeiterator-previousnode |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* L'interface à laquelle elle appartient : `NodeIterator`.
NodeIterator.referenceNode
==========================

**Expérimental:** **Cette fonction est expérimentale**  
Puisque cette fonction est toujours en développement dans certains navigateurs, veuillez consulter le tableau de compatibilité pour les préfixes à utiliser selon les navigateurs.  
Il convient de noter qu'une fonctionnalité expérimentale peut voir sa syntaxe ou son comportement modifié dans le futur en fonction des évolutions de la spécification.

La propriété en lecture seule **`NodeIterator.referenceNode`** renvoie le `Node` auquel l'itérateur est ancré ; si de nouveaux noeuds sont insérés, l'itérateur reste ancré au noeud de référence spécifié par cette propriété.

Syntaxe
-------


```js
node = nodeIterator.referenceNode;
```

Exemple
-------


```js
var nodeIterator = document.createNodeIterator(
  document.body,
  NodeFilter.SHOW\_ELEMENT,
  {
    acceptNode: function (node) {
      return NodeFilter.FILTER\_ACCEPT;
    },
  },
  false,
);
node = nodeIterator.referenceNode;
```

Spécifications
--------------

| Specification |
| --- |
| DOM Standard # dom-nodeiterator-referencenode |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* L'interface à laquelle elle appartient : `NodeIterator`
NodeIterator.nextNode()
=======================

La méthode **`NodeIterator.nextNode()`** renvoie le noeud suivant dans l'ensemble représenté par le `NodeIterator` et avance la position de l'itérateur dans cet ensemble. Le premier appel de `nextNode()` en renvoie le premier noeud.

Cette méthode retourne `null` quand il n'y a plus de nœuds dans l'ensemble.

Dans les navigateurs anciens, comme spécifié dans les anciennes version des spécifications, la méthode pouvait déclencher une `DOMException` `INVALID_STATE_ERR` si elle était appelée après la méthode `NodeIterator.detach()`. Les navigateurs récents ne lancent rien.

Syntaxe
-------


```js
node = nodeIterator.nextNode();
```

Exemple
-------


```js
var nodeIterator = document.createNodeIterator(
  document.body,
  NodeFilter.SHOW\_ELEMENT,
  {
    acceptNode: function (node) {
      return NodeFilter.FILTER\_ACCEPT;
    },
  },
  false, // this optional argument is not used any more
);
currentNode = nodeIterator.nextNode(); // renvoie le noeud suivant.
```

Spécifications
--------------

| Specification |
| --- |
| DOM Standard # dom-nodeiterator-nextnode |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

L'interface à laquelle elle appartient : `NodeIterator`.