recursal/MDN huggingface dataset:
hashchange
==========

L'événement `hashchange` est déclenché lorsque l'identificateur de fragment de l'URL a changé (la partie de l'URL qui suit le symbole #, y compris le symbole # lui-même).

|  |  |
| --- | --- |
| Bulles | Oui |
| Annulable | Non |
| Objets cibles | `Window` |
| Interface | `HashChangeEvent` (en-US) |
| Action par défaut | Aucune |

Propriétés
----------

| Propriété | Type | Description |
| --- | --- | --- |
| `target` Lecture seule  | `EventTarget` | The browsing context (`window`). |
| `type` Lecture seule  | `DOMString` | Type de l'évènement |
| `bubbles` Lecture seule  | `Boolean` | Whether the event normally bubbles or not. |
| `cancelable` Lecture seule  | `Boolean` | Whether the event is cancellable or not. |
| `oldURL` Lecture seule  | `String` | The previous URL from which the window was navigated. |
| newURL Lecture seule  | `String` |  |

Il existe plusieurs scripts de secours listés sur cette page. Fondamentalement, ces scripts vérifient le `location.hash` à intervalles réguliers. Voici une version qui n'autorise qu'un seul gestionnaire à être lié à la propriété `window.onhashchange`:


```js
(function (window) {
  // Sortir si le navigateur implémente cet événement
  if ("onhashchange" in window) {
    return;
  }

  var location = window.location,
    oldURL = location.href,
    oldHash = location.hash;

  // Vérifie la hash de la barre d'adresse toutes les 100ms
  setInterval(function () {
    var newURL = location.href,
      newHash = location.hash;

    // Si le hash a été changé et qu'un gestionnaire a été lié...
    if (newHash != oldHash && typeof window.onhashchange === "function") {
      // exécute le gestionnaire
      window.onhashchange({
        type: "hashchange",
        oldURL: oldURL,
        newURL: newURL,
      });

      oldURL = newURL;
      oldHash = newHash;
    }
  }, 100);
})(window);
```

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

| Specification |
| --- |
| HTML Standard # event-hashchange |
| HTML Standard # handler-window-onhashchange |

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

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

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

* `popstate` (en-US)
* WindowEventHandlers.onhashchange
Window.top
==========

Renvoie une référence à la fenêtre la plus haute dans la hiérarchie des fenêtres

Syntaxe
-------


```js
var topWindow = window.top;
```

Notes
-----

Là où la propriété `window.parent` renvoie le parent immédiat de la fenêtre courante, `window.top` renvoie la fenêtre la plus haute dans la hiérarchie des objets de fenêtre.

Cette propriété est particulièrement utile lorsque vous avez affaire à une fenêtre qui se trouve dans une subframe d'un ou de plusieurs parents, et que vous souhaitez accéder au jeu de frameset de niveau supérieur.

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

| Specification |
| --- |
| HTML Standard # dom-top-dev |

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

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

**`window.stop()`** arrête le chargment des ressources supplémentaires dans le contexte de navigation actuel, ce qui équivaut au bouton d'arrêt dans le navigateur.

En raison de la manière dont les scripts sont exécutés, cette méthode ne peut pas interrompre le chargement de son document parent, mais elle arrêtera ses images, nouvelles fenêtres et autres objets en cours de chargement.

Syntaxe
-------


```js
window.stop();
```

Exemple
-------


```js
window.stop();
```

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

| Specification |
| --- |
| HTML Standard # dom-window-stop-dev |

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

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

Récupère la hauteur (en pixels) de la partie visible de la fenêtre de navigation en incluant, si elle est affichée, la barre de défilement horizontale.

**Note :** La valeur retournée par cette propriété correspond le cas échéant à la hauteur de la fenêtre définie par `nsIDOMWindowUtils.setCSSViewport()`, dans le cas où vous utilisez cette méthode pour définir les dimensions de la fenêtre virtuelle dans le but d'agencer la page.

Syntaxe
-------


```js
var hauteur = window.innerHeight;
```

### Valeur

Renvoie la hauteur de la partie visible de la fenêtre de navigation. La propriété `window.innerHeight` est accessible en lecture seulement ; elle n'a pas de valeur par défaut.

Notes
-----

* La propriété `window.innerHeight` est supportée par tout objet assimilé à une fenêtre *`window`*, un cadre *frame* , un ensemble de cadres *frameset*, ou une fenêtre secondaire.
* Il existe un algorithme pour calculer la hauteur de la partie visible de la fenêtre en excluant la barre de défilement horizontale si est elle affichée.
Exemples
--------

### Sur un *frameset*


```js
var intFrameHeight = window.innerHeight; // ou

var intFrameHeight = self.innerHeight;
// retournera la hauteur de la partie visible du cadre dans frameset

var intFramesetHeight = parent.innerHeight;
// retournera la hauteur de la partie visible du frameset le plus proche

var intOuterFramesetHeight = top.innerHeight;
// retournera la hauteur de la partie visible du frameset le plus éloigné
```

{{todo("ajouter ici un lien vers une démo interactive")}}
* Pour modifier les dimensions d'une fenêtre, voir `window.resizeBy()` et `window.resizeTo()` (en-US).
* Pour récupérer la hauteur extérieure d'une fenêtre, c'est-à-dire la hauteur de la fenêtre du navigateur dans sa totalité, voir `window.outerHeight`.
### Exemple graphique

L'illustration suivante montre la différence entre `outerHeight` et `innerHeight`.

![Illustration de la différence entre innerHeight et outerHeight](/fr/docs/Web/API/Window/innerHeight/firefoxinnervsouterheight2.png)

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

| Specification |
| --- |
| CSSOM View Module # dom-window-innerheight |

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

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

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

* `window.innerWidth`
* `window.outerHeight`
* `window.outerWidth`
Window : évènement rejectionhandled
===================================

L'évènement **`rejectionhandled`** est envoyé à la portée globale du script (il s'agit généralement de `window`, mais ça peut aussi être `Worker`) lorsqu'une promesse rompue est gérée tardivement, c'est-à-dire lorsqu'un gestionnaire est attaché à la promesse après que celle-ci a échoué en entraînant un évènement `unhandledrejection` (en-US).

Cet évènement peut être utilisé pour le débogage et pour la résilience des applications en général. On pourra l'utiliser avec l'évènement `unhandledrejection` qui est émis lorsqu'une promesse est rompue et qu'elle n'a pas de gestionnaire d'échec à ce moment.

Syntaxe
-------

On pourra utiliser le nom de l'évènement dans des méthodes comme `addEventListener()`, ou utiliser une propriété qui est un gestionnaire d'évènement.


```js
addEventListener("rejectionhandled", (event) => {});
onrejectionhandled = (event) => {};
```

Type d'évènement
----------------

Un objet de type `PromiseRejectionEvent` (en-US) qui hérite de `Event`.

Event

PromiseRejectionEvent

(en-US)Propriétés de l'évènement
-------------------------

`PromiseRejectionEvent.promise` (en-US) Lecture seule 

La promesse JavaScript qui a été rompue.

`PromiseRejectionEvent.reason` (en-US) Lecture seule 

Une valeur ou un objet qui indique la raison de l'échec de la promesse, comme celui qui serait passé à `Promise.reject()`.

Alias pour les gestionnaires d'évènement
----------------------------------------

En plus de l'interface `Window`, la propriété `onrejectionhandled` pour gérer l'évènement est disponible sur les cibles suivantes :

* `HTMLBodyElement`
* `HTMLFrameSetElement`
* `SVGSVGElement` (en-US)
Exemple
-------

L'évènement `rejectionhandled` peut être utilisé afin de journaliser les promesses rompues dans la console, ainsi que les raisons de leur échec :


```js
window.addEventListener(
  "rejectionhandled",
  (event) => {
    console.log(`Promesse rompue - raison : ${event.reason}`);
  },
  false,
);
```

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

| Specification |
| --- |
| HTML Standard # unhandled-promise-rejections |
| HTML Standard # handler-window-onrejectionhandled |

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

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

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

* Les évènements relatifs aux échecs des promesses
* `PromiseRejectionEvent` (en-US)
* Les promesses (`Promise`)
* `unhandledrejection` (en-US)
Window.localStorage
===================

La propriété `localStorage` vous permet d'accéder à un objet local `Storage`. Le `localStorage` est similaire au `sessionStorage` (en-US). La seule différence : les données stockées dans le `localStorage` n'ont pas de délai d'expiration, alors que les données stockées dans le `sessionStorage` sont nettoyées quand la session navigateur prend fin — donc quand on ferme le navigateur.

Il convient de noter que les données stockées dans `localStorage` ou `sessionStorage` **sont spécifiques au protocole de la page.**

Les clés et les valeurs **sont toujours** des chaînes de caractères (à noter que, comme pour les objets, les clés entières seront automatiquement converties en chaînes de caractères).

Syntaxe
-------


```js
monStockage = localStorage;
```

### Valeur

Un objet `Storage` qui peut être utilisé pour accéder à l'espace de stockage local de l'origine actuelle.

### Exceptions

`SecurityError`

La demande viole une décision politique, ou l'origine n'est pas un schéma/hôte/port valide (cela peut se produire si l'origine utilise le shéma `file:` ou `data:`, par exemple). Par exemple, l'utilisateur peut configurer son navigateur de manière à refuser la permission de conserver des données pour l'origine spécifiée.

Exemple
-------

L'extrait de code suivant accède à l'objet local `Storage` du domaine courant et lui ajoute une entrée en utilisant `Storage.setItem()`.


```js
localStorage.setItem("monChat", "Tom");
```


La syntaxe pour la lecture de l'article `localStorage` est la suivante :


```js
var cat = localStorage.getItem("monChat");
```


La syntaxe pour la suppression de l'élément `localStorage` est la suivante :


```js
localStorage.removeItem("monChat");
```


La syntaxe pour supprimer tous les éléments de `localStorage` est la suivante :


```js
// Effacer tous les éléments
localStorage.clear();
```


**Note :** Se référer à l'article Using the Web Storage API pour voir un exemple complet.

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

| Specification |
| --- |
| HTML Standard # dom-localstorage-dev |

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

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

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

* Using the Web Storage API
* `Storage/LocalStorage`
* `Window/SessionStorage`
* `Window.sessionStorage`
Window.frames
=============

Renvoie la fenêtre elle-même, qui est semblable à un objet de type Array, listant les frames présentes dans la fenêtre courante.

Syntaxe
-------


```js
frameList = window.frames;
```


* `frameList` est une liste d'objets frame, semblable à un tableau grâce à la propriété `length` . Ses éléments sont accessibles en utilisant la notation `[i]`.
* `frameList === window` est évalué à `true`.
* Chaque élément de `window.frames` est un pseudo tableau représentant l'objet window correspondant au contenu de la <frame> (en-US) ou <iframe> , et non au DOM element (i)frame (ex., `window.frames[ 0 ]` équivaut à `document.getElementsByTagName( "iframe" )[ 0 ].contentWindow`).
* pour plus de détails sur la valeur retournée, se référer au fil de discussion sur mozilla.dev.platform.
Exemple
-------


```js
var frames = window.frames; // ou // var frames = window.parent.frames;
for (var i = 0; i < frames.length; i++) {
  // faire quelque chose avec chaque subframe en tant que frames[i]
  frames[i].document.body.style.background = "red";
}
```

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

| Specification |
| --- |
| HTML Standard # dom-frames-dev |
Window: messageerror event
==========================

L'événement `messageerror` est déclenché sur un objet `Window` lorsqu'il reçoit un message qui ne peut pas être désérialisé.

|  |  |
| --- | --- |
| Bulles | Non |
| Annulable | Non |
| Interface | `MessageEvent` |
| Propriété de gestionnaire d'événements | `onmessageerror` (en-US) |

Exemples
--------

Écoutez `messageerror` en utilisant `addEventListener()` :


```js
window.addEventListener("messageerror", (event) => {
  console.error(event);
});
```


Idem, mais en utilisant la propriété de gestionnaire d'événements `onmessageerror` (en-US) :


```js
window.onmessageerror = (event) => {
  console.error(event);
};
```

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

| Specification |
| --- |
| HTML Standard # event-messageerror |
| HTML Standard # handler-window-onmessageerror |

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

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

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

* `Window.postMessage()`
* Événements liés: `message`.
Window.locationbar
==================

Renvoie l'objet `locationbar`, dont la visibilité peut être vérifiée.

Syntaxe
-------


```js
objRef = window.locationbar;
```

Exemple
-------

L'exemple HTML complet suivant montre comment la propriété `visible` de l'objet `locationbar` est utilisée.


```html
<!doctype html>
<html lang="fr">
  <head>
    <meta charset="UTF-8" />
    <title>Divers tests DOM</title>

    <script>
 var visible = window.locationbar.visible;
 </script>
  </head>
  <body>
    <p>Divers tests DOM</p>
  </body>
</html>
```

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

| Specification |
| --- |
| HTML Standard # dom-window-locationbar-dev |

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

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

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

* `window.locationbar`, `window.menubar`, `window.personalbar` (en-US), `window.scrollbars`, `window.statusbar` (en-US), `window.toolbar` (en-US)
Window.mozInnerScreenY
======================

Résumé
------

Obtient la coordonnée Y du coin supérieur gauche de la fenêtre de la fenêtre, en coordonnées d'écran.

**Note :** Cette coordonnée est indiquée en pixels CSS et non en pixels matériels. Cela signifie qu'il peut être affecté par le niveau de zoom ; pour calculer le nombre réel de pixels d'écran physiques, vous devez utiliser la propriété `nsIDOMWindowUtils.screenPixelsPerCSSPixel`.

Syntaxe
-------


```js
screenY = window.mozInnerScreenY;
```

### Valeur

* *screenY* stocke la valeur de la propriété `window.mozInnerScreenY`.
* La propriété `window.mozInnerScreenY` est une valeur en lecture seule à virgule flottante; il n'a pas de valeur par défaut.
Spécification
-------------

Ne fait partie d'aucune spécification ou recommandation technique du W3C.

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

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

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

* `window.mozInnerScreenX`
* `nsIDOMWindowUtils.screenPixelsPerCSSPixel`
window.cancelAnimationFrame()
=============================

La méthode **`window.cancelAnimationFrame()`** met fin à une animation précédement configurée par un appel à `window.requestAnimationFrame()`.Syntaxe
-------


```js
window.cancelAnimationFrame(requestID);
```

### Paramètres

`requestID`

L'identifiant retourné par l'appel à `window.requestAnimationFrame()` qui a généré la fonction de rappel (callback)

Exemples
--------


```js
var requestAnimationFrame =
  window.requestAnimationFrame ||
  window.mozRequestAnimationFrame ||
  window.webkitRequestAnimationFrame ||
  window.msRequestAnimationFrame;

var cancelAnimationFrame =
  window.cancelAnimationFrame || window.mozCancelAnimationFrame;

var start = window.mozAnimationStartTime; // Seulement supporté par Firefox. Les autre navigateurs peuvent utiliser quelque chose comme Date.now()..

var myReq; // Déclarer la variable globalement avant de lancer l'animation

function step(timestamp) {
  var progress = timestamp - start;
  d.style.left = Math.min(progress / 10, 200) + "px";
  if (progress < 2000) {
    // Ne pas oublier de récupérer l'identifiant à chaque appel de la fonction
    myReq = requestAnimationFrame(step);
  }
}
myReq = requestAnimationFrame(step);
// L'annulation utilise le dernier identifiant
cancelAnimationFrame(myReq);
```

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

| Specification |
| --- |
| HTML Standard # animationframeprovider-cancelanimationframe |

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

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

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

* `window.mozAnimationStartTime`
* `window.requestAnimationFrame()`
Window: vrdisplaypresentchange event
====================================

L'événement **`vrdisplaypresentchange`** de l'API WebVR est déclenché lorsque l'état de présentation d'un affichage VR change — c'est à dire passe de la présentation à la non présentation, ou vice versa.

|  |  |
| --- | --- |
| Bulles | Non |
| Annulable | Non |
| Interface | `VRDisplayEvent` (en-US) |
| Propriété de gestionnaire d'événements | `onvrdisplaypresentchange (en-US)` |

Exemples
--------

Vous pouvez utiliser l'événement `vrdisplaypresentchange` dans une méthode `addEventListener` :


```js
window.addEventListener("vrdisplaypresentchange", function () {
  if (vrDisplay.isPresenting) {
    info.textContent = "L'affichage a commencé à présenter.";
  } else {
    info.textContent = "L'affichage a cessé de se présenter.";
  }
  reportDisplays();
});
```


Ou utilisez la propriété de gestionnaire d'événements `onvrdisplaypresentchange` (en-US) :


```js
window.onvrdisplaypresentchange = function () {
  if (vrDisplay.isPresenting) {
    info.textContent = "L'affichage a commencé à présenter.";
  } else {
    info.textContent = "L'affichage a cessé de se présenter.";
  }
  reportDisplays();
};
```

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

#### No specification found

No specification data found for `api.Window.vrdisplaypresentchange_event`.  
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
----------

* WebVR API
unload
======

L'événement `unload` est appelé lorsque le document ou une ressource enfant est en train d'être déchargé.

Il est lancé après :

1. beforeunload (en-US) (événement annulable)
2. pagehide (en-US)

Le document se trouve alors dans un état particulier :

* Toutes les ressources existent encore (img, iframe etc.)
* Plus rien n'est encore visible par l'utilisateur final
* Les intéractions avec l'interface sont désactivées (`window.open`, `alert`, `confirm`, etc.)
* Aucune erreur ne viendra interrompre le flux de déchargement.

Veuiller noter que l'événement `unload` suit l'ordre du document : le cadre parent est déchargé *avant* le `unload` d'un cadre enfant (voir l'exemple ci-dessous).

|  |  |
| --- | --- |
| Événement propageable | Non |
| Annulable | Non |
| Objets cibles | defaultView, Document, Element |
| Interface | `UIEvent` si généré depuis un élément de l'interface
 utilisateur, `Event` |
| Action par défaut | Aucune |

Propriétés
----------

| Propriété | Type | Description |
| --- | --- | --- |
| `target` Lecture seule  | `EventTarget` | La cible de l'événement (la cible de plus haut niveau dans le DOM). |
| `type` Lecture seule  | `DOMString` | Le type d'événement. |
| `bubbles` Lecture seule  | `Boolean` (en-US) | Si l'événement remonte ou non. |
| `cancelable` Lecture seule  | `Boolean` (en-US) | Si l'événement est annulable ou non. |
| `view` Lecture seule  | `WindowProxy` | `document.defaultView` (`fenêtre` du document) |
| `detail` Lecture seule  | `long` (`float`) | 0. |

Exemple
-------


```html
<!doctype html>
<html>
  <head>
    <title>Cadre parent</title>
    <script>
 window.addEventListener("beforeunload", function (event) {
 console.log("Je suis le 1er.");
 });
 window.addEventListener("unload", function (event) {
 console.log("Je suis le 3ème.");
 });
 </script>
  </head>
  <body>
    <iframe src="child-frame.html"></iframe>
  </body>
</html>
```


Ci-dessous, le contenu de `child-frame.html`:


```html
<!doctype html>
<html>
  <head>
    <title>Cadre enfant</title>
    <script>
 window.addEventListener("beforeunload", function (event) {
 console.log("Je suis le 2nd.");
 });
 window.addEventListener("unload", function (event) {
 console.log("Je suis le 4ème et dernier…");
 });
 </script>
  </head>
  <body>
    ☻
  </body>
</html>
```


Quand le cadre parent est déchargé, les événements sont lancés dans l'ordre décrit par les messages `console.log`.

Événements liés
---------------

* `DOMContentLoaded`
* `readystatechange`
* `load`
* `beforeunload`
* `unload`
Spécifications
--------------

* Unloading Documents — unload a document
* Event Module Definition — unload
Window.alert()
==============

`window.alert()` indique au navigateur d'afficher une boîte de dialogue avec un message optionnel, et d'attendre que la personne ferme cette boîte de dialogue.

Sous certaines conditions, par exemple au changement d'onglet, le navigateur pourra ne pas afficher la boîte de dialogue ou ne pas attendre que la personne la ferme.

Syntaxe
-------


```js
alert();
alert(message);
```

### Paramètres

`message` Facultatif

Une chaîne de caractères qu'on souhaite afficher dans la boîte de dialogue. Si la valeur fournie est un objet, elle sera convertie en chaîne de caractères puis affichée.

### Valeur de retour

Aucune (`undefined`).

Exemples
--------


```js
window.alert("Hello world!");
alert("Hello world!");
```


produiront tous les deux ce qui suit :

![](/fr/docs/Web/API/Window/alert/alerthelloworld.png)

Notes
-----

Les boîtes de dialogue créées avec `alert()` ne doivent pas nécessiter de réponse de la part de l'utilisatrice ou de l'utilisateur, en dehors de l'acquittement du message.

Ces boîtes de dialogue sont des fenêtres modales qui empêchent d'accéder au reste de l'interface utilisateur du programme, à moins que la boîte de dialogue soit fermée. Aussi, il ne faut pas abuser de cette fonction.

Une autre méthode consiste à utiliser l'élément `<dialog>` afin d'afficher des alertes.

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

| Specification |
| --- |
| HTML Standard # dom-alert-dev |

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

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

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

* L'élément `<dialog>`
* `confirm`
* `prompt`
window.close
============

### Résumé

Ferme la fenêtre référencée.

### Syntaxe


```js
window.close();
```

### Description

Lorsque cette méthode est appelée, la fenêtre référencée est fermée.

Cette méthode est uniquement autorisée à être appelée pour des fenêtres qui ont été ouvertes par un script à l'aide de la méthode window.open. Si la fenêtre n'a pas été ouverte par un script, l'erreur suivante apparaît dans la console JavaScript : `Scripts may not close windows that were not opened by script.`

#### Exemples

##### Fermeture d'une fenêtre ouverte avec `window.open()`


```html
<script type="text/javascript">
 // Variable globale pour stocker une référence vers la fenêtre ouverte
 var fenetreOuverte;

 function ouvrirFenetre() {
 fenetreOuverte = window.open("details.html");
 }
 function fermerFenetreOuverte() {
 fenetreOuverte.close();
 }
</script>
```


##### Fermeture de la fenêtre courante


```html
<script type="text/javascript">
 function fermerFenetreCourante() {
 window.close();
 }
</script>
```

### Spécification

DOM Level 0. `window.close()` ne fait partie d'aucune spécification ni recommandation technique du W3C.

### Référence additionnelle

* window.close() sur MSDN