recursal/MDN huggingface dataset:
HTMLTableRowElement.insertCell()
================================

La méthode **`HTMLTableRowElement.insertCell()`** insère une nouvelle cellule (`<td>`) dans une ligne de tableau (`<tr>`) et renvoie une référence sur cette cellule.

**Note :** `insertCell()` insère la cellule directement dans la ligne. La cellule n'a pas besoin d'être ajoutée séparément comme cela serait le cas si `Document.createElement()` avait été utilisé pour créer le nouvel élément `<td>`.

Syntaxe
-------


```js
var newCell = HTMLTableRowElement.insertCell(index);
```


`HTMLTableRowElement` est une référence sur un élément HTML `<tr>`.

### Paramètres

`index` Facultatif

`index` est l'index de cellule de la nouvelle cellule. Si `index` est `-1` ou égal au nombre actuel de cellules, la nouvelle cellule est ajoutée à la fin la ligne. Si `index` est supérieur au nombre de cellules, une exception `IndexSizeError` sera levée. Si `index` est omis, la valeur sera `-1` par défaut.

### Valeur de retour

`newCell` est une `HTMLTableCellElement` qui fait référence à la nouvelle cellule.

Exemple
-------

Cet exemple utilise `HTMLTableElement.insertRow()` pour ajouter une nouvelle ligne à une table.

Nous utilisons ensuite `insertCell(0)` pour insérer une nouvelle cellule dans la nouvelle ligne (pour être du HTML valide, un `<tr>` doit avoir au moins un élément `<td>`). Enfin, nous ajoutons du texte à la cellule en utilisant `Document.createTextNode()` et `Node.appendChild()`.

### HTML


```html
<table id="my-table">
  <tr>
    <td>Row 1</td>
  </tr>
  <tr>
    <td>Row 2</td>
  </tr>
  <tr>
    <td>Row 3</td>
  </tr>
</table>
```

### JavaScript


```js
function addRow(tableID) {
  // Obtient une référence sur la table
  let tableRef = document.getElementById(tableID);

  // Insère une ligne à la fin de la table
  let newRow = tableRef.insertRow(-1);

  // Insère une cellule dans la ligne à l’index 0
  let newCell = newRow.insertCell(0);

  // Ajoute un nœud texte à la cellule
  let newText = document.createTextNode("New bottom row");
  newCell.appendChild(newText);
}

// Appelle addRow() avec l’ID de la table
addRow("my-table");
```

### Résultat

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

| Specification |
| --- |
| HTML Standard # dom-tr-insertcell-dev |

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

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

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

* `HTMLTableElement.insertRow()`
* L'élément HTML représentant les cellules : `HTMLTableCellElement`
DOMTokenList.length
===================

La propriété en lecture seule **`length`** (*longueur*) de l'interface `DOMTokenList` est un `integer` (*entier*) représentant le nombre d'objets stockés dans la liste.

Syntaxe
-------


```js
tokenList.length;
```

### Value

Un `integer` (*entier*).

Exemples
--------

Dans l'exemple suivant, nous récupérons la liste des classes définies dans un élément `<span>` en tant que `DOMTokenList` en utilisant `Element.classList`, puis écrivons la longueur (*length*) de la liste dans le `Node.textContent` du `<span>`.

D'abord le HTML:


```html
<span class="a b c"></span>
```


Maintenant le JavaScript:


```js
var span = document.querySelector("span");
var classes = span.classList;
var length = classes.length;

span.textContent = "classList length = " + length;
```


La sortie ressemble à ceci :

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

| Specification |
| --- |
| DOM Standard # ref-for-dom-domtokenlist-length① |

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

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

La propriété **`value`** (*valeur*) de l'interface `DOMTokenList` renvoie la valeur de la liste en tant que `DOMString` (chaîne de caractères), ou efface et définit la liste à la valeur donnée.

Syntaxe
-------


```js
tokenList.value;
```

### Valeur

Une `DOMString` (*chaîne de caractères*).

Exemples
--------

Dans l'exemple suivant, nous récupérons la liste des classes définies sur un élément `<span>` en tant que `DOMTokenList` en utilisant `Element.classList`, puis écrivons alors la valeur de la liste dans le `Node.textContent` du `<span>`.

D'abord le HTML :


```html
<span class="a b c"></span>
```


Maintenant le JavaScript :


```js
var span = document.querySelector("span");
var classes = span.classList;
span.textContent = classes.value;
```


La sortie ressemble à ceci :

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

| Specification |
| --- |
| DOM Standard # ref-for-dom-domtokenlist-value② |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
DOMTokenList.entries()
======================

La méthode **`DOMTokenList.entries()`** renvoie un `itérateur` permettant de parcourir toutes les paires clé / valeur contenues dans cet objet. Les valeurs sont des objets `DOMString` (*chaînes de caractères*), chacun représentant une seule marque.

Syntaxe
-------


```js
tokenList.entries();
```

### Valeur retournée

Renvoie un `itérateur`.

Exemples
--------

Dans l'exemple suivant, nous récupérons la liste des classes définies sur un élément `<span>` en tant que `DOMTokenList` en utilisant `Element.classList`. Nous récupérons un itérateur contenant les paires clé / valeur en utilisant `entries()`, puis parcourons chacune d'entre elles en utilisant une boucle for ... of , et les écrivons dans un `Node.textContent` du `<span>`.

D'abord le HTML :


```html
<span class="a b c"></span>
```


Maintenant le JavaScript :


```js
var span = document.querySelector("span");
var classes = span.classList;
var iterator = classes.entries();

for (var value of iterator) {
  span.textContent += value + " ++ ";
}
```


La sortie ressemble à ceci :

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

#### No specification found

No specification data found for `api.DOMTokenList.entries`.  
Check for problems with this page or contribute a missing `spec_url` to mdn/browser-compat-data. Also make sure the specification is included in w3c/browser-specs.

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

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

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

* `DOMSettableTokenList` (objet qui étend DOMTokenList avec la propriété définissable *.value*)
DOMTokenList.values()
=====================

La méthode **`values()`** (*valeurs*) de l'interface `DOMTokenList` renvoie un `itérateur` permettant aux développeurs de passer en revue toutes les valeurs contenues dans la `DOMTokenList`. Individuellement, les valeurs sont des objets `DOMString` (*chaînes de caractères*).

Syntaxe
-------


```js
tokenList.values();
```

### Paramètres

Aucun.

### Valeur retournée

Renvoie un `itérateur`.

Exemples
--------

Dans l'exemple suivant, nous récupérons la liste des classes définies dans un élément `<span>` en tant que `DOMTokenList` en utilisant `Element.classList`. Si nous récupérons un itérateur contenant les valeurs en utilisant `values()`, nous les itérons alors en utilisant une boucle for ... of et écrivons chacune dans le `Node.textContent` du `<span>`.

D'abord, le HTML :


```html
<span class="a b c"></span>
```


Maintenant le JavaScript :


```js
var span = document.querySelector("span");
var classes = span.classList;
var iterator = classes.values();

for (var value of iterator) {
  span.textContent += value + " ++ ";
}
```


La sortie ressemble à ceci :

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

#### No specification found

No specification data found for `api.DOMTokenList.values`.  
Check for problems with this page or contribute a missing `spec_url` to mdn/browser-compat-data. Also make sure the specification is included in w3c/browser-specs.

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
DOMTokenList.item()
===================

La méthode **`item()`** de l'interface `DOMTokenList` renvoie un élément de la liste par son index.

Syntaxe
-------


```js
tokenList.item(index);
```

### Paramètres

index

Une `DOMString` (*chaîne de caractères*) représentant l'index de l'élément dont on veut le retour.

### Valeur retournée

Une `DOMString` (*chaîne de caractères*) représentant l'élément renvoyé. Le retour est `undefined` (*indéfini*) si le nombre est plus grand que ou égal à la longueur de la liste.

Exemples
--------

Dans l'exemple suivant, nous récupérons la liste des classes définies dans un élément `<span>` en tant que `DOMTokenList` en utilisant `Element.classList`. Nous récupérons le dernier élément dans la liste en utilisant *item(length-1)* et l'écrivons dans le `Node.textContent` du `<span>`.

D'abord le code HTML :


```html
<span class="a b c"></span>
```


Maintenant le JavaScript :


```js
var span = document.querySelector("span");
var classes = span.classList;
var item = classes.item(classes.length - 1);
span.textContent = item;
```


La sortie ressemble à ceci :

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

| Specification |
| --- |
| DOM Standard # ref-for-dom-domtokenlist-item① |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
DOMTokenList.toggle()
=====================

La méthode **`toggle()`** (qui signifie *basculer* en anglais) de l'interface `DOMTokenList` supprime un jeton (*token*) donné de la liste et renvoie `false`. Si *token* n'existe pas, il est ajouté et la fonction renvoie `true`.

Syntaxe
-------


```js
tokenList.toggle(token [, force]);
```

### Paramètres

token

Une chaîne de caractères `DOMString` représentant le jeton que l'on veut activer ou désactiver.

force Facultatif

Un *booléen* qui, s'il est inclus, transforme la bascule en opération à un seul sens. Si ce paramètre vaut `false`, le jeton sera seulement supprimé et aucun ajout ne suivra. S'il vaut `true`, le jeton sera seulement ajouté et pas supprimé.

### Valeur de retour

Un booléen qui vaut `true` ou `false` selon que le jeton se trouve dans la liste après l'exécution de la fonction ou non.

Exemples
--------

Dans l'exemple suivant, nous récupérons la liste des classes définies dans un élément `<span>` en tant que `DOMTokenList` en utilisant `Element.classList`. Lors d'un clic sur le texte, nous remplaçons alors un jeton dans la liste et écrivons la liste dans le `Node.textContent` du `<span>`.

### HTML


```html
<span class="a b">classList vaut 'a b'</span>
```

### JavaScript


```js
let span = document.querySelector("span");
let classes = span.classList;

span.addEventListener("click", function () {
  let result = classes.toggle("c");

  if (result) {
    span.textContent = `'c' ajouté ; classList vaut désormais "${classes}".`;
  } else {
    span.textContent = `'c' retiré ; classList vaut désormais "${classes}".`;
  }
});
```

### Résultat

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

| Specification |
| --- |
| DOM Standard # ref-for-dom-domtokenlist-toggle① |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
DOMTokenList.replace()
======================

La méthode **`replace()`** de l'interface `DOMTokenList` remplace une marque *(token)* existante par une nouvelle marque.

Syntaxe
-------


```js
tokenList.replace(oldToken, newToken);
```

### Paramètres

oldToken

Une `DOMString` (*chaîne de caractères*) représentant la marque que vous voulez remplacer.

newToken

Une `DOMString` (*chaîne de caractères*) représentant la marque avec laquelle vous voulez remplacer l'ancienne.

### Valeur retournée

Vide.

Exemples
--------

Dans l'exemple suivant, nous récupérons la liste des classes définies dans un élément `<span>` en tant que `DOMTokenList` en utilisant `Element.classList`. Nous remplaçons alors la marque dans la liste et écrivons la liste dans le `Node.textContent` du `<span>`.

D'abord, le HTML :


```html
<span class="a b c"></span>
```


Maintenant le JavaScript :


```js
var span = document.querySelector("span");
var classes = span.classList;
try {
  classes.replace("c", "z");
  span.textContent = classes;
} catch (e) {
  span.textContent = e;
}
```


La sortie ressemble à ceci :

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

| Specification |
| --- |
| DOM Standard # ref-for-dom-domtokenlist-replace① |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
DOMTokenList.contains()
=======================

La méthode **`contains()`** de l'interface `DOMTokenList` renvoie un `Boolean` (en-US) (*booléen*) — `true` (*vrai*) si la liste sous-jacente contient le symbole donné, sinon `false` (*faux*).

Syntaxe
-------


```js
tokenList.contains(token);
```

### Paramètres

token

Une `DOMString` (*chaîne de caractères*) représentant la "token" (*marque*) dont vous voulez vérifier l'existence dans la liste.

### Valeur renvoyée

Un `Boolean` (en-US) (*booléen*)— `true` (*vrai*) si la liste sous-jacente contient la marque donnée, sinon `false` (*faux*).

Exemples
--------

Dans l'exemple suivant, nous récupérons la liste des classes définies sur un élément `<span>` en tant que `DOMTokenList` en utilisant `Element.classList`. Nous testons ensuite l'existence de "c" dans la liste, et écrivons le résultat dans le `Node.textContent` du `<span>`.

Tout d'abord, le code HTML :


```html
<span class="a b c"></span>
```


Maintenant, le JavaScript :


```js
var span = document.querySelector("span");
var classes = span.classList;
var result = classes.contains("c");
if (result) {
  span.textContent = "The classList contains 'c'";
} else {
  span.textContent = "The classList does not contain 'c'";
}
```


La sortie ressemble à ceci :

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

| Specification |
| --- |
| DOM Standard # ref-for-dom-domtokenlist-contains① |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
DOMTokenList.forEach()
======================

La méthode **`forEach()`** de l'interface `DOMTokenList` appelle le retour donné en paramètre, un pour chaque paire de valeurs dans la liste, dans l'ordre d'insertion.

Syntaxe
-------


```js
tokenList.forEach(callback);
tokenList.forEach(callback, argument);
```

### Paramètres

`callback`

Fonction à exécuter pour chaque élément, prenant éventuellement 3 arguments :

*`currentValue`*

L'élément en cours de traitement dans le tableau.

`currentIndex`

L'index de l'élément en cours de traitement dans le tableau.

*`listObj`*

Le tableau que `forEach()` est en train d'appliquer.


`argument` Facultatif

Valeur à utiliser comme `this` lors de l'exécution du `callback` (*rappel*).

### Valeur renvoyée

`undefined` (*indéfinie*).

Exemple
-------

Dans l'exemple suivant, nous récupérons la liste des classes définies dans un élément `<span>` en tant que `DOMTokenList` en utilisant `Element.classList`. Nous récupérons un itérateur contenant les valeurs avec `forEach()` et écrivons chacune d'elles dans le `Node.textContent` du `<span>` pendant l'exécution de la fonction interne `forEach()`.

### HTML


```html
<span class="a b c"></span>
```

### JavaScript


```js
var span = document.querySelector("span");
var classes = span.classList;
var iterator = classes.values();

classes.forEach(function (value, key, listObj) {
  span.textContent += value + " " + key + "/" + this + " ++ ";
}, "arg");
```

### Résultat

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

#### No specification found

No specification data found for `api.DOMTokenList.forEach`.  
Check for problems with this page or contribute a missing `spec_url` to mdn/browser-compat-data. Also make sure the specification is included in w3c/browser-specs.

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

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

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

* `DOMSettableTokenList` (objet qui étend DOMTokenList avec la propriété définissable *.value*)
DOMTokenList.add()
==================

La méthode **`add()`** de l'interface `DOMTokenList` ajoute le *token* (*marque*) à la liste.

Syntaxe
-------


```js
tokenList.add(token1[, token2[, ...]]);
```

### Paramètres

token

Une `DOMString` (*chaîne de caractères*) représentant la marque (*token*) que vous souhaitez ajouter à la liste.

### Valeur renvoyée

Vide.

Exemples
--------

Dans l'exemple suivant, nous récupérons une liste des classes définies sur un élément `<span>` en tant que `DOMTokenList`, en utilisant `Element.classList`. Nous ajoutons alors une nouvelle marque à la liste et écrivons la liste dans un `Node.textContent` du `<span>`.

Tout d'abord, le code HTML :


```html
<span class="a b c"></span>
```


Maintenant, le JavaScript :


```js
var span = document.querySelector("span");
var classes = span.classList;
classes.add("d");
span.textContent = classes;
```


La sortie ressemble à ceci :

Vous pouvez ajouter plusieurs *token* :


```js
span.classList.add("d", "e", "f");
```

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

| Specification |
| --- |
| DOM Standard # ref-for-dom-domtokenlist-add① |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
DOMTokenList.remove()
=====================

La méthode **`remove()`** de l'interface `DOMTokenList` supprime sur la liste la marque (*token)* spécifiée.

Syntaxe
-------


```js
tokenList.remove(token1[, token2[, ...]]);
```

### Paramètres

tokenN...

Une `DOMString` (*chaîne de caractères*) représentant la marque que vous voulez supprimer sur la liste. Si la chaîne de caractères n'existe pas sur la liste, aucune erreur n'est levée et rien ne se passe.

### Valeur retournée

Vide.

Exemples
--------

Dans l'exemple suivant, nous récupérons la liste des classes définies dans l'élément `<span>` en tant que `DOMTokenList` en utilisant `Element.classList`. Nous retirons ensuite une marque sur la liste et écrivons la liste dans le `Node.textContent` du `<span>`.

D'abord, le HTML :


```html
<span class="a b c"></span>
```


Maintenant le JavaScript :


```js
var span = document.querySelector("span");
var classes = span.classList;
classes.remove("c");
span.textContent = classes;
```


La sortie ressemble à ceci :

Pour supprimer plusieurs classes à la fois, vous pouvez utiliser un tableau (*array*) avec la syntaxe de décomposition. L'ordre des classes n'a pas d'importance :


```js
let span = document.getElementsByTagName("span")[0],
  classes = span.classList;

classes.remove(...["c", "b"]);
span.textContent = classes;
```

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

| Specification |
| --- |
| DOM Standard # ref-for-dom-domtokenlist-remove① |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
DOMTokenList.supports()
=======================

**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 méthode **`supports()`** de l'interface `DOMTokenList` renvoie `true` (*vrai*) si une marque (*token)* donnée se trouve parmi les marques prises en charge dans l'attribut associé. Cette méthode est destinée à la détection des fonctionnalités.

Syntaxe
-------


```js
var boolean = element.supports(token);
```

### Paramètres

*`token`*

Une `DOMString` (*chaîne de caractères*) contenant la marque à interroger.

### Renvoie

un `Boolean` (*booléen*) indiquant si la marque a été trouvée.

Exemple
-------


```js
var iframe = document.getElementById("display");
if (iframe.sandbox.supports("an-upcoming-feature")) {
  // code de support pour la future et mystérieuse fonctionnalité
} else {
  // code de secours
}

if (iframe.sandbox.supports("allow-scripts")) {
  // instruction cadre de l'exécution de JavaScript
  // NOTE: ceci fonctionne bien mais est juste un exemple!
}
```

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

| Specification |
| --- |
| DOM Standard # ref-for-dom-domtokenlist-supports① |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
DOMTokenList.keys()
===================

La méthode **`keys()`** de l'interface `DOMTokenList` renvoie un `itérateur` permettant de parcourir toutes les clés contenues dans cet objet. Les clés sont de type `unsigned integer` *(entier non signé)*.

Syntaxe
-------


```js
tokenList.keys();
```

### Paramètres

Aucun.

### Valeur retournée

Renvoie un `itérateur`.

Exemples
--------

Dans l'exemple suivant, nous récupérons la liste des classes définies dans un élément `<span>` en tant que `DOMTokenList` en utilisant `Element.classList`. Ensuite nous récupérons un itérateur contenant les clés en utilisant `values()`, alors, nous itérons ces clés avec une boucle for ... of et écrivons chacune dans le `Node.textContent` du `<span>`.

D'abord, le HTML :


```html
<span class="a b c"></span>
```


Maintenant le JavaScript:


```js
var span = document.querySelector("span");
var classes = span.classList;
var iterator = classes.keys();

for (var value of iterator) {
  span.textContent += value + " ++ ";
}
```


La sortie ressemble à ceci :

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

#### No specification found

No specification data found for `api.DOMTokenList.keys`.  
Check for problems with this page or contribute a missing `spec_url` to mdn/browser-compat-data. Also make sure the specification is included in w3c/browser-specs.

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
BaseAudioContext.createBiquadFilter()
=====================================

La méthode `createBiquadFilter()` de l'interface `BaseAudioContext` crée un `BiquadFilterNode`, qui représente un filtre de second ordre configurable comme plusieurs types de filtres communs différents.

Syntaxe
-------


```js
baseAudioContext.createBiquadFilter();
```

### Retourne

un `BiquadFilterNode`.

Exemple
-------

L'exemple suivant montre une utilisation basique d'un AudioContext pour créer un nœud de filtre Biquad. Pour un exemple fonctionnel complet, visitez notre démonstration voice-change-o-matic (et lisez de même le code source).


```js
var audioCtx = new (window.AudioContext || window.webkitAudioContext)();

//set up the different audio nodes we will use for the app
var analyser = audioCtx.createAnalyser();
var distortion = audioCtx.createWaveShaper();
var gainNode = audioCtx.createGain();
var biquadFilter = audioCtx.createBiquadFilter();
var convolver = audioCtx.createConvolver();

// connect the nodes together

source = audioCtx.createMediaStreamSource(stream);
source.connect(analyser);
analyser.connect(distortion);
distortion.connect(biquadFilter);
biquadFilter.connect(convolver);
convolver.connect(gainNode);
gainNode.connect(audioCtx.destination);

// Manipulate the Biquad filter

biquadFilter.type = "lowshelf";
biquadFilter.frequency.setValueAtTime(1000, audioCtx.currentTime);
biquadFilter.gain.setValueAtTime(25, audioCtx.currentTime);
```

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

| Specification |
| --- |
| Web Audio API # dom-baseaudiocontext-createbiquadfilter |

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

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

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

* Utiliser l'API Web Audio (en-US)