recursal/MDN huggingface dataset:
XMLHttpRequest.timeout
======================

La propriété **`XMLHttpRequest.timeout`** est un `unsigned long` (un entier long, non-signé) représentant la durée, en millisecondes, qu'une requête peut prendre avant d'être automatiquement terminée. Par défaut, la valeur est 0 et il n'y pas de *timeout*. Lorsqu'une requête expire, un évènement `timeout` (en-US) est déclenché.

**Note :** Pour un exemple, voir Utiliser la propriété `timeout` avec une requête asynchrone (en-US).

**Note :** Ces délais d'expiration ne devraient pas être utilisés pour les requêtes `XMLHttpRequest` synchrones dans un environnement de document : ils déclencheront une exception `InvalidAccessError`. On ne peut donc pas utiliser de *timeout* pour les requêtes synchrones avec une fenêtre parente.

Exemples
--------


```js
var xhr = new XMLHttpRequest();
xhr.open("GET", "/server", true);

xhr.timeout = 2000; // durée en millisecondes

xhr.onload = function () {
  // Requête terminée. On traite le résultat ici.
};

xhr.ontimeout = function (e) {
  // Requête qui a expiré. On traite ce cas.
};

xhr.send(null);
```

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

| Specification |
| --- |
| XMLHttpRequest Standard # the-timeout-attribute |

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

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

La propriété XMLHttpRequest.readyState renvoie l'état dans lequel se trouve un client XMLHttpRequest.Un client XHR existe dans l'un des états suivants :

|  |  |  |
| --- | --- | --- |
| Value | State | Description |
| `0` | `UNSENT` | Le client a été créé. open() n'a pas encore été appelé. |
| `1` | `OPENED` | `open()`a été appelé. |
| `2` | `HEADERS_RECEIVED` | `send()` a été appelé, et les en-têtes et le statut sont
 disponibles.
  |
| `3` | `LOADING` | 
 Téléchargement; `responseText` contient des données
 partielles.
  |
| `4` | `DONE` | L'opération est terminée. |

UNSENT

Le client XMLHttpRequest a été créé, mais la méthode open() n'a pas encore été appelée.

OPENED

La méthode open() a été invoquée. Pendant cet état, les en-têtes de requête peuvent être définis à l'aide de la méthode setRequestHeader() et la méthode send() peut être appelée, ce qui lancera la récupération.

HEADERS\_RECEIVED

send() a été appelé et les en-têtes de réponse ont été reçus

LOADING

Le corps de la réponse est en cours de réception. Si `responseType` (en-US) is "text" ou une chaîne vide, `responseText` aura la réponse textuelle partielle au fur et à mesure de son chargement.

DONE

L'opération de récupération est terminée. Cela peut signifier que le transfert de données a été effectué avec succès ou a échoué.


**Note :** Les noms des états sont différents dans les versions d'Internet Explorer antérieures à 11. Au lieu de `UNSENT`, `OPENED`, `HEADERS_RECEIVED`, `LOADING` et `DONE`, les noms `READYSTATE_UNINITIALIZED` (0), `READYSTATE_LOADING` (1), `READYSTATE_LOADED` (2), `READYSTATE_INTERACTIVE` (3) et `READYSTATE_COMPLETE` (4) sont utilisés.

Exemple
-------


```js
var xhr = new XMLHttpRequest();
console.log("UNSENT", xhr.readyState); // readyState will be 0

xhr.open("GET", "/api", true);
console.log("OPENED", xhr.readyState); // readyState will be 1

xhr.onprogress = function () {
  console.log("LOADING", xhr.readyState); // readyState will be 3
};

xhr.onload = function () {
  console.log("DONE", xhr.readyState); // readyState will be 4
};

xhr.send(null);
```

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

| Specification |
| --- |
| XMLHttpRequest Standard # states |

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

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

La lecture seule `XMLHttpRequest` propriété **`responseText`** renvoie le texte reçu d'un serveur suite à l'envoi d'une requête.

Syntaxe
-------


```js
var resultText = XMLHttpRequest.responseText;
```

### Value

A `DOMString` qui contient soit les données textuelles reçues à l'aide du `XMLHttpRequest` ou `null` si la demande a échoué ou `""` si la demande n'a pas encore été envoyée en appelant `send()`.

Lors du traitement d'une requête asynchrone, la valeur de `responseText` reçoit toujours le contenu actuel du serveur, même s'il est incomplet car les données n'ont pas encore été complètement reçues.

Vous savez que tout le contenu a été reçu lorsque la valeur de `readyState` deviens `XMLHttpRequest.DONE` (`4`), et `status` becomes 200 (`"OK"`).

### Exceptions

`InvalidStateError`

Le `XMLHttpRequest.responseType` (en-US) n'est défini ni sur la chaîne vide ni sur "texte". Étant donné que la propriété responseText n'est valide que pour le contenu texte, toute autre valeur est une condition d'erreur.

Example
-------


```js
var xhr = new XMLHttpRequest();
xhr.open("GET", "/server", true);

// If specified, responseType must be empty string or "text"
xhr.responseType = "text";

xhr.onload = function () {
  if (xhr.readyState === xhr.DONE) {
    if (xhr.status === 200) {
      console.log(xhr.response);
      console.log(xhr.responseText);
    }
  }
};

xhr.send(null);
```

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

| Specification |
| --- |
| XMLHttpRequest Standard # the-responsetext-attribute |

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

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

La propriété en lecture seule XMLHttpRequest.status renvoie le code d'état HTTP numérique de la réponse de XMLHttpRequest.

Avant que la demande ne se termine, la valeur du statut est 0. Les navigateurs signalent également un statut de 0 en cas d'erreurs XMLHttpRequest.

Exemple
-------


```js
var xhr = new XMLHttpRequest();
console.log("UNSENT: ", xhr.status);

xhr.open("GET", "/server");
console.log("OPENED: ", xhr.status);

xhr.onprogress = function () {
  console.log("LOADING: ", xhr.status);
};

xhr.onload = function () {
  console.log("DONE: ", xhr.status);
};

xhr.send();

/\*\*
 \* Outputs the following:
 \*
 \* UNSENT: 0
 \* OPENED: 0
 \* LOADING: 200
 \* DONE: 200
 \*/
```

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

| Specification |
| --- |
| XMLHttpRequest Standard # the-status-attribute |

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

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

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

* Liste des HTTP response codes (en-US)
* HTTP
GlobalEventHandlers.onloadend
=============================

La propriété **`onloadend`** du "mixin" `GlobalEventHandlers` Un gestionnaire d'évènement représentant le code à appeler lorsque l'évènement `loadend` est déclenché (quand la progression est arrêtée sur le chargement d'une ressource).

Syntaxe
-------


```js
img.onloadend = funcRef;
```

### Valeur

`funcRef` est la fonction du gestionnaire à appeler quand l'évènement `loadend` de la ressource est déclenché.

Exemples
--------

### Contenu HTML


```html
<img src="myImage.jpg" />
```

### Contenu JavaScript


```js
// 'loadstart' est le premier lancé, puis 'load', puis 'loadend'

image.addEventListener("load", function (e) {
  console.log("Image loaded");
});

image.addEventListener("loadstart", function (e) {
  console.log("Image load started");
});

image.addEventListener("loadend", function (e) {
  console.log("Image load finished");
});
```

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

| Specification |
| --- |
| XMLHttpRequest Standard # event-xhr-loadend |
| XMLHttpRequest Standard # handler-xhr-onloadend |

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

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

Le constructeur **`XMLHttpRequest()`** crée un nouvel objet `XMLHttpRequest`.

Pour plus de détails sur l'utilisation de `XMLHttpRequest`, voir la page Utiliser `XMLHttpRequest`.

Syntaxe
-------


```js
new XMLHttpRequest();
```

### Paramètres

Aucun.

### Valeur de retour

Un nouvel objet `XMLHttpRequest`. L'objet doit être au minimum initialisé par l'appel de la méthode `open()` avant d'appeler `send()` pour envoyer la requête au serveur.

La syntaxe de Firefox non standard
----------------------------------

Firefox 16 a ajouté à ce constructeur un paramètre non standard qui peut activer le mode anonyme (voir le bug 692677). Définir une valeur de `true` pour le drapeau `mozAnon` est analogue au comportement du constructeur `AnonXMLHttpRequest()` décrit dans les versions antérieures de la spécification de `XMLHttpRequest`.


```js
const request = new XMLHttpRequest(paramsDictionary);
```

### Paramètres (non standard)

`objParameters`

Un drapeau qui peut être activé :

`mozAnon`

Un booléen. Si ce drapeau vaut `true`, il empêchera le navigateur d'exposer l'origine et des informations d'authentification lors de la récupération des ressources. Plus important encore, cela signifie que les cookies ne seront pas envoyés, sauf s'ils sont ajoutés de façon explicite en utilisant la méthode `setRequestHeader()`.


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

| Specification |
| --- |
| XMLHttpRequest Standard # dom-xmlhttprequest |

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

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

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

* Utiliser `XMLHttpRequest`
* HTML dans `XMLHttpRequest` (en-US)
IntersectionObserver.unobserve()
================================

La méthode **`unobserve()`** de l'interface `IntersectionObserver` indique à l'objet `IntersectionObserver` courant de cesser d'observer l'élément cible spécifié.

Syntaxe
-------


```js
IntersectionObserver.unobserve(target);
```

### Paramètres

`target`

L'`élément` à cesser d'observer. Si l'élément spécifié n'est pas en cours d'observation, cette méthode ne fait rien et ne lève pas d'exception.

### Valeur de retour

`undefined`.

Exemple
-------

Ce fragment de code illustre la création d'un observateur, l'ajout d'un élément sous observation puis l'arrêt de cette d'observation.


```js
let observer = new IntersectionObserver(callback);
observer.observe(document.getElementById("elementAObserver"));

/\* ... \*/

observer.unobserve(document.getElementById("elementAObserver"));
```

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

| Specification |
| --- |
| Intersection Observer # dom-intersectionobserver-unobserve |

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

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

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

* L'API *Intersection Observer*
* `IntersectionObserver.observe()`
IntersectionObserver.observe()
==============================

**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 **`observe()`** de l'interface `IntersectionObserver` ajoute un élément à l'ensemble des éléments cibles étant observés par l'`IntersectionObserver`. Un observateur possède un ensemble de seuils d'intersection et une racine, mais peut observer plusieurs éléments cibles en surveillant leurs changements de visibilité indépendamment. Pour cesser d'observer un élément, il faut appeler la méthode `IntersectionObserver.unobserve()`.

Lorsque la visibilité d'un élément cible franchit l'un des seuils d'intersection de l'observateur (tel que listé dans `IntersectionObserver.thresholds`, la fonction de rappel de l'observateur est executée avec comme argument un objet `IntersectionObserverEntry` représentant le changement d'intersection qui a été observé. À noter que cette conception permet à de multiples changements d'intersection d'éléments différents d'être traités par un unique appel à la fonction de rappel au moyen d'un tableau d'objets `IntersectionObserverEntry`.

Syntaxe
-------


```js
IntersectionObserver.observe(targetElement);
```

### Paramètres

`targetElement`

Un élément dont on souhaite observer les changements de visibilité dans la racine. Cet élément doit nécessairement être un descendant de l'élément racine (ou contenu dans le document courant si la racine est la fenêtre du document).

### Valeur de retour

`undefined`.

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

| Specification |
| --- |
| Intersection Observer # dom-intersectionobserver-observe |

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

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

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

* `IntersectionObserver.unobserve()`
IntersectionObserver.root
=========================

La propriété en lecture seule **`root`** de l'interface `IntersectionObserver` identifie l'`Element` ou le `Document` dont les bornes sont considérées comme la zone englobante (*bounding box*) de la zone d'affichage (*viewport*) au sein de laquelle les intersections avec la cible sont observées. Si `root` vaut `null`, ce sont les limites de la zone d'affichage (*viewport*) courantes qui sont utilisées.

Syntaxe
-------


```js
root = IntersectionObserver.root;
```

### Valeur

Un objet `Element` ou `Document` dont la boîte englobante est utilisée pour définir les limites de la zone de visibilité utilisée pour déterminer la proportion de l'élément cible qui est visible. L'intersection de ce rectangle délimiteur, décalé par toute marge spécifiée au moyen des options passées au constructeur de l'`IntersectionObserver()` (voir `options.rootMargin`), les limites de la zone recouverte par l'élément cible, moins les limites de la zone recouverte par chaque élément ou autre objet chevauchant l'élément cible, est considéré comme la partie visible de l'élément.

Si `root` vaut `null`, ce sera le document parent qui sera considéré comme racine et la zone d'intersection sera la zone d'affichage (*viewport*).

Exemple
-------

Cet exemple définit la propriété `border` de l'élément racine de l'observateur d'intersection comme une ligne verte moyenne de 2 pixels grâce aux propriétés exposées par CSSOM.


```js
observer.root.style.border = "2px solid #44aa44";
```

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

| Specification |
| --- |
| Intersection Observer # dom-intersectionobserver-root |

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

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

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

* Mesurer la visibilité d'un élément dans le temps l'API *Intersection Observer* (en-US)
IntersectionObserver.rootMargin
===============================

**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é **`rootMargin`** est une propriété en lecture seule de l'interface `IntersectionObserver`. C'est une chaîne de caractères avec une syntaxe similaire à celle de la propriété CSS `margin`. Chaque côté de la zone rectangulaire représentée par `rootMargin` est ajouté au côté correspondant de la boîte englobante de la racine de l'élément avant que le test d'intersection soit effectué. Cela permet, par exemple, d'ajuster les limites vers l'extérieur afin que l'élément cible soit considéré comme entièrement visible même si un certain nombre de pixels en largeur ou en hauteur sont rognés, ou encore pour traiter la cible comme partiellement masquée si une bordure est trop proche de celle de la boîte englobante de l'élément racine.

Voir la section sur l'élément racine et sa marge externe pour une explication plus approfondie à propos de la marge externe de l'élément racine et son fonctionnement.

Syntaxe
-------


```js
marginString = IntersectionObserver.rootMargin;
```

### Valeur

Une chaîne de caractères, formatée d'une manière similaire à la valeur de la propriété CSS `margin`, contenant les décalages pour un ou plusieurs côtés de la boîte englobante de l'élément racine. Ces décalages sont ajoutés aux valeurs correspondantes de la boîte englobante de l'élément racine avant le calcul de l'intersection entre la zone rectangulaire résultante et celle couverte par l'élément cible.

La chaîne de caractères renvoyée par cette propriété peut ne pas correspondre à celle spécifiée lors de l'initialisation de l'`IntersectionObserver`. Le navigateur a la possibilité de modifier la valeur.

Si `rootMargin` n'est pas spécifiée à l'initialisation de l'objet, sa valeur par défaut vaudra `"0px 0px 0px 0px"`, signifiant que l'intersection sera calculée entre les limites non modifiées de l'élément racine et celles de l'élément cible. La section sur l'élément racine et sa marge externe décrit avec plus de détails comment `rootMargin` est utilisée.

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

| Specification |
| --- |
| Intersection Observer # dom-intersectionobserver-rootmargin |

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

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

La méthode **`disconnect()`**, rattachée à l'interface `IntersectionObserver`, arrête l'observation des changements de visibilité de l'ensemble des éléments cibles.

Syntaxe
-------


```js
intersectionObserver.disconnect();
```

### Paramètres

Aucun.

### Valeur de retour

`undefined`.

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

| Specification |
| --- |
| Intersection Observer # dom-intersectionobserver-disconnect |

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

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

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

* `observe()`
* `unobserve()`
IntersectionObserver.takeRecords()
==================================

La méthode **`takeRecords()`** de l'interface `IntersectionObserver` renvoie un tableau d'objets `IntersectionObserverEntry`, un pour chaque élément ciblé qui a subi un changement d'intersection depuis la dernière vérification des intersections, soit explicitement par un appel à cette méthode, soit implicitement par un appel automatique à la fonction de rappel de l'observateur.

**Note :** Si vous utilisez la fonction de rappel pour surveiller ces changements, vous n'avez pas besoin d'appeler cette méthode. L'appel de cette méthode efface la liste des intersections en attente, de sorte que la fonction de rappel ne sera pas exécutée.

Syntaxe
-------


```js
intersectionObserverEntries = intersectionObserver.takeRecords();
```

### Paramètres

Aucun.

### Valeur de retour

Un tableau d'objets `IntersectionObserverEntry`, un pour chaque élément cible dont l'intersection avec la racine a changé depuis la dernière vérification des intersections.

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

| Specification |
| --- |
| Intersection Observer # dom-intersectionobserver-takerecords |

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

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

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

* L'API *Intersection Observer*
IntersectionObserver.thresholds
===============================

La propriété en lecture seule **`thresholds`** de l'interface `IntersectionObserver` retourne la liste des seuils d'intersection spécifiés lors de l'instanciation avec `IntersectionObserver()`. Si un seul seuil a été fourni lors de l'instanciation de l'objet, cette propriété sera un tableau contenant cette unique valeur numérique.

Voir la section sur les seuils pour apprendre comment fonctionnent les seuils d'intersection.

Syntaxe
-------


```js
thresholds = IntersectionObserver.thresholds;
```

### Valeur

Un tableau de seuils d'intersection, spécifiés lors de l'instanciation via `options.threshold`. Si un seul seuil a été fourni, sans être donné dans un tableau (avec une valeur numérique « brute » donc), la valeur de la propriété sera un tableau contenant cette unique valeur. Quel qu'ait été l'ordre du tableau fourni à l'origine, celui fournit par `thresholds` sera trié par ordre croissant.

Si aucune option `threshold` n'est fournie lors de l'instanciation avec `IntersectionObserver()`, la valeur par défaut de `thresholds` est définie à `[0]`.

**Attention :** Bien que l'objet d'`options` qu'on peut spécifier à la création d'un `IntersectionObserver` possède une propriété champ nommée `threshold`, cette propriété-ci s'appelle `thresholds` (avec un « s » supplémentaire donc). *Cela peut porter à confusion*. Si vous utilisez `thresholds` par erreur comme nom pour la propriété de l'objet `options`, le tableau porté par `thresholds` va se retrouver égal à `[0.0]`, ce qui n'est probablement pas ce à quoi vous vous attendiez. Le déboguage n'en sera que plus chaotique.

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

| Specification |
| --- |
| Intersection Observer # dom-intersectionobserver-thresholds |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
console : méthode statique clear()
==================================

La méthode **`console.clear()`** vide l'affichage de la console, si celle-ci le permet. Une console graphique, comme celle utilisée par les navigateurs, autorisera ce vidage, tandis qu'une console affichée dans un terminal (comme celle de Node.js), ne prendra pas en charge ce comportement et la méthode n'aura pas d'effet (et ne déclenchera pas d'erreur non plus).

Syntaxe
-------


```js
clear()
```

### Paramètres

Aucune.

### Valeur de retour

Aucune (`undefined`).

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

| Specification |
| --- |
| Console Standard # clear |

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
console : méthode statique groupCollapsed()
===========================================

La méthode **`console.groupCollapsed()`** crée un nouveau groupe dans le journal affiché dans la console. À la différence de `console.group()`, le groupe créé ici est replié. La personne devra utiliser l'icône de dépliage pour révéler les informations du groupe.

Il faudra appeler `console.groupEnd()` pour fermer le groupe courant et revenir au niveau du groupe parent.

Voir Utiliser les groupes dans la console pour plus de détails et d'exemples.

**Note:** Cette fonctionnalité est disponible via les Web Workers

Syntaxe
-------


```js
groupCollapsed()
groupCollapsed(libelle)
```

### Paramètres

`libelle` Facultatif

Un libellé identifiant le groupe courant.

### Valeur de retour

Aucune (`undefined`).

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

| Specification |
| --- |
| Console Standard # groupcollapsed |

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

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

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

* `console.group()`
* `console.groupEnd()`
console : méthode statique dirxml()
===================================

La méthode **`console.dirxml()`** affiche un arbre hiérarchique des éléments enfants de l'élément XML/HTML passé en argument. Si l'affichage sous la forme d'un élément n'est pas possible, l'argument est affiché comme un objet JavaScript.

Syntaxe
-------


```js
dirxml(objet)
```

### Paramètres

`objet`

Un objet JavaScript dont on souhaite afficher les propriétés.

### Valeur de retour

Aucune (`undefined`).

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

| Specification |
| --- |
| Console Standard # dirxml |

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

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