diff --git a/files/fr/web/api/element/scrollleft/index.md b/files/fr/web/api/element/scrollleft/index.md
index 3fafc4443a3979..0e7acba5b4f43a 100644
--- a/files/fr/web/api/element/scrollleft/index.md
+++ b/files/fr/web/api/element/scrollleft/index.md
@@ -1,64 +1,78 @@
 ---
-title: element.scrollLeft
+title: Element.scrollLeft
 slug: Web/API/Element/scrollLeft
-tags:
-  - DOM
-  - DOM_0
 translation_of: Web/API/Element/scrollLeft
+browser-compat: api.Element.scrollLeft
 ---
-{{ ApiRef() }}
+{{APIRef("DOM")}}
 
-### Résumé
+La propriété **`Element.scrollLeft`** permet de lire ou de modifier le nombre de pixels le long desquels le contenu d'un élément a défilé depuis son bord gauche.
 
-Définit ou obtient le nombre de pixels dont le contenu est défilé vers la gauche.
+Si la propriété [`direction`](/fr/docs/Web/CSS/direction) de l'élément vaut `rtl` (pour une écriture de droite à gauche), `scrollLeft` est à `0` lorsque la barre de défilement est à la position la plus à droite possible (ce qui correspond au début du contenu à faire défiler) et elle devient de plus en plus négative lors du défilement vers la fin du contenu.
 
-### Syntaxe
+Cette propriété peut être définie avec n'importe quelle valeur entière. Toutefois :
 
-    // Obtient le nombre de pixels défilés
-    var sLeft = element.scrollLeft;
+- Si l'élément ne peut pas défiler (par exemple parce qu'il n'y a aucun défilement), `scrollLeft` sera fixée à `0`.
+- Si la valeur fournie est inférieure à `0` (ou supérieure à `0` pour les éléments écrits de droite à gauche), `scrollLeft` sera fixée à `0`.
+- Si la valeur fournie est supérieure au défilement maximal possible pour le contenu, `scrollLeft` sera fixée à la valeur maximale possible.
 
-_sLeft_ est un entier représentant le nombre de pixels dont _element_ a été défilé vers la gauche.
+> **Attention :** Pour les systèmes qui utilisent une mise à l'échelle pour l'affichage (<i lang="en">display scaling</i>), `scrollLeft` pourra fournir une valeur décimale.
 
-    // Définit le nombre de pixels défilés
-    element.scrollLeft = 10;
+## Valeur
 
-**scrollLeft** peut être n'importe quelle valeur entière, cependant&nbsp;:
+Un nombre
 
-- Si l'élément ne peut pas défiler (par exemple parce qu'il ne déborde pas), `scrollLeft` est mis à 0.
-- S'il reçoit une valeur inférieure à 0, `scrollLeft` est mis à 0.
-- S'il reçoit une valeur plus grande que le maximum dont le contenu peut défiler, `scrollLeft` est mis au maximum.
+## Exemples
 
-### Exemple
+### HTML
 
 ```html
-<script type="text/javascript">
+<div id="container">
+  <div id="content">Cliquez sur le bouton pour glisser à droite !</div>
+</div>
 
-function doScrollLeft(el, p)
-{
-  el.scrollLeft = p;
-}
+<button id="slide" type="button">Glisser à droite</button>
+```
 
-</script>
+### CSS
 
-<div id="aDiv"
-     style="width: 100px; height: 200px; overflow: auto;"
->
-<script type="text/javascript">
-for (var i=0; i<100; ++i){
-  document.write(i + '-FooBar-FooBar-FooBar<br>');
+```css
+#container {
+  width: 100px;
+  height: 100px;
+  border: 1px solid #ccc;
+  overflow-x: scroll;
 }
-</script>
-</div>
-<br>
-<input type="button" value="Défile de 50 pixels"
-       onclick="doScrollLeft(document.getElementById('aDiv'), 50);"
->
+
+#content {
+  width: 250px;
+  background-color: #ccc;
+}
+```
+
+### JavaScript
+
+```js
+const button = document.getElementById('slide');
+
+button.onclick = function () {
+  document.getElementById('container').scrollLeft += 20;
+};
 ```
 
-### Spécification
+### Résultat
+
+{{EmbedLiveSample("")}}
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
 
-{{ DOM0() }}
+{{Compat}}
 
-### Références
+## Voir aussi
 
-- [_scrollLeft_ sur MSDN](http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/scrollleft.asp)
+- [`Element.scrollTop`](/fr/docs/Web/API/Element/scrollTop)
+- [`Element.scrollTo()`](/fr/docs/Web/API/Element/scrollTo)
diff --git a/files/fr/web/api/globaleventhandlers/onblur/index.md b/files/fr/web/api/globaleventhandlers/onblur/index.md
index 286ccc3d95d0eb..15f6dfab96f185 100644
--- a/files/fr/web/api/globaleventhandlers/onblur/index.md
+++ b/files/fr/web/api/globaleventhandlers/onblur/index.md
@@ -1,59 +1,69 @@
 ---
-title: element.onblur
+title: GlobalEventHandlers.onblur
 slug: Web/API/GlobalEventHandlers/onblur
-tags:
-  - DOM
-  - DOM_0
 translation_of: Web/API/GlobalEventHandlers/onblur
+browser-compat: api.GlobalEventHandlers.onblur
 ---
-{{ ApiRef() }}
+{{ApiRef("HTML DOM")}}
 
-### Résumé
+La propriété **`onblur`**, rattachée au mixin [`GlobalEventHandlers`](/fr/docs/Web/API/GlobalEventHandlers), est [le gestionnaire d'évènements](/fr/docs/Web/Events/Event_handlers) qui permet de traiter les évènements [`blur`](/fr/docs/Web/API/Element/blur_event). Elle est disponible sur les interfaces [`Element`](/fr/docs/Web/API/Element), [`Document`](/fr/docs/Web/API/Document), et [`Window`](/fr/docs/Web/API/Window).
 
-La propriété **onblur** renvoie le gestionnaire de l'évènement `blur` (perte de focus) pour l'élément courant.
+L'évènement `blur` est déclenché lorsqu'un élément perd le focus.
 
-### Syntaxe
+> **Note :** Le gestionnaire d'évènement opposé à `onblur` est [`onfocus`](/fr/docs/Web/API/GlobalEventHandlers/onfocus).
 
-    element.onblur = nomFonctionUtilisateur;
+## Syntaxe
 
-- `nomFonctionUtilisateur` est le nom de la fonction utilisateur préalablement définie, sans les parenthèses ni aucun argument. Il est également possible de déclarer une «&nbsp;fonction anonyme&nbsp;», comme&nbsp;:
+```js
+cible.onblur = refFonction;
+```
+
+### Valeur
 
-<!---->
+`refFonction` est un nom de fonction ou une [expression de fonction](/fr/docs/Web/JavaScript/Reference/Operators/function). La fonction reçoit un objet [`FocusEvent`](/fr/docs/Web/API/FocusEvent) comme unique argument.
 
-    element.onblur = function() {
-        alert("Évènement onblur détecté");
-    };
+## Exemple
 
-### Exemple
+Cet exemple utilise `onblur` et [`onfocus`](/fr/docs/Web/API/GlobalEventHandlers/onfocus) pour changer le texte au sein d'un élément [`<input>`](/fr/docs/Web/HTML/Element/Input).
 
-Lorsqu'une zone de saisie n'est plus active suite à une perte du «&nbsp;focus&nbsp;», une boîte de message (alert) est affichée.
+### HTML
 
 ```html
-<form>
-	<input type="text" id="foo" value="Allo!" />
-</form>
+<input type="text" value="Cliquez ici">
+```
 
-<script type="text/javascript">
+### JavaScript
 
-var elem = document.getElementById("foo");
+```js
+let input = document.querySelector('input');
 
-// Attention&nbsp;: afficherMessage(); ou afficherMessage(param); ne fonctionneront pas ici,
-// il doit s'agir d'une référence au nom d'une fonction et non d'un appel de cette fonction
+input.onblur = inputBlur;
+input.onfocus = inputFocus;
 
-elem.onblur = afficherMessage;
+function inputBlur() {
+  input.value = 'Le focus a été perdu';
+}
 
-function afficherMessage() {
-	alert("Évènement onblur detecté!");
+function inputFocus() {
+  input.value = 'Le focus est là';
 }
-</script>
 ```
 
-### Notes
+### Résultat
+
+Essayez de cliquer à l'intérieur et en dehors du champ pour voir son contenu être modifié.
+
+{{EmbedLiveSample('')}}
+
+## Spécifications
+
+{{Specifications}}
 
-L'évènement `blur` se déclenche lors de la perte de focus d'un élément.
+## Compatibilité des navigateurs
 
-Microsoft Internet Explorer déclenche l'évènement `blur` sur presque tous les éléments, contrairement aux navigateurs Gecko (dont Firefox) qui ne le déclencheront que sur un nombre limité d'éléments.
+{{Compat}}
 
-### Spécification
+## Voir aussi
 
-{{ DOM0() }}
+- L'évènement [`blur`](/fr/docs/Web/API/Element/blur_event)
+- Le gestionnaire d'évènement dual&nbsp;: [`GlobalEventHandlers.onfocus`](/fr/docs/Web/API/GlobalEventHandlers/onfocus)
diff --git a/files/fr/web/api/globaleventhandlers/onchange/index.md b/files/fr/web/api/globaleventhandlers/onchange/index.md
index 669a38b5d66326..33b104964a1d9d 100644
--- a/files/fr/web/api/globaleventhandlers/onchange/index.md
+++ b/files/fr/web/api/globaleventhandlers/onchange/index.md
@@ -1,43 +1,62 @@
 ---
-title: element.onchange
+title: GlobalEventHandlers.onchange
 slug: Web/API/GlobalEventHandlers/onchange
-tags:
-  - DOM
-  - DOM_0
-  - Référence_du_DOM_Gecko
 translation_of: Web/API/GlobalEventHandlers/onchange
+browser-compat: api.GlobalEventHandlers.onchange
 ---
-{{ ApiRef() }}
+{{ApiRef("HTML DOM")}}
 
-### Résumé
+La propriété **`onchange`**, rattachée au mixin [`GlobalEventHandlers`](/fr/docs/Web/API/GlobalEventHandlers), est [un gestionnaire d'évènements](/fr/docs/Web/Events/Event_handlers) qui permet de traiter les évènements [`change`](/fr/docs/Web/API/HTMLElement/change_event).
 
-La propriété `onchange` définit et renvoie le gestionnaire d'évènement `onChange` (modification) pour l'élément courant.
+Les évènements `change` sont déclenchés lorsque la personne valide un changement de valeur dans un contrôle d'un formulaire. Cela peut se produire, par exemple, lors d'un clic à l'extérieur du contrôle ou en utilisant la touche <kbd>Tab</kbd> pour passer à un contrôle différent.
 
-### Syntaxe
+> **Note :** À la différence de [`oninput`](/fr/docs/Web/API/GlobalEventHandlers/oninput), le gestionnaire d'évènements `onchange` n'est pas nécessairement appelé pour chaque modification de la valeur (`value`) d'un élément.
 
-    element.onchange = code de gestion de l'évènement
+## Syntaxe
 
-### Notes
+```js
+cible.onchange = refFonction;
+```
 
-Le pseudo code suivant illustre la manière dont le gestionnaire d'évènement `change` est implémenté dans Mozilla&nbsp;:
+`refFonction` est un nom de fonction ou une [expression de fonction](/fr/docs/Web/JavaScript/Reference/Operators/function). La fonction reçoit un objet [`Event`](/fr/docs/Web/API/Event) comme unique argument.
 
-      control.onfocus = focus;
-      control.onblur = blur;
-      function focus () {
-          original_value = control.value;
-      }
+## Exemple
 
-      function blur () {
-          if (control.value&nbsp;!= original_value)
-            control.onchange();
-      }
+Dans cet exemple, on affiche dans un journal le nombre de caractères d'un élément [`<input>`](/fr/docs/Web/HTML/Element/Input) après chaque modification, une fois que le focus a été retiré du contrôle.
 
-Par conséquent, vous pouvez rencontrer des comportements inattendus dans l'évènement `change` si vous modifiez la valeur du contrôle dans vos propres gestionnaires d'évènements `focus` ou `blur`. De plus, l'évènement `change` se déclenche avant l'évènement `blur`. Ce comportement n'est pas le même que celui d'Internet Explorer.
+### HTML
 
-### Specification
+```html
+<input type="text" placeholder="Saisissez quelque chose ici, puis cliquez en dehors du champ." size="50">
+<p id="log"></p>
+```
 
-{{ DOM0() }}
+### JavaScript
 
-### Voir aussi
+```js
+let input = document.querySelector('input');
+let log = document.getElementById('log');
 
-- [DOM Level 2: HTML event types](http://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-eventgroupings-htmlevents) — traduction en français (non normative)&nbsp;: [DOM Niveau 2 Events&nbsp;: Les types d'événements HTML](http://www.yoyodesign.org/doc/w3c/dom2-events/events.html#Events-eventgroupings-htmlevents)
+input.onchange = handleChange;
+
+function handleChange(e) {
+  log.textContent = `La valeur du champ mesure 
+      ${e.target.value.length} caractère(s).`;
+}
+```
+
+### Résultat
+
+{{EmbedLiveSample("")}}
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
+
+{{Compat}}
+
+## Voir aussi
+
+- L'évènement [`change`](/fr/docs/Web/API/HTMLElement/change_event)
diff --git a/files/fr/web/api/globaleventhandlers/ondblclick/index.md b/files/fr/web/api/globaleventhandlers/ondblclick/index.md
index a4ecb0a523f6ed..7f532eb9174d13 100644
--- a/files/fr/web/api/globaleventhandlers/ondblclick/index.md
+++ b/files/fr/web/api/globaleventhandlers/ondblclick/index.md
@@ -1,70 +1,65 @@
 ---
-title: element.ondblclick
+title: GlobalEventHandlers.ondblclick
 slug: Web/API/GlobalEventHandlers/ondblclick
-tags:
-  - DOM
-  - DOM_0
-  - Référence_du_DOM_Gecko
 translation_of: Web/API/GlobalEventHandlers/ondblclick
+browser-compat: api.GlobalEventHandlers.ondblclick
 ---
-{{ ApiRef() }}
+{{ApiRef("HTML DOM")}}
 
-### Résumé
+La propriété **`ondblclick`**, rattachée au mixin [`GlobalEventHandlers`](/fr/docs/Web/API/GlobalEventHandlers), est [un gestionnaire d'évènements](/fr/docs/Web/Events/Event_handlers) qui permet de traiter les évènements [`dblclick`](/fr/docs/Web/API/Element/dblclick_event).
 
-La propriété **ondblclick** renvoie le gestionnaire d'évènement `dblclick` de l'élément courant.
+L'évènement `dblclick` est déclenché lorsque la personne double-clique sur un élément. Il est déclenché après deux évènements [`click`](/fr/docs/Web/API/Element/click_event).
 
-### Syntaxe
+## Syntaxe
 
-    element.ondblclick = nomDeFonction;
+```js
+cible.ondblclick = refFonction;
+```
 
-- `nomDeFonction` est le nom d'une fonction définie par l'utilisateur, sans les parenthèses ni aucun paramètre. Il peut également s'agir d'une déclaration de fonction anonyme, comme&nbsp;:
+### Valeur
 
-<!---->
+`refFonction` est un nom de fonction ou une [expression de fonction](/fr/docs/Web/JavaScript/Reference/Operators/function). La fonction reçoit un objet [`MouseEvent`](/fr/docs/Web/API/MouseEvent) comme unique argument. À l'intérieur de cette fonction, le mot-clé [`this`](/fr/docs/Web/JavaScript/Reference/Operators/this) correspondra à l'élément sur lequel l'évènement a été déclenché.
 
-    element.ondblclick = function() { alert("Évènement dblclick détecté"); };
+Seul un gestionnaire `ondblclick` peut être affecté par objet à un instant donné. Si besoin de plus de flexibilité, on pourra utiliser la méthode [`EventTarget.addEventListener()`](/fr/docs/Web/API/EventTarget/addEventListener).
 
-### Exemple
+## Exemple
 
-```html
-<html>
+Cet exemple affiche dans un journal la position des doubles-clics.
 
-<head>
-<title>ondblclick event example</title>
+### HTML
 
-<script type="text/javascript">
+```html
+<p>Double-cliquez n'importe où dans cet exemple.</p>
+<p id="log"></p>
+```
 
-function initElement() {
- var p = document.getElementById("foo");
- // Attention&nbsp;: showAlert(); ou showAlert(param); ne fonctionneront pas ici,
- // il doit s'agir d'une référence à un nom de fonction, pas un appel de fonction.
- p.ondblclick = showAlert;
-};
+### JavaScript
 
-function showAlert() {
- alert("Évènement dblclick détecté")
-}
-</script>
+```js
+let log = document.getElementById('log');
 
-<style type="text/css">
-<!--
-#foo {
-border: solid blue 2px;
+document.ondblclick = logDoubleClick;
+
+function logDoubleClick(e) {
+  log.textContent = `Position : (${e.clientX}, ${e.clientY})`;
 }
--->
-</style>
-</head>
-
-<body onload="initElement()";>
-<span id="foo">Mon élément</span>
-<p>Double-cliquez sur l'élément ci-dessus.</p>
-</body>
-</html>
 ```
 
-### Notes
+### Résultat
+
+{{EmbedLiveSample("")}}
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
 
-L'évènement `dblclick` est déclenché lorsque l'utilisateur double-clique sur un élément.
+{{Compat}}
 
-### Spécification
+## Voir aussi
 
-{{ DOM0() }}
+- L'évènement [`dblclick`](/fr/docs/Web/API/Element/dblclick_event)
+- Les gestionnaires d'évènements associés
+  - [`GlobalEventHandlers.onauxclick`](/fr/docs/Web/API/GlobalEventHandlers/onauxclick)
+  - [`GlobalEventHandlers.onclick`](/fr/docs/Web/API/GlobalEventHandlers/onclick)
diff --git a/files/fr/web/api/globaleventhandlers/onfocus/index.md b/files/fr/web/api/globaleventhandlers/onfocus/index.md
index f8b2de65f524ad..c2deb458600dea 100644
--- a/files/fr/web/api/globaleventhandlers/onfocus/index.md
+++ b/files/fr/web/api/globaleventhandlers/onfocus/index.md
@@ -1,28 +1,72 @@
 ---
-title: element.onfocus
+title: GlobalEventHandlers.onfocus
 slug: Web/API/GlobalEventHandlers/onfocus
-tags:
-  - DOM
-  - DOM_0
-  - Référence_du_DOM_Gecko
 translation_of: Web/API/GlobalEventHandlers/onfocus
+browser-compat: api.GlobalEventHandlers.onfocus
 ---
-{{ ApiRef() }}
+{{ApiRef("HTML DOM")}}
 
-### Résumé
+La propriété **`onfocus`**, , rattachée au mixin [`GlobalEventHandlers`](/fr/docs/Web/API/GlobalEventHandlers), est [un gestionnaire d'évènements](/fr/docs/Web/Events/Event_handlers) qui permet de traiter les évènements [`focus`](/fr/docs/Web/API/Element/focus_event).
 
-La propriété **onfocus** renvoie le gestionnaire de l'évènement `focus` pour l'élément courant.
+L'évènement `focus` est déclenché lorsque la personne active le focus sur un élément.
 
-### Syntaxe
+Afin que `onfocus` soit déclenché sur les éléments qui ne sont pas des éléments `<input>`, il faut que ces derniers aient un attribut [`tabindex`](/fr/docs/Web/HTML/Global_attributes#attr-tabindex). Voir la section [Remettre l'accessibilité au clavier](/fr/docs/Learn/Accessibility/HTML#remettre_laccessibilité_au_clavier) pour plus de détails.
 
-    code de gestion de l'évènement = element.onfocus
+> **Note :** Le gestionnaire d'évènement opposé à `onfocus` est [`onblur`](/fr/docs/Web/API/GlobalEventHandlers/onblur).
 
-### Notes
+## Syntaxe
 
-L'évènement focus se déclenche lorsque l'utilisateur donne le focus clavier à l'élément donné.
+```js
+cible.onfocus = refFonction;
+```
 
-Contrairement à Microsoft Internet Explorer, dans lequel presque toutes les sortes d'éléments peuvent recevoir l'évènement focus, presqu'aucune sorte d'élément ne reçoit cet évènement dans les navigateurs utilisant Gecko.
+### Value
 
-### Spécification
+`refFonction` est un nom de fonction ou une [expression de fonction](/fr/docs/Web/JavaScript/Reference/Operators/function). La fonction reçoit un objet [`FocusEvent`](/fr/docs/Web/API/FocusEvent) comme unique argument.
 
-{{ DOM0() }}
+## Exemple
+
+Cet exemple utilise [`onblur`](/fr/docs/Web/API/GlobalEventHandlers/onblur) et `onfocus` pour changer le texte au sein d'un élément [`<input>`](/fr/docs/Web/HTML/Element/Input).
+
+
+### HTML
+
+```html
+<input type="text" value="Cliquez ici">
+```
+
+### JavaScript
+
+```js
+let input = document.querySelector('input');
+
+input.onblur = inputBlur;
+input.onfocus = inputFocus;
+
+function inputBlur() {
+  input.value = 'Le focus a été perdu';
+}
+
+function inputFocus() {
+  input.value = 'Le focus est là';
+}
+```
+
+### Résultat
+
+Essayez de cliquer à l'intérieur et en dehors du champ pour voir son contenu être modifié.
+
+{{EmbedLiveSample('')}}
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
+
+{{Compat}}
+
+## Voir aussi
+
+- L'évènement [`focus`](/fr/docs/Web/API/Element/focus_event)
+- Le gestionnaire d'évènement dual&nbsp;: [`GlobalEventHandlers.onblur`](/fr/docs/Web/API/GlobalEventHandlers/onblur)
diff --git a/files/fr/web/api/globaleventhandlers/onkeydown/index.md b/files/fr/web/api/globaleventhandlers/onkeydown/index.md
index b280fea9ad9280..549accfdf68363 100644
--- a/files/fr/web/api/globaleventhandlers/onkeydown/index.md
+++ b/files/fr/web/api/globaleventhandlers/onkeydown/index.md
@@ -1,32 +1,77 @@
 ---
-title: element.onkeydown
+title: GlobalEventHandlers.onkeydown
 slug: Web/API/GlobalEventHandlers/onkeydown
-tags:
-  - DOM
-  - DOM_0
-  - Référence_du_DOM_Gecko
 translation_of: Web/API/GlobalEventHandlers/onkeydown
+browser-compat: api.GlobalEventHandlers.onkeydown
 ---
-{{ ApiRef() }}
+{{ApiRef("HTML DOM")}}
 
-### Résumé
+La propriété **`onkeydown`**, rattachée au mixin [`GlobalEventHandlers`](/fr/docs/Web/API/GlobalEventHandlers), est [un gestionnaire d'évènements](/fr/docs/Web/Events/Event_handlers) qui permet de traiter les évènements [`keydown`](/fr/docs/Web/API/Document/keydown_event).
 
-La propriété **onkeydown** définit et renvoie le gestionnaire d'évènement `keydown` de l'élément courant.
+L'évènement `keydown` est déclenché lorsque l'utilisatrice ou l'utilisateur appuie sur une touche du clavier.
 
-### Syntaxe
+## Syntaxe
 
-    code de gestion de l'évènement = element.onkeydown
+```js
+cible.onkeydown = refFunction;
+```
 
-### Notes
+### Value
 
-L'évènement `keydown` se déclenche lorsque qu'une touche du clavier est enfoncée.
+`refFunction` est un nom de fonction ou une [expression de fonction](/fr/docs/Web/JavaScript/Reference/Operators/function). La fonction reçoit un objet [`KeyboardEvent`](/fr/docs/Web/API/KeyboardEvent) comme unique argument.
 
-À différencier de [onkeypress](/fr/DOM/element.onkeypress) qui se déclenche lorsque qu'une touche du clavier est pressée. (La nuance se situe dans le fait que `onkeydown` se produit avant `onkeypress` même s'ils se produisent quasiment au même instant)
+## Exemple
 
-### Voir aussi
+Cet exemple affiche la valeur de [`KeyboardEvent.code`](/fr/docs/Web/API/KeyboardEvent/code) à chaque fois qu'on appuie sur une touche à l'intérieur de l'élément [`<input>`](/fr/docs/Web/HTML/Element/Input).
 
-[onkeypress](/fr/DOM/element.onkeypress) [onkeyup](/fr/DOM/element.onkeyup)
+### HTML
 
-### Spécification
+```html
+<input>
+<p id="log"></p>
+```
 
-{{ DOM0() }}
+### JavaScript
+
+```js
+const input = document.querySelector('input');
+const log = document.getElementById('log');
+
+input.onkeydown = logKey;
+
+function logKey(e) {
+  log.textContent += ` ${e.code}`;
+}
+```
+
+### Résultat
+
+{{EmbedLiveSample("")}}
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
+
+{{Compat}}
+
+### Notes de compatibilité
+
+Depuis Firefox 65, les évènements [`keyup`](/fr/docs/Web/API/Document/keyup_event) et [`keydown`](/fr/docs/Web/API/Document/keydown_event) sont désormais déclenchés pendant la composition IME afin d'améliorer la compatibilité entre les navigateurs pour les locuteurs de langues asiatiques (CJKT) (voir [le bug 354358](https://bugzilla.mozilla.org/show_bug.cgi?id=354358)). Pour ignorer les évènements `keydown` qui font partie d'une composition, on pourra écrire quelque chose d'analogue au fragment qui suit (229 est une valeur spéciale de `keyCode` relative à un évènement qui a été traité par un IME)&nbsp;:
+
+```js
+eventTarget.addEventListener("keydown", event => {
+  if (event.isComposing || event.keyCode === 229) {
+    return;
+  }
+  // faire quelque chose
+});
+```
+
+## Voir aussi
+
+- L'évènement [`keydown`](/fr/docs/Web/API/Document/keydown_event)
+- Les gestionnaires d'évènements associés
+  - [`GlobalEventHandlers.onkeypress`](/fr/docs/Web/API/GlobalEventHandlers/onkeypress)
+  - [`GlobalEventHandlers.onkeyup`](/fr/docs/Web/API/GlobalEventHandlers/onkeyup)
diff --git a/files/fr/web/api/globaleventhandlers/onkeypress/index.md b/files/fr/web/api/globaleventhandlers/onkeypress/index.md
index 42a8889bf90113..62c5772a883235 100644
--- a/files/fr/web/api/globaleventhandlers/onkeypress/index.md
+++ b/files/fr/web/api/globaleventhandlers/onkeypress/index.md
@@ -1,32 +1,143 @@
 ---
-title: element.onkeypress
+title: GlobalEventHandlers.onkeypress
 slug: Web/API/GlobalEventHandlers/onkeypress
-tags:
-  - DOM
-  - DOM_0
-  - Référence_du_DOM_Gecko
 translation_of: Web/API/GlobalEventHandlers/onkeypress
+browser-compat: api.GlobalEventHandlers.onkeypress
 ---
-{{ ApiRef() }}
+{{ApiRef("HTML DOM")}} {{deprecated_header}}
 
-### Résumé
+La propriété **`onkeypress`**, rattachée au mixin [`GlobalEventHandlers`](/fr/docs/Web/API/GlobalEventHandlers), est [un gestionnaire d'évènements](/fr/docs/Web/Events/Event_handlers) qui permet de traiter les évènements [`keypress`](/fr/docs/Web/API/Document/keypress_event).
 
-La propriété **onkeypress** définit et renvoie le gestionnaire d'évènement `keypress` de l'élément courant.
+L'évènement `keypress` _devrait_ être déclenché lorsqu'on appuie sur une touche du clavier. Toutefois, en pratique, les navigateurs ne déclenchent pas d'évènements `keypress` pour certaines touches.
 
-### Syntaxe
+> **Attention :** Le gestionnaire d'évènements `onkeypress` est déprécié, il faut utiliser [`onkeydown`](/fr/docs/Web/API/GlobalEventHandlers/onkeydown) à la place.
 
-    element.onkeypress = code de gestion de l'évènement
+## Syntaxe
 
-### Notes
+```js
+cible.onkeypress = refFonction;
+```
 
-L'évènement `keypress` se déclenche lorsque qu'une touche du clavier est pressée.
+### Valeur
 
-À différencier de [onkeydown](/fr/DOM/element.onkeydown) qui se déclenche lorsque qu'une touche du clavier est enfoncée. (La nuance se situe dans le fait que `onkeydown` se produit avant `onkeypress`, même s'il se produisent quasiment au même instant)
+`refFonction` est un nom de fonction ou une [expression de fonction](/fr/docs/Web/JavaScript/Reference/Operators/function). La fonction reçoit un objet [`KeyboardEvent`](/fr/docs/Web/API/KeyboardEvent) comme unique argument.
 
-### Voir aussi
+## Exemples
 
-[onkeydown](/fr/DOM/element.onkeydown) [onkeyup](/fr/DOM/element.onkeyup)
+### Exemple simple
 
-### Spécification
+Cet exemple affiche la valeur de [`KeyboardEvent.code`](/fr/docs/Web/API/KeyboardEvent/code) à chaque fois qu'on appuie  sur une touche à l'intérieur de l'élément [`<input>`](/fr/docs/Web/HTML/Element/Input).
 
-{{ DOM0() }}
+#### HTML
+
+```html
+<input>
+<p id="log"></p>
+```
+
+#### JavaScript
+
+```js
+const input = document.querySelector('input');
+const log = document.getElementById('log');
+
+input.onkeypress = logKey;
+
+function logKey(e) {
+  log.textContent += ` ${e.code}`;
+}
+```
+
+#### Résultat
+
+{{EmbedLiveSample("", 700, 200)}}
+
+### Filtrer des touches à l'aide d'une expression rationnelle
+
+Dans cet exemple, on filtre les caractères saisis dans le champ du formulaire à l'aide d'une [expression rationnelle](/fr/docs/Web/JavaScript/Guide/Regular_Expressions).
+
+#### HTML
+
+```html
+<label>Veuillez ne saisir que des chiffres :
+  <input>
+</label>
+```
+
+#### JavaScript
+
+```js
+function numbersOnly(event) {
+  return event.charCode === 0 || /\d/.test(String.fromCharCode(event.charCode));
+}
+
+const input = document.querySelector('input');
+input.onkeypress = numbersOnly;
+
+// On empêche de coller (le contenu collé pourrait contenir
+// des caractères qui ne sont pas des chiffres)
+input.onpaste = event => false;
+```
+
+#### Résultat
+
+{{EmbedLiveSample("")}}
+
+### Capturer la saisie d'un mot-clé secret
+
+La fonction JavaScript qui suit fera une action lorsqu'on saisira le mot "exit" à n'importe quel endroit de la page.
+
+```js
+
+(function () {
+  const sSecret = "exit";
+  let nOffset = 0;
+
+  document.onkeypress = function(oPEvt) {
+    let oEvent = oPEvt || window.event,
+        nChr = oEvent.charCode,
+        sNodeType = oEvent.target.nodeName.toUpperCase();
+
+    if (nChr === 0 ||
+        oEvent.target.contentEditable.toUpperCase() === "TRUE" ||
+        sNodeType === "TEXTAREA" ||
+        sNodeType === "INPUT" && oEvent.target.type.toUpperCase() === "TEXT") {
+      return true;
+    }
+
+    if (nChr !== sSecret.charCodeAt(nOffset)) {
+      nOffset = nChr === sSecret.charCodeAt(0) ? 1 : 0;
+    } else if (nOffset < sSecret.length - 1) {
+      nOffset++;
+    } else {
+      nOffset = 0;
+      /* Faire quelque chose ici… */
+      console.log("et voilà !");
+      location.assign("https://developer.mozilla.org/");
+    }
+
+    return true;
+  };
+})();
+```
+
+> **Note :** Un <i lang="en">framework</i> pour effectuer de telles captures, plus complet, est [disponible sur GitHub](https://github.com/madmurphy/spell.js/).
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
+
+{{Compat}}
+
+### Notes de compatibilité
+
+- L'évènement `keypress` n'est plus déclenché pour [les touches non-imprimables](/fr/docs/Web/API/KeyboardEvent/keyCode#non-printable_keys_(function_keys)) (voir [le bug 968056](https://bugzilla.mozilla.org/show_bug.cgi?id=968056) pour l'implémentation de ce comportement dans Firefox 65), à l'exception de la touche <kbd>Entrée</kbd>, et des combinaisons de touches <kbd>Shift</kbd>+<kbd>Entrée</kbd> et <kbd>Ctrl</kbd>+<kbd>Entrée</kbd> (à des fins de compatibilité entre navigateurs).
+
+## Voir aussi
+
+- L'évènement [`keypress`](/fr/docs/Web/API/Document/keypress_event)
+- Les gestionnaires d'évènements associés
+  - [`GlobalEventHandlers.onkeydown`](/fr/docs/Web/API/GlobalEventHandlers/onkeydown)
+  - [`GlobalEventHandlers.onkeyup`](/fr/docs/Web/API/GlobalEventHandlers/onkeyup)
diff --git a/files/fr/web/api/globaleventhandlers/onmousedown/index.md b/files/fr/web/api/globaleventhandlers/onmousedown/index.md
index 77e14f71e0801d..8b48e177bc1e2e 100644
--- a/files/fr/web/api/globaleventhandlers/onmousedown/index.md
+++ b/files/fr/web/api/globaleventhandlers/onmousedown/index.md
@@ -1,26 +1,101 @@
 ---
-title: element.onmousedown
+title: GlobalEventHandlers.onmousedown
 slug: Web/API/GlobalEventHandlers/onmousedown
-tags:
-  - DOM
-  - DOM_0
-  - Référence_du_DOM_Gecko
 translation_of: Web/API/GlobalEventHandlers/onmousedown
+browser-compat: api.GlobalEventHandlers.onmousedown
 ---
-{{ ApiRef() }}
+{{ApiRef("HTML DOM")}}
 
-### Résumé
+La propriété **`onmousedown`**, rattachée au mixin [`GlobalEventHandlers`](/fr/docs/Web/API/GlobalEventHandlers), est [un gestionnaire d'évènements](/fr/docs/Web/Events/Event_handlers) qui permet de traiter les évènements [`mousedown`](/fr/docs/Web/API/Element/mousedown_event).
 
-La propriété **onmousedown** renvoie le gestionnaire de l'évènement `mousedown` (bouton de la souris enfoncé) pour l'élément courant.
+L'évènement `mousedown` est déclenché lorsqu'on appuie sur le bouton de la souris.
 
-### Syntaxe
+> **Note :** Le gestionnaire d'évènements opposé à `onmousedown` est [`onmouseup`](/fr/docs/Web/API/GlobalEventHandlers/onmouseup).
 
-    code de gestion de l'évènement = element.onMouseDown
+## Syntaxe
 
-### Notes
+```js
+cible.onmousedown = refFonction;
+```
 
-L'évènement `mousedown` se déclenche lorsque l'utilisateur appuie sur le bouton gauche de la souris.
+### Valeur
 
-### Spécification
+`refFonction` est un nom de fonction ou une [expression de fonction](/fr/docs/Web/JavaScript/Reference/Operators/function). La fonction reçoit un objet [`MouseEvent`](/fr/docs/Web/API/MouseEvent) comme unique argument.
 
-{{ DOM0() }}
+## Exemple
+
+Cet exemple révèle une partie d'une image lorsqu'on appuie et maintient un bouton de souris. Il utilise les gestionnaires d'évènements `onmousedown`, [`onmouseup`](/fr/docs/Web/API/GlobalEventHandlers/onmouseup), et [`onmousemove`](/fr/docs/Web/API/GlobalEventHandlers/onmousemove).
+
+### HTML
+
+```html
+<div class="container">
+  <div class="view" hidden></div>
+  <img src="rhino.jpg">
+</div>
+```
+
+### CSS
+
+```css
+.container {
+  width: 300px;
+  height: 227px;
+  background: black;
+}
+
+.view {
+  position: absolute;
+  width: 100px;
+  height: 100px;
+  background: white;
+  border-radius: 50%;
+}
+
+img {
+  mix-blend-mode: darken;
+}
+```
+
+### JavaScript
+
+```js
+function showView(event) {
+  view.removeAttribute('hidden');
+  view.style.left = event.clientX - 50 + 'px';
+  view.style.top = event.clientY - 50 + 'px';
+  event.preventDefault();
+}
+
+function moveView(event) {
+  view.style.left = event.clientX - 50 + 'px';
+  view.style.top = event.clientY - 50 + 'px';
+}
+
+function hideView(event) {
+  view.setAttribute('hidden', '');
+}
+
+const container = document.querySelector('.container');
+const view = document.querySelector('.view');
+
+container.onmousedown = showView;
+container.onmousemove = moveView;
+document.onmouseup = hideView;
+```
+
+### Résultat
+
+{{EmbedLiveSample("", 700, 300)}}
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
+
+{{Compat}}
+
+## Voir aussi
+
+- L'évènement [`mousedown`](/fr/docs/Web/API/Element/mousedown_event)
diff --git a/files/fr/web/api/globaleventhandlers/onmousemove/index.md b/files/fr/web/api/globaleventhandlers/onmousemove/index.md
index 07ecef1a1ee8f5..640610050d5743 100644
--- a/files/fr/web/api/globaleventhandlers/onmousemove/index.md
+++ b/files/fr/web/api/globaleventhandlers/onmousemove/index.md
@@ -1,39 +1,96 @@
 ---
-title: element.onmousemove
+title: GlobalEventHandlers.onmousemove
 slug: Web/API/GlobalEventHandlers/onmousemove
-tags:
-  - DOM
-  - DOM_0
-  - Référence_du_DOM_Gecko
 translation_of: Web/API/GlobalEventHandlers/onmousemove
+browser-compat: api.GlobalEventHandlers.onmousemove
 ---
-{{ ApiRef() }}
+{{ApiRef("HTML DOM")}}
 
-### Résumé
+La propriété **`onmousemove`**, rattachée au mixin [`GlobalEventHandlers`](/fr/docs/Web/API/GlobalEventHandlers), est [un gestionnaire d'évènements](/fr/docs/Web/Events/Event_handlers) qui permet de traiter les évènements [`mousemove`](/fr/docs/Web/API/Element/mousemove_event).
 
-La propriété **onmousemove** renvoie le code de gestion de l'évènement `mousemove` pour l'élément courant.
+Un évènement `mousemove` est déclenché lorsqu'on déplace la souris.
 
-### Syntax
+## Syntaxe
 
-`element.onmousemove = functionRef`
+```js
+cible.onmousemove = refFonction;
+```
 
-où _functionRef_ est une fonction ou une expression de type _function._ Consulter la [référence des fonctions](/en-US/docs/JavaScript/Reference/Functions_and_function_scope) pour plus de détails.
+### Valeur
 
-Le paramètre fournit au gestionnaire d'évènement _functionRef_ lors du déclenchement de l'évènement est objet qui représente l'évènement de déplacment de souris, de type {{ domxref("MouseEvent") }}.
+`refFonction`est un nom de fonction ou une [expression de fonction](/fr/docs/Web/JavaScript/Reference/Operators/function). La fonction reçoit un objet [`MouseEvent`](/fr/docs/Web/API/MouseEvent) comme unique argument.
 
-### Exemple
+## Exemples
 
-```js
-document.body.onmousemove = event => {
-  // Suivi de la position de la souris dans la console
-  console.log(`Position de la souris : X = ${event.clientX} | Y = ${event.clientY}`);
+### Bulles d'information
+
+Cet exemple crée des bulles d'information qui suivent la souris. Il utilise les gestionnaires d'évènements `onmousemove`, [`onmouseover`](/fr/docs/Web/API/GlobalEventHandlers/onmouseover), et [`onmouseout`](/fr/docs/Web/API/GlobalEventHandlers/onmouseout).
+
+#### HTML
+
+```html
+<p><a href="#" data-tooltip="Premier lien">Voir une bulle d'information ici&hellip;</a></p>
+<p><a href="#" data-tooltip="Deuxième lien">&hellip; ou ici !</a></p>
+```
+
+#### CSS
+
+```css
+.tooltip {
+  position: absolute;
+  z-index: 9999;
+  padding: 6px;
+  background: #ffd;
+  border: 1px #886 solid;
+  border-radius: 5px;
 }
 ```
 
-### Notes
+#### JavaScript
+
+```js
+const tooltip = new (function() {
+  const node = document.createElement('div');
+  node.className = 'tooltip';
+  node.setAttribute('hidden', '');
+  document.body.appendChild(node);
+
+  this.follow = function(event) {
+    node.style.left = event.clientX + 20 + 'px';
+    node.style.top = event.clientY + 10 + 'px';
+  };
+
+  this.show = function(event) {
+    node.textContent = event.target.dataset.tooltip;
+    node.removeAttribute('hidden');
+  };
+
+  this.hide = function() {
+    node.setAttribute('hidden', '');
+  };
+})();
+
+const links = document.querySelectorAll('a');
+
+links.forEach(link => {
+  link.onmouseover = tooltip.show;
+  link.onmousemove = tooltip.follow;
+  link.onmouseout = tooltip.hide;
+});
+```
+
+#### Résultat
+
+{{EmbedLiveSample("")}}
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
 
-L'évènement `mousemove` se déclenche lorsque l'utilisateur déplace la souris.
+{{Compat}}
 
-### Spécification
+## Voir aussi
 
-{{ DOM0() }}
+- L'évènement [`mousemove`](/fr/docs/Web/API/Element/mousemove_event)
diff --git a/files/fr/web/api/globaleventhandlers/onmouseout/index.md b/files/fr/web/api/globaleventhandlers/onmouseout/index.md
index 8574ace6b64f17..3223ef2a913a36 100644
--- a/files/fr/web/api/globaleventhandlers/onmouseout/index.md
+++ b/files/fr/web/api/globaleventhandlers/onmouseout/index.md
@@ -1,26 +1,59 @@
 ---
-title: element.onmouseout
+title: GlobalEventHandlers.onmouseout
 slug: Web/API/GlobalEventHandlers/onmouseout
-tags:
-  - DOM
-  - DOM_0
-  - Référence_du_DOM_Gecko
 translation_of: Web/API/GlobalEventHandlers/onmouseout
+browser-compat: api.GlobalEventHandlers.onmouseout
 ---
-{{ ApiRef() }}
+{{ApiRef("HTML DOM")}}
 
-### Résumé
+La propriété **`onmouseout`**, rattachée au mixin [`GlobalEventHandlers`](/fr/docs/Web/API/GlobalEventHandlers), est [un gestionnaire d'évènements](/fr/docs/Web/Events/Event_handlers) qui permet de traiter les évènements [`mouseout`](/fr/docs/Web/API/Element/mouseout_event).
 
-La propriété **onmouseout** renvoie le code de gestion de l'évènement `mouseout` (sortie du pointeur de la souris) pour l'élément courant.
+Un évènement `mouseout` est déclenché lorsque la souris quitte un élément. Par exemple, si la souris se déplace en dehors d'une image d'une page web, l'évènement `mouseout` est déclenché pour cet élément d'image.
 
-### Syntaxe
+## Syntaxe
 
-    code de gestion de l'évènement = element.onmouseout
+```js
+cible.onmouseout = refFonction;
+```
 
-### Notes
+### Valeur
 
-L'évènement `mouseout` se déclenche lorsque le pointeur de la souris quitte un élément (par exemple lorsque le pointeur sort d'une image sur une page web, cet évènement se déclenche pour l'élément `image` correspondant).
+`refFonction`est un nom de fonction ou une [expression de fonction](/fr/docs/Web/JavaScript/Reference/Operators/function). La fonction reçoit un objet [`MouseEvent`](/fr/docs/Web/API/MouseEvent) comme unique argument.
 
-### Spécification
+## Exemple
 
-{{ DOM0() }}
+Cet exemple ajoute des gestionnaires d'évènements `onmouseout` et `onmouseover` sur un paragraphe. Essayez de déplacer votre souris sur le paragraphe et en dehors.
+
+### HTML
+
+```html
+<p>Testez votre souris ici !</p>
+```
+
+### JavaScript
+
+```js
+const p = document.querySelector('p');
+p.onmouseover = logMouseOver;
+p.onmouseout = logMouseOut;
+
+function logMouseOver() {
+  p.textContent = 'évènement mouseover détecté';
+}
+
+function logMouseOut() {
+  p.textContent = 'évènement mouseout détecté';
+}
+```
+
+### Résultat
+
+{{EmbedLiveSample("")}}
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
+
+{{Compat}}
diff --git a/files/fr/web/api/globaleventhandlers/onmouseup/index.md b/files/fr/web/api/globaleventhandlers/onmouseup/index.md
index 766da9723ddde2..ef47d94e7ad5a2 100644
--- a/files/fr/web/api/globaleventhandlers/onmouseup/index.md
+++ b/files/fr/web/api/globaleventhandlers/onmouseup/index.md
@@ -1,26 +1,106 @@
 ---
-title: element.onmouseup
+title: GlobalEventHandlers.onmouseup
 slug: Web/API/GlobalEventHandlers/onmouseup
-tags:
-  - DOM
-  - DOM_0
-  - Référence_du_DOM_Gecko
 translation_of: Web/API/GlobalEventHandlers/onmouseup
+browser-compat: api.GlobalEventHandlers.onmouseup
 ---
-{{ ApiRef() }}
+{{ApiRef("HTML DOM")}}
 
-### Résumé
+La propriété **`onmouseup`**, rattachée au mixin [`GlobalEventHandlers`](/fr/docs/Web/API/GlobalEventHandlers), est [un gestionnaire d'évènements](/fr/docs/Web/Events/Event_handlers) qui permet de traiter les évènements [`mouseup`](/fr/docs/Web/API/Element/mouseup_event).
 
-La propriété **onmouseup** renvoie le gestionnaire de l'évènement `mouseup` (bouton de la souris relaché) pour l'élément courant.
+Un évènement `mouseup` se produit lorsqu'on relâche le bouton de la souris.
 
-### Syntaxe
+> **Note :** Le gestionnaire d'évènements opposé à `onmouseup` est [`onmousedown`](/fr/docs/Web/API/GlobalEventHandlers/onmousedown).
 
-    code de gestion de l'évènement = element.onMouseUp
+## Syntaxe
 
-### Notes
+```js
+cible.onmouseup = refFonction;
+```
 
-L'évènement `mouseup` se déclenche lorsque l'utilisateur relâche le bouton gauche de la souris.
+### Valeur
 
-### Spécification
+`refFonction` est un nom de fonction ou une [expression de fonction](/fr/docs/Web/JavaScript/Reference/Operators/function). La fonction reçoit un objet [`MouseEvent`](/fr/docs/Web/API/MouseEvent) comme unique argument.
 
-{{ DOM0() }}
+## Exemple
+
+Dans cet exemple, une «&nbsp;tartine&nbsp;» se cache lorsqu'on clique avec la souris sur le grille-pain puis réapparaît lorsqu'on relâche le bouton. L'exemple utilise les gestionnaires d'évènements [`onmousedown`](/fr/docs/Web/API/GlobalEventHandlers/onmousedown) et `onmouseup`.
+
+### HTML
+
+```html
+<div class="container">
+  <div class="toaster"></div>
+  <div class="toast">Coucou le monde !</div>
+</div>
+```
+
+### CSS
+
+```css
+.container {
+  position: absolute;
+  left: 50%;
+  bottom: 20px;
+  transform: translate(-50%);
+}
+
+.toaster {
+  width: 160px;
+  height: 110px;
+  background: #bbb;
+  border-radius: 10px 10px 0 0;
+}
+
+.toast {
+  position: absolute;
+  left: 50%;
+  top: 50%;
+  z-index: -1;
+  width: 100px;
+  height: 50px;
+  padding: 10px;
+  background: #ed9;
+  border-radius: 10px 10px 0 0;
+  transform: translate(-50%, -90px);
+  transition: transform .3s;
+}
+
+.depressed {
+  transform: translate(-50%, -50%);
+}
+```
+
+### JavaScript
+
+```js
+function depress() {
+  toast.classList.add('depressed');
+}
+
+function release() {
+  toast.classList.remove('depressed');
+}
+
+const toaster = document.querySelector('.toaster');
+const toast = document.querySelector('.toast');
+
+toaster.onmousedown = depress;
+document.onmouseup = release;
+```
+
+### Résultat
+
+{{EmbedLiveSample("", 700, 200)}}
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
+
+{{Compat}}
+
+## Voir aussi
+
+- L'évènement [`mouseup`](/fr/docs/Web/API/Element/mouseup_event)
diff --git a/files/fr/web/api/globaleventhandlers/onresize/index.md b/files/fr/web/api/globaleventhandlers/onresize/index.md
index b18387cce12189..f65acb42955c2d 100644
--- a/files/fr/web/api/globaleventhandlers/onresize/index.md
+++ b/files/fr/web/api/globaleventhandlers/onresize/index.md
@@ -1,66 +1,64 @@
 ---
-title: element.onresize
+title: GlobalEventHandlers.onresize
 slug: Web/API/GlobalEventHandlers/onresize
-tags:
-  - DOM
-  - DOM_0
 translation_of: Web/API/window.onresize
 translation_of_original: Web/API/Element.onresize
+browser-compat: api.GlobalEventHandlers.onresize
 ---
-{{ ApiRef() }}
+{{ApiRef}}
 
-### Résumé
+La propriété **`onresize`**,rattachée au mixin [`GlobalEventHandlers`](/fr/docs/Web/API/GlobalEventHandlers), est [un gestionnaire d'évènements](/fr/docs/Web/Events/Event_handlers) qui permet de traiter les évènements [`resize`](/fr/docs/Web/API/Window/resize_event).
 
-La propriété **onresize** renvoie le code de gestion `onresize` de l'élément. Il sert également à définir le code devant s'exécuter lorsqu'un évènement de redimensionnement survient.
+Un évènement `resize` est déclenché après que la fenêtre a été redimensionnée.
 
-Seul l'objet _window_ possède un évènement `onresize`.
+## Syntaxe
 
-### Syntaxe
-
-    // attribue une fonction anonyme à onresize
-    window.onresize = function(){alert('Redimensionnement de la fenêtre')}
+```js
+window.onresize = refFonction;
+```
 
-    // Attribue la référence d'une fonction à onresize
-    function sayHi(){alert('Hi')}
+### Value
 
-    window.onresize = sayHi;
+`refFonction` est un nom de fonction ou une [expression de fonction](/fr/docs/Web/JavaScript/Reference/Operators/function). La fonction reçoit un objet [`FocusEvent`](/fr/docs/Web/API/FocusEvent) comme unique argument.
 
-    // Montre la valeur de window.onresize
-    alert(window.onresize);
+## Exemple
 
-Un évènement onresize employé avec des cadres sera lancé à chaque fois que le cadre sera redimensionné soit directement, soit comme résultant du redimensionnement de la fenêtre.
+### Journaliser l'évolution de la taille de la fenêtre
 
-### Exemple
+#### HTML
 
 ```html
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
- "http://www.w3.org/TR/html4/strict.dtd">
-<html>
-<head>
-<title>exemple avec onresize</title>
-<script type="text/javascript">
-
-function sayHi(){
-  alert('Hi');
+<p>Redimensionnez la fenêtre pour déclencher l'évènement <code>resize</code>.</p>
+<p>Hauteur de la fenêtre : <span id="height"></span></p>
+<p>Largeur de la fenêtre : <span id="width"></span></p>
+```
+
+#### JavaScript
+
+```js
+const heightOutput = document.querySelector('#height');
+const widthOutput = document.querySelector('#width');
+
+function resize() {
+  heightOutput.textContent = window.innerHeight;
+  widthOutput.textContent = window.innerWidth;
 }
 
-window.onresize = sayHi;
-
-</script>
-</head>
-<body>
-<input type="button"
- value="Cliquez ici pour voir window.onresize"
- onclick="alert(window.onresize);"
->
-</body>
-</html>
+window.onresize = resize;
 ```
 
-### Notes
+#### Résultat
+
+{{EmbedLiveSample("")}}
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
 
-Un attribut onresize peut être placé sur n'importe quel élément, mais seul l'objet `window` possède un évènement sur le redimensionnement. Le rédimensionnement d'autres éléments (par exemple, la modification de la largeur ou de la hauteur d'un élément img par un script) ne lancera aucun évènement de redimensionnement.
+{{Compat}}
 
-### Spécification
+## Voir aussi
 
-{{ DOM0() }}
+- L'évènement [`resize`](/fr/docs/Web/API/Window/resize_event)
diff --git a/files/fr/web/api/htmlelement/offsetparent/index.md b/files/fr/web/api/htmlelement/offsetparent/index.md
index 71a075b8ac4453..5257c01623f2ca 100644
--- a/files/fr/web/api/htmlelement/offsetparent/index.md
+++ b/files/fr/web/api/htmlelement/offsetparent/index.md
@@ -1,26 +1,29 @@
 ---
-title: element.offsetParent
+title: HTMLElement.offsetParent
 slug: Web/API/HTMLElement/offsetParent
-tags:
-  - DOM
-  - DOM_0
-  - Référence_du_DOM_Gecko
 translation_of: Web/API/HTMLElement/offsetParent
+browser-compat: api.HTMLElement.offsetParent
 ---
-{{ ApiRef() }}
+{{APIRef("HTML DOM")}}
 
-### Résumé
+La propriété en lecture seule **`HTMLElement.offsetParent`** fournit une référence vers le plus proche élément ancêtre positionné (plus proche selon la hiérarchie). S'il n'y a pas d'élément ancêtre positionné, c'est le plus proche ancêtre `td`, `th`, `table` qui sera renvoyé, ou `body` s'il n'y a non plus pas d'élément de tableau comme ancêtre.
 
-Renvoie une référence à l'objet qui est l'élément conteneur positionné le plus proche (dans la hiérarchie de positionnement). Si l'élément n'est pas positionné, c'est l'élément racine (html en mode de respect des standards&nbsp;; body en mode de rendu quirks) qui est l'**offsetParent**.
+> **Note :** `offsetParent` renvoie `null` dans les situations suivantes&nbsp;:
+>
+> - La propriété `display` de l'élément ou de son élément parent vaut `none`.
+> - La propriété `position` de l'élément vaut `fixed` (Firefox renverra `<body>`).
+> - L'élément courant est `<body>` ou `<html>`.
 
-### Syntaxe
+`offsetParent` est utile car [`offsetTop`](/fr/docs/Web/API/HTMLElement/offsetTop) et [`offsetLeft`](/fr/docs/Web/API/HTMLElement/offsetLeft) sont relatifs au bord de remplissage.
 
-    objetParent = element.offsetParent
+## Valeur
 
-### Paramètres
+Une référence objet vers l'élément dans lequel l'élément courant est décalé.
 
-- `objetParent` est une référence à l'élément dans lequel l'élément courant est positionné.
+## Spécifications
 
-### Spécification
+{{Specifications}}
 
-{{ DOM0() }}
+## Compatibilité des navigateurs
+
+{{Compat}}
diff --git a/files/fr/web/api/htmlelement/offsettop/index.md b/files/fr/web/api/htmlelement/offsettop/index.md
index 68c4330e6fc01c..5d9f3be21a3647 100644
--- a/files/fr/web/api/htmlelement/offsettop/index.md
+++ b/files/fr/web/api/htmlelement/offsettop/index.md
@@ -1,42 +1,37 @@
 ---
-title: element.offsetTop
+title: HTMLElement.offsetTop
 slug: Web/API/HTMLElement/offsetTop
-tags:
-  - DOM
-  - DOM_0
 translation_of: Web/API/HTMLElement/offsetTop
+browser-compat: api.HTMLElement.offsetTop
 ---
-{{ ApiRef() }}
+{{APIRef("HTML DOM")}}
 
-### Résumé
+La propriété en lecture seule **`HTMLElement.offsetTop`** renvoie la distance entre la bordure extérieure de l'élément courant et la bordure intérieure haute de l'élément [`offsetParent`](/fr/docs/Web/API/HTMLElement/offsetParent) (le plus proche ancêtre positionné).
 
-**offsetTop** renvoie la distance entre l'élément courant et le haut du nœud [`offsetParent`](/fr/docs/DOM/element.offsetParent).
+## Valeur
 
-### Syntaxe
+Un nombre.
 
-    topPos = element.offsetTop;
+## Exemples
 
-### Paramètres
+```js
+let d = document.getElementById("div1");
+let topPos = d.offsetTop;
 
-- `topPos` est le nombre de pixels depuis le haut de l'élément parent.
+if (topPos > 10) {
+  // si le décalage est supérieur
+  // à 10 pixels par rapport au parent
+}
+```
 
-### Exemple
+## Spécifications
 
-    d = document.getElementById("div1");
+{{Specifications}}
 
-    topPos = d.offsetTop;
+## Compatibilité des navigateurs
 
-    if (topPos > 10 ) {
+{{Compat}}
 
-        // l'objet est décalé de plus de
-        // 10 pixels par rapport à son parent
+Pour respecter la spécification, cette propriété renverra `null` sur WebKit si l'élément est masqué (autrement dit si `style.display` vaut `none` pour cet élément ou l'un de ses ancêtres) ou si `style.position` vaut `"fixed"` pour l'élément courant.
 
-    }
-
-### Spécification
-
-{{ DOM0() }}
-
-### Références
-
-[_offsetTop definition_ sur MSDN](http://msdn2.microsoft.com/en-us/library/ms534303.aspx)
+Cette propriété renverra `null` sur Internet Explorer (9) si `style.position` vaut `"fixed"` pour l'élément courant (`display:none` n'a pas d'impact pour ce navigateur).
diff --git a/files/fr/web/api/window/alert/index.md b/files/fr/web/api/window/alert/index.md
index 9efdaf91089c48..38994371817add 100644
--- a/files/fr/web/api/window/alert/index.md
+++ b/files/fr/web/api/window/alert/index.md
@@ -1,45 +1,60 @@
 ---
-title: window.alert
+title: Window.alert()
 slug: Web/API/Window/alert
-tags:
-  - DOM
-  - DOM_0
-  - Référence_du_DOM_Gecko
 translation_of: Web/API/Window/alert
+browser-compat: api.Window.alert
 ---
-{{ ApiRef() }}
+{{APIRef}}
 
-### Résumé
+`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.
 
-Affiche un dialogue d'alerte contenant le texte spécifié.
+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
+## Syntaxe
 
-    window.alert(message);
+```js
+alert()
+alert(message)
+```
 
-- `message` est une chaîne contenant le texte à afficher dans le dialogue d'alerte.
+### Paramètres
 
-### Exemple
+- `message` {{optional_inline}}
+  - : 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.
 
-    window.alert("Bonjour&nbsp;!");
+### Valeur de retour
 
-produira&nbsp;:
+Aucune ([`undefined`](/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined)).
+
+## Exemples
+
+```js
+window.alert("Hello world!");
+alert("Hello world!");
+```
+
+produiront tous les deux ce qui suit&nbsp;:
 
 ![](alerthelloworld.png)
 
-### Notes
+## 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.
 
-Le dialogue d'alerte doit être utilisé pour les messages qui ne demandent aucune réponse de la part de l'utilisateur, à part son acceptation du message.
+Une autre méthode consiste à utiliser l'élément [`<dialog>`](/fr/docs/Web/HTML/Element/dialog) afin d'afficher des alertes.
 
-Le texte suivant est commun à cet article, `DOM:window.prompt` et `DOM:window.confirm` Les boîtes de dialogue sont des fenêtres modales&nbsp;: elles empêchent l'utilisateur d'accéder au reste de l'interface du programme tant qu'elles ne sont pas fermées. C'est pourquoi il ne faut pas abuser des fonctions créant une boîte de dialogue (ou fenêtre modale).
+## Spécifications
 
-Les applications utilisant le chrome (par exemple les extensions) devront plutôt utiliser les méthodes de [nsIPromptService](fr/NsIPromptService).
+{{Specifications}}
 
-### Spécification
+## Compatibilité des navigateurs
 
-{{ DOM0() }}
+{{Compat}}
 
-### Voir aussi
+## Voir aussi
 
-- [confirm](/fr/DOM/window.confirm)
-- [prompt](/fr/DOM/window.prompt)
+- L'élément [`<dialog>`](/fr/docs/Web/HTML/Element/dialog)
+- [`confirm`](/fr/docs/Web/API/Window/confirm)
+- [`prompt`](/fr/docs/Web/API/Window/prompt)
diff --git a/files/fr/web/api/window/confirm/index.md b/files/fr/web/api/window/confirm/index.md
index 5a51a25ead39d4..8e9c0a34088f0f 100644
--- a/files/fr/web/api/window/confirm/index.md
+++ b/files/fr/web/api/window/confirm/index.md
@@ -1,41 +1,60 @@
 ---
-title: window.confirm
+title: Window.confirm()
 slug: Web/API/Window/confirm
-tags:
-  - DOM
-  - DOM_0
 translation_of: Web/API/Window/confirm
+browser-compat: api.Window.confirm
 ---
 {{ApiRef("Window")}}
 
-### Résumé
+`window.confirm()` indique au navigateur d'afficher une boîte de dialogue avec un message optionnel et d'attendre que la personne confirme ou annule la boîte de dialogue.
 
-Affiche un dialogue modal avec un message et deux boutons, OK et Annuler.
+Sous certaines conditions, par exemple au changement d'onglet, le navigateur pourra ne pas afficher la boîte de dialogue ou ne pas attendre la confirmation ou l'annulation.
 
-### Syntaxe
+## Syntaxe
 
-    resultat = window.confirm(message);
+```js
+confirm(message)
+```
 
-- `message` est la chaîne contenant le texte à afficher dans le dialogue.
-- `resultat` est une valeur booléenne indiquant si OK ou Annuler a été sélectionné (`true` signifie OK).
+### Paramètres
 
-### Exemple
+- `message`
+  - : Une chaîne de caractères qu'on souhaite afficher dans la boîte de dialogue de confirmation.
 
-    if (window.confirm("Une nouvelle fenêtre va s'ouvrir.")) {
-        window.open("fenetre.html", "Nouvelle fenêtre", "");
-    }
+### Valeur de retour
 
-### Notes
+Un booléen qui indique si l'option «&nbsp;OK&nbsp;» (`true`) ou «&nbsp;Annuler&nbsp;» (`false`) a été sélectionnée. Si le navigateur ignore les boîtes de dialogue, la valeur renvoyée est toujours `false`.
 
-Le texte suivant est commun à cet article, `DOM:window.prompt` et `DOM:window.confirm` Les boîtes de dialogue sont des fenêtres modales&nbsp;: elles empêchent l'utilisateur d'accéder au reste de l'interface du programme tant qu'elles ne sont pas fermées. C'est pourquoi il ne faut pas abuser des fonctions créant une boîte de dialogue (ou fenêtre modale).
+## Exemples
 
-Les applications utilisant le chrome (par exemple les extensions) devront plutôt utiliser les méthodes de [nsIPromptService](fr/NsIPromptService).
+```js
+if (window.confirm("Do you really want to leave?")) {
+  window.open("exit.html", "Thanks for Visiting!");
+}
+```
 
-### Spécification
+Créera le résultat suivant&nbsp;:
 
-{{ DOM0() }}
+![Confirmation dans Firefox](firefoxcomfirmdialog_zpsf00ec381.png)
 
-### Voir aussi
+## Notes
 
-- [alert](/fr/docs/DOM/window.alert)
-- [prompt](/fr/docs/DOM/window.prompt)
+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.
+
+Il y a également d'autres raisons [d'éviter les boîtes de dialogue pour demander une confirmation](https://alistapart.com/article/neveruseawarning/).
+
+Une autre méthode consiste à utiliser l'élément [`<dialog>`](/fr/docs/Web/HTML/Element/dialog) afin d'afficher des demandes de confirmation.
+
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
+
+{{Compat}}
+
+## Voir aussi
+
+- L'élément [`<dialog>`](/fr/docs/Web/HTML/Element/dialog)
+- [`window.alert()`](/fr/docs/Web/API/Window/alert)
+- [`window.prompt()`](/fr/docs/Web/API/Window/prompt)
diff --git a/files/fr/web/api/window/dump/index.md b/files/fr/web/api/window/dump/index.md
index 6eb59b8b00b7dd..419aecd5e18b91 100644
--- a/files/fr/web/api/window/dump/index.md
+++ b/files/fr/web/api/window/dump/index.md
@@ -1,34 +1,34 @@
 ---
-title: window.dump
+title: Window.dump()
 slug: Web/API/Window/dump
-tags:
-  - DOM
-  - DOM_0
-  - Référence_du_DOM_Gecko
 translation_of: Web/API/Window/dump
+browser-compat: api.Window.dump
 ---
-{{ ApiRef() }}
+{{ApiRef}} {{Non-standard_header}}
 
-### Résumé
+La méthode **`Window.dump()`** permet d'afficher des messages sur la sortie standard (`stdout`) du navigateur. Si le navigateur a été démarré depuis un terminal, la sortie produite par `dump()` apparaîtra dans le terminal.
 
-Affiche des messages dans la console (native).
+La sortie produite par `dump()` n'est _pas_ envoyée vers la console des outils de développement du navigateur. Pour afficher des messages dans la console des outils de développement, il faudra utiliser [`console.log()`](/fr/docs/Web/API/Console/log).
 
-### Syntaxe
+## Syntaxe
 
-    dump(message);
+```js
+dump(message)
+```
 
-- `message` est le message texte à afficher.
+### Paramètres
 
-### Notes
+- `message`
+  - : Une chaîne de caractères contenant le message à afficher.
 
-`dump` est habituellement utilisé pour débogage du JavaScript. Du code avec permissions peut également utiliser [Components.utils.reportError](/fr/Components.utils.reportError) et [nsIConsoleService](/fr/nsIConsoleService) pour afficher des messages dans la [console JavaScript](/fr/Console_JavaScript).
+### Valeur de retour
 
-Dans [Gecko](/fr/Gecko), `dump` est désactivé par défaut – il ne fait rien mais ne génère aucune erreur. Pour que `dump` écrive dans le flux standard de sortie, vous devez l'activer en mettant la préférence `browser.dom.window.dump.enabled` à `true`. Vous pouvez définir cette préférence dans [about:config](http://kb.mozillazine.org/About:config) ou dans un [fichier user.js](http://kb.mozillazine.org/User.js_file).
+Aucune ([`undefined`](/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined)).
 
-Vous aurez besoin d'une console pour voir quelque chose. Si vous n'en avez pas déjà une, fermez et réouvrez le programme en ajoutant le paramètre `-console` à la ligne de commande.
+## Spécifications
 
-`dump` est également disponible au composants XPCOM implémentés en JavaScript, même si [window](/fr/DOM/window) n'est pas l'objet global dans ce contexte.
+Cette fonctionnalité ne fait partie d'aucune spécification.
 
-### Spécification
+## Compatibilité des navigateurs
 
-{{ DOM0() }}
+{{Compat}}
diff --git a/files/fr/web/api/window/fullscreen/index.md b/files/fr/web/api/window/fullscreen/index.md
index 549e41ee632f17..aaa97e77de9b7e 100644
--- a/files/fr/web/api/window/fullscreen/index.md
+++ b/files/fr/web/api/window/fullscreen/index.md
@@ -1,40 +1,34 @@
 ---
-title: window.fullScreen
+title: Window.fullScreen
 slug: Web/API/Window/fullScreen
-tags:
-  - DOM
-  - DOM_0
-  - Référence_du_DOM_Gecko
 translation_of: Web/API/Window/fullScreen
+browser-compat: api.Window.fullScreen
 ---
-{{ ApiRef() }}
+{{APIRef}}{{Non-standard_Header}}
 
-### Résumé
+La propriété **`fullScreen`**, rattachée à l'interface `Window`, indique si la fenêtre est affichée en mode plein écran ou non.
 
-Cette propriété indique si la fenêtre est affichée en mode plein écran ou non. Elle n'est fiable qu'à partir de Gecko 1.9 (Firefox 3), voir les Notes plus bas.
+Avec des privilèges sur le chrome, cette propriété est accessible en lecture-écriture, sinon elle est uniquement accessible en lecture. Il faut garder à l'esprit que tenter de modifier cette propriété sans disposer des privilèges sur le chrome ne déclenchera pas d'exception mais échouera silencieusement. Ce comportement évite de casser les scripts qui modifient cette propriété pour Internet Explorer.
 
-### Syntaxe
+## Valeur
 
-    var isInFullScreen = windowRef.fullScreen;
+Une valeur booléenne qui indique si la fenêtre est en plein écran.
 
-Avec les privilèges chrome, la propriété est modifiable&nbsp;; autrement elle est en lecture seule. Souvenez-vous que si vous essayez de définir cette propriété sans les privilèges chrome, aucune exception ne sera déclenchée et l'appel échouera juste silencieusement. Cela permet d'empêcher que des scripts conçus pour utiliser cette propriété dans Internet Explorer cessent de fonctionner.
+## Notes
 
-### Valeur de retour
+- Passer entre le mode normal et le mode plein écran déclenchera l'évènement `resize` sur la fenêtre correspondante.
 
-- `isInFullScreen`
-  - : Une valeur booléenne. Signification des valeurs&nbsp;:
+## Exemples
 
-<!---->
+```js
+if (window.fullScreen) {
+  // en plein écran !
+}
+else {
+  // pas en plein écran !
+}
+```
 
-- `true`&nbsp;: La fenêtre est en mode plein écran.
-- `false`&nbsp;: La fenêtre n'est pas en mode plein écran.
+## Compatibilité des navigateurs
 
-### Exemples
-
-### Spécification
-
-{{ DOM0() }}
-
-### Notes
-
-Cette propriété n'est fiable qu'à partir de Mozilla 1.9 (Firefox 3). Mozilla 1.8 et les versions antérieures disposent de cette propriété, mais elle renvoie toujours `false`, même quand la fenêtre est en mode plein écran ({{ Bug(127013) }}).
+{{Compat}}
diff --git a/files/fr/web/api/window/length/index.md b/files/fr/web/api/window/length/index.md
index c9efe7f9c031f3..651265177fdc9b 100644
--- a/files/fr/web/api/window/length/index.md
+++ b/files/fr/web/api/window/length/index.md
@@ -2,25 +2,28 @@
 title: Window.length
 slug: Web/API/Window/length
 translation_of: Web/API/Window/length
+browser-compat: api.Window.length
 ---
-{{ ApiRef() }}
+{{ApiRef}}
 
-Retourne le nombre de frames (soit des éléments de frame ou iframe) présent sur la page.
+Renvoie le nombre de <i lang="en">frames</i> (que ce soit des éléments [`<frame>`](/fr/docs/Web/HTML/Element/frame) ou [`<iframe>`](/fr/docs/Web/HTML/Element/iframe)) dans la fenêtre.
 
-## Syntaxe
+## Valeur
 
-    nombreDeFrames= window.length;
+Un nombre.
 
-- _nombreDeFrames est égal au nombre de frames présent sur la page._
-
-## Exemple
+## Exemples
 
 ```js
 if (window.length) {
-  // La page contient des frames
+  // Il s'agit d'un document avec des frames
 }
 ```
 
-## Specification
+## Spécifications
+
+{{Specifications}}
+
+## Compatibilité des navigateurs
 
-{{DOM0}}
+{{Compat}}
diff --git a/files/fr/web/api/window/open/index.md b/files/fr/web/api/window/open/index.md
index 1255f9a281bb77..8871d11fad6ebd 100644
--- a/files/fr/web/api/window/open/index.md
+++ b/files/fr/web/api/window/open/index.md
@@ -1,496 +1,335 @@
 ---
-title: window.open
+title: Window.open()
 slug: Web/API/Window/open
-tags:
-  - DOM
-  - DOM_0
 translation_of: Web/API/Window/open
+browser-compat: api.Window.open
 ---
-{{ ApiRef() }}
+{{APIRef}}
 
-### Définition
+La méthode **`open()`**, rattachée à l'interface [`Window`](/fr/docs/Web/API/Window), charge une ressource indiquée dans un contexte de navigation (onglet, fenêtre ou [`<iframe>`](/fr/docs/Web/HTML/Element/iframe)) nouveau ou existant, avec un nom donné.
 
-Crée une nouvelle fenêtre de navigation secondaire et y charge la ressource référencée.
-
-### Syntaxe
+## Syntaxe
 
 ```js
-var windowObjectReference = window.open(strUrl, strWindowName[, strWindowFeatures]);
+open()
+open(url)
+open(url, target)
+open(url, target, windowFeatures)
 ```
 
-### Valeur renvoyée et paramètres
-
-- `WindowObjectReference`
-  - : Il s'agit de la référence pointant vers la fenêtre de navigation nouvellement créée. Cette référence est la valeur renvoyée par la méthode `open()`&nbsp;; elle sera à `null` si pour une raison ou une autre l'appel n'a pas réussi à ouvrir une fenêtre. Une variable globale est le meilleur endroit pour stocker une telle référence. Il est alors possible, par exemple, de l'utiliser pour obtenir certaines propriétés de la nouvelle fenêtre, ou accéder à certaines de ses méthodes, à condition que la relation entre votre fenêtre principale et votre fenêtre secondaire se conforme avec les paramètres de sécurité de même origine (_[Same origin policy](http://www.mozilla.org/projects/security/components/same-origin.html) security requirements_ ).
-- `strUrl`
-  - : Il s'agit de l'URL à charger dans la fenêtre nouvellement créée. _strUrl_ peut être un document HTML, un fichier image, ou tout autre type de fichier géré par le navigateur.
-- `strWindowName`
-  - : Il s'agit de la chaîne d'identification de la nouvelle fenêtre. Celle-ci peut être utilisée pour être la cible de liens et de formulaires lorsque l'attribut `target` d'un élément `<a>` ou d'un élément `<form>` est spécifié. Cette chaîne ne peut contenir d'espaces. _strWindowName_ ne spécifie pas le titre de la fenêtre, juste son nom interne.
-- `strWindowFeatures`
-  - : Paramètre optionnel. Il s'agit de la chaîne listant les fonctionnalités de la nouvelle fenêtre de navigation (et de ses barres d'outils). Cette chaîne ne peut contenir d'espaces. Chaque fonctionnalité doit être séparée par une virgule au sein de la chaîne de caractères.
+### Paramètres
 
-### Description
+- `url` {{optional_inline}}
+  - : Une chaîne de caractères indiquant l'URL ou le chemin de la ressource à charger. S'il s'agit d'une chaîne de caractères vide (`""`) ou que ce paramètre est absent, une page blanche est chargée dans le contexte de navigation ciblé.
 
-La méthode `open()` crée une nouvelle fenêtre secondaire de navigation, de façon similaire au choix de l'option Nouvelle fenêtre du menu Fichier. Le paramètre _strUrl_ spécifie l'URL à récupérer et à charger dans la nouvelle fenêtre. Si _strUrl_ est une chaîne vide, une nouvelle fenêtre vide de tout contenu (l'URL `about:blank` sera chargée) est créée avec les barres d'outils par défaut de la fenêtre principale.
+- `target` {{optional_inline}}
+  - : Une chaîne de caractères sans espace qui indique le nom ([`Window.name`](/fr/docs/Web/API/Window/name)) du contexte de navigation dans lequel la ressource est chargée. Si le nom ne correspond pas à un contexte déjà existant, un nouveau contexte est créé avec ce nom. [Les mots-clés spécifiques pour `target`](/fr/docs/Web/HTML/Element/a#attr-target), `_self`, `_blank`, `_parent`, et `_top`, peuvent également être utilisés.
 
-Notez que les URL distantes ne seront pas chargées instantanément. Lorsque l'appel à `window.open()` se termine et renvoie sa valeur, la fenêtre contient toujours `about:blank`. Le chargement proprement dit de l'URL est reporté et ne commence effectivement qu'après la fin de l'exécution du bloc de script courant. La création de la fenêtre d'une part et le chargement de la ressource référencée d'autre part sont faits de manière asynchrone.
+    Le nom pourra être utilisé comme valeur pour l'attribut `target` d'un élément [`<a>`](/fr/docs/Web/HTML/Element/a#attr-target) ou [`<form>`](/fr/docs/Web/HTML/Element/Form#attr-target).
 
-#### Exemples
+- `windowFeatures` {{optional_inline}}
+  - : Une chaîne de caractères contenant une liste de fonctionnalités de fenêtre, séparées par des virgules, de la forme `nom=valeur`, ou pour les fonctionnalités booléennes `nom` uniquement. Ces fonctionnalités incluent des options comme la taille et le positionnement par défaut de la fenêtre, s'il faut ouvrir une fenêtre popup minimale, etc. Les options suivantes sont prises en charge&nbsp;:
+    - `popup`
+      - : Si cette fonctionnalité est activée, il est demandé au navigateur d'ouvrir la fenêtre sous forme d'une popup minimale. Les fonctionnalités offertes par l'interface utilisateur du navigateur seront choisies par ce dernier (on y trouve généralement seulement la barre d'adresse).
 
-```js
-var windowObjectReference;
-var strWindowFeatures = "menubar=yes,location=yes,resizable=yes,scrollbars=yes,status=yes";
+        Si `popup` n'est pas activée et qu'il n'y a pas d'autres fonctionnalités déclarées avec ce paramètre, le nouveau contexte de navigation sera un onglet.
 
-function openRequestedPopup() {
-  windowObjectReference = window.open("http://www.cnn.com/", "CNN_WindowName", strWindowFeatures);
-}
-```
+        > **Note :** Indiquer n'importe quelle fonctionnalité avec `windowFeatures`, en dehors de `noopener` ou `noreferrer`, aura pour effet de demander l'ouverture d'une popup.
 
-```js
-var windowObjectReference;
-
-function openRequestedPopup() {
-  windowObjectReference = window.open(
-    "http://www.domainname.ext/path/ImageFile.png",
-    "DescriptiveWindowName",
-    "resizable,scrollbars,status"
-  );
-}
-```
+        Pour activer cette fonctionnalité, on indiquera simplement le nom `popup` sans valeur ou avec les valeurs `yes`, `1`, ou `true`.
 
-Si une fenêtre du nom _strWindowName_ existe déjà, alors, au lieu d'ouvrir une nouvelle fenêtre, _strUrl_ est chargée dans cette fenêtre existante. Dans ce cas, la valeur renvoyée par la méthode est la fenêtre existante, et _strWindowFeatures_ est ignorée. Fournir une chaîne vide pour _strUrl_ est une manière d'obtenir une référence à une fenêtre ouverte par son nom sans en changer l'adresse. Si vous désirez ouvrir une nouvelle fenêtre à chaque appel de `window.open()`, il faut utiliser la nom réservé _\_blank_ pour _strWindowName_.
+        Par exemple&nbsp;: `popup=yes`, `popup=1`, `popup=true`, et `popup` produiront le même résultat.
 
-_strWindowFeatures_ est une chaîne optionnelle contenant une liste, séparée par des virgules, de fonctionnalités demandées pour la nouvelle fenêtre. Après qu'une fenêtre soit ouverte, vous ne pouvez pas utiliser JavaScript pour changer ses fonctionnalités et ses barres d'outils. Si _strWindowName_ ne spécifie pas une fenêtre existante et si vous ne fournissez pas le paramètre _strWindowFeatures_ (ou si celui-ci est une chaîne vide), la nouvelle fenêtre secondaire comportera les barres d'outils par défaut de la fenêtre principale.
+        > **Note :** [La valeur `true` a été introduite en mars 2022](https://github.com/whatwg/html/pull/7425). Pour une meilleure compatibilité avec les anciens navigateurs, on utilisera une des autres valeurs.
 
-Si le paramètre _strWindowFeatures_ est utilisé et si aucune information de taille n'est définie, les dimensions de la nouvelle fenêtre seront les mêmes que celles de la fenêtre ouverte la plus récemment.
+    - `width` ou `innerWidth`
+      - : Indique la largeur de la zone de contenu, incluant les barres de défilement. La valeur minimale requise est 100.
 
-Si le paramètre _strWindowFeatures_ est utilisé et qu'aucune information de position n'est définie, les coordonnées du coin en haut à gauche de la nouvelle fenêtre seront décalées de 22 pixels vers le bas et vers la droite par rapport à celles de la fenêtre ouverte le plus récemment. Un décalage est utilisé par tous les concepteurs de navigateurs (il est de 29 pixels dans Internet Explorer 6 SP2 avec le thème par défaut) et son but est d'aider l'utilisateur à remarquer l'ouverture d'une nouvelle fenêtre. Si la fenêtre ouverte le plus récemment était maximisée, il n'y aura pas de décalage et la nouvelle fenêtre secondaire sera maximisée également.
+    - `height` ou `innerHeight`
+      - : Indique la hauteur de la zone de contenu, incluant les barres de défilement. La valeur minimale requise est 100.
 
-**Si le paramètre _strWindowFeatures_ est défini, les fonctionnalités qui ne sont pas listées, explicitement demandées dans la chaîne, seront désactivées ou enlevées** (à l'exception de _titlebar_ et _close_ qui sont par défaut à _yes_).
+    - `left` ou `screenX`
+      - : Indique la distance, exprimée en pixels, depuis le bord gauche de la zone de travail définie par le système d'exploitation, à laquelle la fenêtre sera ouverte.
 
-> **Note :** Si vous utilisez le paramètre _strWindowFeatures_, listez uniquement les fonctionnalités dont vous avez besoin, qui doivent être activées ou affichées. Les autres (à l'exception de _titlebar_ et _close_) seront désactivées ou enlevées.
+    - `top` ou `screenY`
+      - : Indique la distance, exprimée en pixels, depuis le bord haut de la zone de travail définie par le système d'exploitation, à laquelle la fenêtre sera ouverte.
 
-#### Fonctionnalités de position et de taille
+    - `noopener`
+      - : Si cette fonctionnalité est utilisée, la nouvelle fenêtre n'aura pas accès à la fenêtre d'origine avec [`Window.opener`](/fr/docs/Web/API/Window/opener) (qui renverra alors `null`).
 
-[Note sur les corrections d'erreurs de position et de dimension](#Note_sur_les_corrections_d.27erreurs_de_position_et_de_dimension)
+        Lorsque `noopener` est utilisé, les noms de cibles qui ne sont pas vides et qui ne sont pas `_top`, `_self`, et `_parent`, sont traités comme `_blank` lorsqu'il s'agit de décider s'il faut ouvrir un nouveau contexte de navigation.
 
-{{bug(176320) }}
+    - `noreferrer`
+      - : Si cette fonctionnalité est utilisée, le navigateur ne fournira pas d'en-tête [`Referer`](/fr/docs/Web/HTTP/Headers/Referer) et fixera d'office `noopener` à `true`. Voir [`rel="noreferrer"`](/fr/docs/Web/HTML/Link_types#noreferrer) pour plus d'informations.
 
-[Note sur les priorités](#Note_sur_les_priorit.C3.A9s)
+### Valeur de retour
 
-- left
-  - : Spécifie la distance à laquelle la nouvelle fenêtre est placée depuis le bord gauche de la zone de travail destinée aux applications du système d'exploitation de l'utilisateur jusqu'à la bordure extérieure (bordure de redimensionnement) de la fenêtre de navigation. La nouvelle fenêtre ne peut pas être positionnée initialement hors de l'écran.
-- top
-  - : Spécifie la distance à laquelle la nouvelle fenêtre est placée depuis le bord supérieur de la zone de travail destinée aux applications du système d'exploitation de l'utilisateur jusqu'à la bordure extérieure (bordure de redimensionnement) de la fenêtre de navigation. La nouvelle fenêtre ne peut pas être positionnée initialement hors de l'écran.
-- height
-  - : Spécifie la hauteur de la zone de contenu, l'espace de visualisation de la nouvelle fenêtre secondaire, en pixels. La valeur de hauteur comprend celle de la barre de défilement horizontale si celle-ci est présente. La valeur minimale requise est 100.
-- width
-  - : Spécifie la largeur de la zone de contenu, l'espace de visualisation de la nouvelle fenêtre secondaire, en pixels. La valeur de largeur comprend celle de la barre de défilement verticale si celle-ci est présente. Elle ne prend pas en compte un éventuel panneau latéral si celui-ci est déplié. La valeur minimale requise est 100.
-- screenX
-  - : Mozilla.
-- screenY
-  - : Mozilla.
-- outerHeight
+Un objet [WindowProxy](/fr/docs/Glossary/WindowProxy). La référence renvoyée peut être utilisée afin d'accéder aux propriétés et méthodes de la nouvelle fenêtre tant que les prérequis concernant [la règle de même origine](/fr/docs/Web/Security/Same-origin_policy) sont respectés.
 
-  - : Spécifie la hauteur de toute la fenêtre de navigation en pixels. Cette valeur outerHeight comprend toute barre d'outils présente, la barre de défilement horizontale de la fenêtre (si présente) et les bordures inférieures et supérieures. La valeur minimale requise est 100.
+## Description
 
-    > **Note :** étant donné que la barre de titre est toujours visible, demander une valeur outerHeight=100 rendra la valeur innerHeight de la fenêtre de navigation plus petite que les 100 pixels minimaux habituels.
+La méthode `open()` de l'interface [`Window`](/fr/docs/Web/API/Window) prend comme paramètre une URL et charge la ressource correspondante dans un onglet ou une fenêtre (nouveau ou existant). Le paramètre `target` détermine la fenêtre ou l'onglet dans lequel charger la ressource et le paramètre `windowFeatures` peut être utilisé afin de contrôler la taille et la position de la nouvelle fenêtre, ou pour ouvrir la fenêtre comme une popup, dotée d'une interface utilisateur minimale.
 
-- outerWidth
-  - : Spécifie la largeur de toute la fenêtre de navigation en pixels. Cette valeur outerWidth comprend la barre de défilement verticale (si présente) et les bords gauche et droits de la fenêtre.
-- innerHeight
-  - : de la zone de contenu, l'espace de visualisation de la nouvelle fenêtre secondaire, en pixels. La valeur `innerHeight` comprend la hauteur de la barre de défilement horizontale si celle-ci est présente. La valeur minimale requise est 100.
-- innerWidth
-  - : de la zone de contenu, l'espace de visualisation de la nouvelle fenêtre secondaire, en pixels. La valeur `innerWidth` comprend la largeur de la barre de défilement verticale si celle-ci est présente. Elle ne prend pas en compte un éventuel panneau latéral si celui-ci est déplié. La valeur minimale requise est 100.
+On notera que les URL distantes ne sont pas chargées immédiatement. Lorsque `window.open()` fournit sa valeur de retour, la nouvelle fenêtre contiendra encore `about:blank`. La récupération effective de la page démarre après que le bloc du script courant a fini son exécution. La création de la fenêtre et le chargement de la ressource référencée sont réalisés de façon asynchrone.
 
-#### Fonctionnalités de barres d'outils et de chrome
+## Exemples
 
-- menubar
-  - : Si cette fonctionnalité est définie à _yes_, la nouvelle fenêtre secondaire disposera d'une barre de menus. Les utilisateurs de Mozilla et Firefox peuvent obliger les nouvelles fenêtres à toujours avoir une barre de menus en positionnant `dom.disable_window_open_feature.menubar` à _true_ dans <kbd>about:config</kbd> ou dans leur [fichier user.js](http://www.mozilla.org/support/firefox/edit#user).
-- toolbar
-  - : Si cette fonctionnalité est définie à _yes_, la nouvelle fenêtre secondaire disposera d'une barre de navigation (boutons Précédente, Suivante, Actualiser et Arrêter). En plus de la barre de navigation, les navigateurs basés sur Mozilla afficheront également la barre d'onglets si elle est toujours visible et présente dans la fenêtre parente. Les utilisateurs de Mozilla et Firefox peuvent obliger les nouvelles fenêtres à toujours afficher la barre de navigation en positionnant `dom.disable_window_open_feature.toolbar` à _true_ dans <kbd>about:config</kbd> ou dans leur [fichier user.js](http://www.mozilla.org/support/firefox/edit#user).
-- location
-  - : Si cette fonctionnalité est définie à _yes_, la nouvelle fenêtre secondaire affichera une barre d'adresse (ou d'emplacement).Les utilisateurs de Mozilla et Firefox peuvent obliger les nouvelles fenêtres à toujours afficher la barre d'adresse en positionnant `dom.disable_window_open_feature.location` à _true_ dans <kbd>about:config</kbd> ou dans leur [fichier user.js](http://www.mozilla.org/support/firefox/edit#user). Notez qu'Internet Explorer 7 force la présence de la barre d'adresse&nbsp;: «&nbsp;Nous pensons que la barre d'adresse est aussi importante pour les utilisateurs **à voir dans les fenêtres pop-up**. Une barre d'adresse manquante crée une opportunité pour un fraudeur de contrefaire une adresse. Pour aider à contrer cela, **IE7 va afficher une barre d'adresse sur toutes les fenêtres de navigation pour aider les utilisateurs à voir où ils sont**.&nbsp;» provenant de [Better Website Identification](http://blogs.msdn.com/ie/archive/2005/11/21.aspx). Il est également dans les intentions de Mozilla de forcer la présence de la Barre d'adresse dans une prochaine version de Firefox&nbsp;: {{bug(337344) }}
-- directories
-  - : Si cette fonctionnalité est définie à _yes_, la nouvelle fenêtre secondaire affichera la barre personnelle dans les navigateurs Netscape 6.x, Netscape 7.x, Mozilla et Firefox. Dans Internet Explorer 5+, la barre de liens sera affichée. En plus de la barre personnelle, les navigateurs Mozilla afficheront la barre de navigation du site si celle-ci est visible et présente dans la fenêtre parente. Les utilisateurs de Mozilla et Firefox peuvent obliger les nouvelles fenêtres à toujours afficher leur barre personnelle en positionnant`dom.disable_window_open_feature.directories` à _true_ dans <kbd>about:config</kbd> ou dans leur [fichier user.js](http://www.mozilla.org/support/firefox/edit#user).
-- personalbar
-  - : Similaire à _directories_, mais ne fonctionne que dans Netscape et les navigateurs basés sur Mozilla.
-- status
-  - : Si cette fonctionnalité est définie à _yes_, la nouvelle fenêtre secondaire disposera d'une barre d'état. Les utilisateurs peuvent forcer la présence de la barre d'état dans tous les navigateurs basés sur Mozilla, dans Internet Explorer 6 SP2 ([Note sur la barre d'état avec XP SP2](#Note_sur_les_probl.C3.A8mes_de_s.C3.A9curit.C3.A9_li.C3.A9s_.C3.A0_la_pr.C3.A9sence_de_la_barre_d.27.C3.A9tat)) et dans Opera 6+. Les réglages par défaut des navigateurs récents basés sur Mozilla et Firefox 1.0 forcent la présence de la barre d'état.
+L'exemple qui suit illustre comment exploiter la fonctionnalité `popup`.
 
-#### Fonctionnalités relatives à la fenêtre
-
-- resizable
-
-  - : Si cette fonctionnalité est définie à _yes_, la nouvelle fenêtre secondaire sera redimensionnable À partir de la version 1.4, les navigateurs basés sur Mozilla ont une zone de redimensionnement à l'extrémité droite de la barre d'état. Cela permet de s'assurer que les utilisateurs peuvent toujours redimensionner la fenêtre même si l'auteur de la page Web a demandé que cette fenêtre secondaire ne soit pas redimensionnable. Dans ce cas, les icônes de maximisation/restauration dans la barre de titre de la fenêtre seront désactivées et les bordures de la fenêtre ne permettront pas de la redimensionner, mais celle-ci pourra toujours être redimensionnée via cette zone de la barre d'état. Il est probable qu'à partir de Firefox 3, toutes les fenêtres secondaires seront redimensionnables ({{ Bug(177838) }})
-
-    > **Note :** pour des raisons d'accessibilité, il est vivement recommandé de toujours définir cette fonctionnalité à _yes_.
-
-    Les utilisateurs de Mozilla et Firefox peuvent obliger les nouvelles fenêtres à être facilement redimensionnables en positionnant `dom.disable_window_open_feature.resizable` à _true_ dans <kbd>about:config</kbd> ou dans leur [fichier user.js](http://www.mozilla.org/support/firefox/edit#user).
-
-- scrollbars
-
-  - : Si cette fonctionnalité est définie à _yes_, la nouvelle fenêtre secondaire affichera des barres de défilement horizontales et/ou verticales si le document ne rentre pas dans la zone d'affichage de la fenêtre.
-
-    > **Note :** pour des raisons d'accessibilité, il est vivement recommandé de toujours définir cette fonctionnalité à _yes_.
-
-    Les utilisateurs de Mozilla et Firefox peuvent obliger cette option à être toujours activée en positionnant `dom.disable_window_open_feature.scrollbars` à _true_ dans <kbd>about:config</kbd> ou dans leur [fichier user.js](http://www.mozilla.org/support/firefox/edit#user).
-
-- dependent
-  - : Si définie à _yes_, la nouvelle fenêtre est dite dépendante de sa fenêtre parente. Une fenêtre dépendante se ferme lorsque sa fenêtre parente est fermée. Une fenêtre dépendante est réduite dans la barre des tâches uniquement lorsque sa fenêtre parente est réduite. Sur les plateformes Windows, une fenêtre dépendante n'est pas affichée sur la barre des tâches. Elle reste également en avant-plan de la fenêtre parente. Les fenêtres dépendantes n'existent pas sous Mac OS X, cette option y sera ignorée. La suppression complète de cette fonctionnalité sur toutes les plateformes est en cours de discussion ({{ Bug(214867) }}) Dans Internet Explorer 6, le plus proche équivalent à cette fonctionnalité est la méthode `showModelessDialog()`.
-- modal
-  - : **Note**&nbsp;: à partir de Mozilla 1.2.1, cette fonctionnalité requiert le privilège `UniversalBrowserWrite` ({{ Bug(180048) }}). Sans ce privilège, elle est équivalente à `dependent`. Si définie à _yes_, la nouvelle fenêtre est dite modale. L'utilisateur ne peut pas retourner à la fenêtre principale tant que la fenêtre modale n'est pas fermée. Une fenêtre modale typique est créée par la [fonction alert()](fr/DOM/window.alert). Le comportement exact des fenêtres modales dépend de la plateforme et de la version de Mozilla. L'équivalent de cette fonctionnalité dans Internet Explorer 6 est la méthode `showModalDialog()`.
-- dialog
-  - : La fonctionnalité `dialog` retire toutes les icônes (restaurer, réduire, agrandir) de la barre de titre de la fenêtre, laissant uniquement le bouton de fermeture. Mozilla 1.2+ et Netscape 7.1 afficheront les autres commandes du menu système (dans Firefox 1.0 et Netscape 7.0x, le menu de commandes système n'est pas associé avec l'icône de Firefox/Netscape 7.0x à l'extrémité gauche de la barre de titre, il s'agit probablement d'un bug. Il est possible d'accéder au menu de commandes système avec un clic droit sur la barre de titre). Les fenêtres de dialogue sont des fenêtres qui n'ont pas d'icône de commande système de réduction ni d'agrandissement/restauration dans la barre de titre, ni dans les choix correspondants du menu de commandes système. On les appelle dialogues car leur utilisation normale est uniquement de notifier une information et d'être ensuite immédiatement fermées. Sur les systèmes Mac, les fenêtres de dialogue ont une bordure différente et peuvent prendre la forme de*sheets*.
-- minimizable
-  - : Ce paramètre peut uniquement s'appliquer à des fenêtres de dialogue&nbsp;; l'utilisation de «&nbsp;minimizable&nbsp;» nécessite `dialog=yes`. Si `minimizable` est défini à _yes_, le nouveau dialogue aura une commande système de réduction dans la barre de titre et il sera possible de le réduire dans la barre des tâches. Toute fenêtre n'étant pas un dialogue est toujours réductible, cette option y sera donc ignorée.
-- fullscreen
-  - : Ce paramètre ne fonctionne plus dans Internet Explorer 6 SP2 de la façon dont il le faisait dans Internet Explorer 5.x. La barre des tâches de Windows, ainsi que la barre de titre et la barre d'état de la fenêtre ne sont ni visibles, ni accessibles lorsque le mode plein écran est activé dans IE 5.x. `fullscreen` ennuie toujours les utilisateurs disposant d'un grand écran ou de plusieurs écrans. Obliger les autres utilisateurs à passer en plein écran avec `fullscreen` est également extrêmement impopulaire et est considéré comme une tentative impolie d'imposer les préférences d'affichage de l'auteur à l'utilisateur. `fullscreen` ne fonctionne plus vraiment dans Internet Explorer 6 SP2.
+```js
+let windowObjectReference;
+let windowFeatures = "popup";
 
-#### Fonctionnalités nécessitant des privilèges
+function openRequestedPopup() {
+  windowObjectReference = window.open("https://www.mozilla.org/", "mozillaWindow", windowFeatures);
+}
+```
 
-Les fonctionnalités suivantes nécessitent le privilège `UniversalBrowserWrite`, autrement elles seront ignorées. Les scripts chrome bénéficient de ce privilège automatiquement, les autres doivent le demander via le [PrivilegeManager](fr/PrivilegeManager).
+On peut également contrôler la taille et la position de la nouvelle fenêtre.
 
-- chrome
-  - : **Note**&nbsp;: à partir de Mozilla 1.7/Firefox 0.9, cette fonctionnalité requiert le privilège `UniversalBrowserWrite` ({{ Bug(244965) }}). Sans ce privilège, elle est ignorée. Si définie à _yes_, la page est chargée en tant qu'unique contenu de la fenêtre, sans aucun autre élément de l'interface de navigation. Il n'y aura pas de menu contextuel défini par défaut, et aucun des raccourcis clavier standard ne fonctionnera. La page est supposée fournir sa propre interface utilisateur, et cette fonctionnalité est habituellement utilisée pour ouvrir des documents XUL (les dialogues standard comme la console JavaScript sont ouverts de cette façon).
-- titlebar
-  - : Par défaut, toutes les nouvelles fenêtres secondaires ont une barre de titre. Si défini à _no_, ce paramètre enlève la barre de titre de la nouvelle fenêtre secondaire. Les utilisateurs de Mozilla et Firefox peuvent obliger les nouvelles fenêtres à toujours avoir une barre de titre en positionnant`dom.disable_window_open_feature.titlebar` à _true_ dans <kbd>about:config</kbd> ou dans leur [fichier user.js](http://www.mozilla.org/support/firefox/edit#user).
-- alwaysRaised
-  - : Si défini à _yes_, la nouvelle fenêtre sera toujours affichée par dessus les autres fenêtres du navigateur, qu'elle soit active ou non.
-- alwaysLowered
-  - : Si défini à _yes_, la nouvelle fenêtre créé flottera par dessous sa propre fenêtre parente tant que celle-ci n'est pas réduite. Les fenêtres utilisant alwaysLowered sont souvent appelées pop-under. Celles-ci ne peuvent pas passer au dessus de leur fenêtre parente, mais celle-ci peut être réduite. Dans Netscape 6.x, les fenêtres alwaysLowered n'ont pas de commande système de réduction ni de commande système restaurer/agrandir.
-- z-lock
-  - : Identique à `alwaysLowered`.
-- close
-  - : Lorsque défini à _no_, ce paramètre supprime l'icône système de fermeture de la fenêtre, et l'élément de menu correspondant. Il fonctionnera uniquement pour les fenêtres de dialogue (avec la fonctionnalité `dialog` activée). `close=no` a précédence sur `minimizable=yes`.Les utilisateurs de Mozilla et Firefox peuvent obliger les nouvelles fenêtres à toujours avoir un bouton de fermeture en positionnant `dom.disable_window_open_feature.close` à _true_ dans <kbd>about:config</kbd> ou dans leur [fichier user.js](http://www.mozilla.org/support/firefox/edit#user).
+```js
+let windowObjectReference;
+let windowFeatures = "left=100,top=100,width=320,height=320";
 
-Les fonctionnalités de position et de taille nécessitent d'être accompagnées d'un nombre. Les fonctionnalités de barres d'outils et de fenêtre peuvent être accompagnées de _yes_ (oui) ou _no_ (non)&nbsp;; il est également possible d'utiliser _1_ à la place de _yes_ et _0_ à la place de _no_. Les fonctionnalités de barres d'outils et de fenêtre acceptent aussi une forme raccourcie&nbsp;: vous pouvez activer une fonctionnalité en listant simplement son nom dans la chaîne _strWindowFeatures_. Si vous fournissez le paramètre _strWindowFeatures_, les fonctionnalités `titlebar` et `close` sont toujours à _yes_ par défaut, mais les autres fonctionnalités présentant un choix _yes_/_no_ seront à _no_ par défaut et seront donc désactivées.
+function openRequestedPopup() {
+  windowObjectReference = window.open("https://www.mozilla.org/", "mozillaWindow", windowFeatures);
+}
+```
 
-Exemple&nbsp;:
+On peut aussi ouvrir un nouvel _onglet_ sans utiliser les fonctionnalités de fenêtre.
 
-```html
-<script type="text/javascript">
-var WindowObjectReference; // variable globale
+```js
+let windowObjectReference;
 
 function openRequestedPopup() {
-  WindowObjectReference = window.open("http://www.nomdedomaine.ext/chemin/FichierImg.png",
-        "NomDeFenetreDescriptif",
-        "width=420,height=230,resizable,scrollbars=yes,status=1");
+  windowObjectReference = window.open("https://www.mozilla.org/", "mozillaTab");
 }
-</script>
 ```
 
-Dans cet exemple, la fenêtre sera redimensionnable, elle affichera des barres de défilement si nécessaire (si le contenu dépasse les dimensions de fenêtre demandées) et affichera la barre d'état. Elle n'affichera pas la barre de menus ni la barre d'adresse. Comme l'auteur connaissait la taille de l'image (400 pixels de large et 200 pixels de haut), il a ajouté les marges appliquées à l'élément racine dans Internet Explorer 6, c'est-à-dire 15 pixels en haut, 15 pixels en bas, 10 pixels à gauche et 10 pixels à droite.
-
-### Bonnes pratiques
+## Bonnes pratiques
 
 ```html
 <script type="text/javascript">
-var WindowObjectReference = null; // variable globale
-
-function openFFPromotionPopup() {
-  if (WindowObjectReference == null || WindowObjectReference.closed) {
-    /* si le pointeur vers l'objet window n'existe pas, ou s'il existe
-       mais que la fenêtre a été fermée */
-    WindowObjectReference = window.open("http://www.spreadfirefox.com/",
-           "PromoteFirefoxWindowName", "resizable=yes,scrollbars=yes,status=yes");
-    /* alors, création du pointeur. La nouvelle fenêtre sera créée par dessus
-       toute autre fenêtre existante. */
+var windowObjectReference = null; // variable globale
+function openMozillaPopup() {
+  if(windowObjectReference == null || windowObjectReference.closed)
+  /* si le pointeur vers l'objet window n'existe pas
+     ou s'il existe mais que la fenêtre a été fermée */
+  {
+    windowObjectReference = window.open("https://www.mozilla.org/",
+   "MozillaWindowName", "popup");
+    /* on le crée. La nouvelle fenêtre sera créée et affichée
+       par-dessus les éventuelles autres fenêtres. */
   }
-  else {
-    WindowObjectReference.focus();
-    /* sinon, la référence à la fenêtre existe et la fenêtre n'a pas été
-       fermée: la fenêtre est peut-être minimisée ou derrière la fenêtre
-       principale. Par conséquent, on peut l'amener par dessus les autres à
-       l'aide de la méthode focus(). Il n'est pas nécessaire de recréer la fenêtre
-       ou de recharger la ressource référencée. */
+  else
+  {
+    windowObjectReference.focus();
+    /* sinon la référence existe et la fenêtre n'est pas fermée
+       on peut donc l'amener devant avec la méthode focus()
+       sans avoir à recréer la fenêtre ou à recharger la 
+       ressource référencée. */
   };
 }
 </script>
-
 (...)
-
-<p><a href="http://www.spreadfirefox.com/" target="PromoteFirefoxWindowName" onclick="openFFPromotionPopup(); return false;" title="Ce lien créera une nouvelle fenêtre ou en réutilisera une déjà ouverte">Promouvoir
-l'adoption de Firefox</a></p>
+<p><a
+ href="https://www.mozilla.org/"
+ target="MozillaWindowName"
+ onclick="openMozillaPopup(); return false;"
+ title="Ce lien créera une nouvelle fenêtre ou réutilisera une fenêtre déjà ouverte"
+>Site Mozilla</a></p>
 ```
 
-Le code ci-dessus résout un certain nombre de problèmes d'utilisabilité (_usability_ ) relatif aux liens ouvrant des fenêtres secondaires. Le but du `return false` dans le code est d'annuler l'action par défaut du lien&nbsp;: si le gestionnaire d'évènements onclick est exécuté, il n'est pas nécessaire d'exécuter l'action par défaut du lien. Mais si JavaScript est désactivé ou non existant dans le navigateur de l'utilisateur, c'est l'évènement onclick qui est ignoré et le navigateur charge la ressource référencée dans le cadre ou la fenêtre portant le nom «&nbsp;PromoteFirefoxWindowName&nbsp;». Si aucun cadre ni fenêtre ne porte ce nom, le navigateur créera une nouvelle fenêtre et l'appellera «&nbsp;PromoteFirefoxWindowName&nbsp;».
-
-Plus d'informations sur l'utilisation de l'attribut target&nbsp;:
+Le fragment de code qui précède corrige certains problèmes relatifs aux liens ouvrants des fenêtres secondaires. L'instruction `return false;` présente dans l'attribut `onclick` permet d'annuler l'action par défaut du lien. Toutefois, si la prise en charge de JavaScript est désactivée ou inexistante, ce gestionnaire d'évènement est ignoré et le navigateur charge la ressource référencée avec le nom "MozillaWindowName" si elle existe ou, dans le cas contraire, crée une nouvelle fenêtre et l'appelle "MozillaWindowName".
 
-[HTML 4.01, section 16.3.2 La sémantique de cible](http://www.la-grange.net/w3c/html4.01/present/frames.html#h-16.3.2)
+Pour en savoir plus sur l'attribut `target`, voir&nbsp;:
+- [La page de référence pour l'élément `<a>`](/fr/docs/Web/HTML/Element/a#target)
+- [La page de référence pour l'élément `<form>`](/fr/docs/Web/HTML/Element/Form#target)
 
-[Comment créer un lien qui ouvre une nouvelle fenêtre?](http://www.htmlhelp.com/fr/faq/html/links.html#new-window)
-
-Vous pouvez également paramétriser la fonction pour la rendre polyvalente, fonctionnelle dans plus de situations, et donc réutilisable dans d'autres scripts et pages Web&nbsp;:
+La fonction présentée ci-avant peut être réécrite pour qu'on puisse la réutiliser dans plusieurs situations&nbsp;:
 
 ```html
 <script type="text/javascript">
-var WindowObjectReference = null; // variable globale
-
-function openRequestedPopup(strUrl, strWindowName) {
-  if(WindowObjectReference == null || WindowObjectReference.closed) {
-    WindowObjectReference = window.open(strUrl, strWindowName,
-           "resizable=yes,scrollbars=yes,status=yes");
-  }
-  else {
-    WindowObjectReference.focus();
+var windowObjectReference = null; // variable globale
+function openRequestedPopup(url, windowName) {
+  if(windowObjectReference == null || windowObjectReference.closed) {
+    windowObjectReference = window.open(url, windowName, "popup");
+  } else {
+    windowObjectReference.focus();
   };
 }
 </script>
 (...)
-
-<p><a href="http://www.spreadfirefox.com/" target="PromoteFirefoxWindow" onclick="openRequestedPopup(this.href, this.target); return false;" title="Ce lien créera une nouvelle fenêtre ou en réutilisera une déjà ouverte">Promouvoir l'adoption de Firefox</a></p>
+<p><a
+ href="https://www.mozilla.org/"
+ target="MozillaWindowName"
+ onclick="openRequestedPopup(this.href, this.target); return false;"
+ title="Ce lien créera une nouvelle fenêtre ou réutilisera une fenêtre déjà ouverte"
+>Site Mozilla</a></p>
 ```
 
-Vous pouvez également ne permettre à cette fonction que d'ouvrir une seule fenêtre secondaire et de la réutiliser pour d'autres liens de cette manière&nbsp;:
+On peut aussi n'utiliser qu'une seule fenêtre secondaire et la réutiliser pour les autres liens&nbsp;:
 
 ```html
 <script type="text/javascript">
-var WindowObjectReference = null; // variable globale
-var PreviousUrl; /* variable globale qui stockera l'URL actuellement
-                    chargée dans la fenêtre secondaire */
-
-function openRequestedSinglePopup(strUrl)
-{
-  if(WindowObjectReference == null || WindowObjectReference.closed)
-  {
-    WindowObjectReference = window.open(strUrl, "SingleSecondaryWindowName",
-           "resizable=yes,scrollbars=yes,status=yes");
-  }
-  else if(previousUrl&nbsp;!= strUrl)
-  {
-    WindowObjectReference = window.open(strUrl, "SingleSecondaryWindowName",
-        "resizable=yes,scrollbars=yes,status=yes");
-    /* si la ressource à charger est différente, on la charge dans la fenêtre
-       secondaire déjà ouverte, et on ramène ensuite celle-ci par dessus
-       sa fenêtre parente. */
-    WindowObjectReference.focus();
-  }
-  else
-  {
-    WindowObjectReference.focus();
+var windowObjectReference = null; // variable globale
+var PreviousUrl; /* une variable globale qui stockera l'URL
+                    courante de la fenêtre secondaire */
+function openRequestedSinglePopup(url) {
+  if(windowObjectReference == null || windowObjectReference.closed) {
+    windowObjectReference = window.open(url, "SingleSecondaryWindowName",
+         "popup");
+  } else if(PreviousUrl != url) {
+    windowObjectReference = window.open(url, "SingleSecondaryWindowName",
+      "popup");
+    /* Si la ressource à charger est différente, on la charge dans
+       la fenêtre secondaire déjà ouverte puis on place la nouvelle
+       fenêtre au premier plan */
+    windowObjectReference.focus();
+  } else {
+    windowObjectReference.focus();
   };
-  PreviousUrl = strUrl;
-  /* explication&nbsp;: on stocke l'URL courante afin de pouvoir la comparer
-     dans le cas d'un autre appel à cette fonction. */
+  PreviousUrl = url;
+  /* On stocke l'URL courante afin de pouvoir la comparer dans 
+     le cas d'un autre appel à cette fonction. */
 }
 </script>
-
 (...)
-
-<p><a href="http://www.spreadfirefox.com/" target="SingleSecondaryWindowName"
-onclick="openRequestedSinglePopup(this.href); return false;"
-title="Ce lien créera une nouvelle fenêtre ou en réutilisera une déjà ouverte">Promouvoir
-l'adoption de Firefox</a></p>
-<p><a href="http://www.mozilla.org/support/firefox/faq"
-target="SingleSecondaryWindowName"
-onclick="openRequestedSinglePopup(this.href); return false;"
-title="Ce lien créera une nouvelle fenêtre ou en réutilisera une déjà ouverte">FAQ
-de Firefox</a></p>
+<p><a
+ href="https://www.mozilla.org/"
+ target="SingleSecondaryWindowName"
+ onclick="openRequestedSinglePopup(this.href); return false;"
+ title="Ce lien créera une nouvelle fenêtre ou réutilisera une fenêtre déjà ouverte"
+>Site Mozilla</a></p>
+<p><a
+ href="https://support.mozilla.org/fr/products/firefox"
+ target="SingleSecondaryWindowName"
+ onclick="openRequestedSinglePopup(this.href); return false;"
+ title="Ce lien créera une nouvelle fenêtre ou réutilisera une fenêtre déjà ouverte"
+>Assistance Firefox</a></p>
 ```
 
-### FAQ
-
-- Comment empêcher l'apparition du message de confirmation demandant à l'utilisateur s'il veut fermer la fenêtre&nbsp;?
-  - : Vous ne pouvez pas. **La règle est que les nouvelles fenêtres qui ne sont pas ouvertes par JavaScript ne peuvent pas être fermées par JavaScript.** La console JavaScript dans les navigateurs basés sur Mozilla affichera le message d'avertissement suivant&nbsp;: `"Scripts may not close windows that were not opened by script."` Si c'était possible, l'historique des URL visitées durant la session de navigation serait perdu au détriment de l'utilisateur. [Plus de détails sur la méthode window.close()](fr/DOM/window.close)
-- Comment ramener la fenêtre si elle est réduite ou masquée par une autre fenêtre&nbsp;?
-  - : Vérifiez d'abord l'existence de la référence à l'objet window, et si celle-ci existe et n'a pas été fermée, utilisez la méthode [focus()](fr/DOM/window.focus). Il n'y a pas d'autre manière fiable. Un [exemple montrant comment utiliser la méthode focus()](#Bonnes_pratiques) est présenté ci-dessus.
-- Comment forcer une fenêtre à être agrandie/maximisée&nbsp;?
-  - : Ce n'est pas possible. Tous les fabricants de navigateurs essaient de rendre l'ouverture d'une nouvelle fenêtre visible et remarquée par les utilisateurs, afin d'éviter de les désorienter.
-- Comment désactiver le redimensionnement des fenêtres ou supprimer les barres d'outils&nbsp;?
-  - : Il n'est pas possible de l'imposer. Les utilisateurs de navigateurs basés sur Mozilla ont un contrôle absolu sur les fonctionnalités des fenêtres comme le fait de pouvoir les redimensionner, de les faire défiler et la présence de barres d'outils via les préférences utilisateur dans `about:config`. Comme vos utilisateurs sont ceux qui sont supposés utiliser de telles fenêtres (et non vous en tant qu'auteur), le mieux est d'éviter d'interférer avec leurs habitudes et préférences. Il est recommandé de toujours positionner la redimensionnabilité et la présence de barres de défilement (si nécessaire) à `yes` pour assurer l'accessibilité au contenu et l'utilisabilité des fenêtres. Ceci est dans l'intérêt tant de l'auteur Web que de ses utilisateurs.
-- Comment redimensionner une fenêtre en fonction de son contenu&nbsp;?
-
-  - : Ce n'est pas faisable de manière fiable, car les utilisateurs peuvent empêcher la fenêtre d'être redimensionnée en décochant la case `Édition/Préférences/Avancé/Scripts & plugins/Autoriser les scripts à/ Déplacer ou redimensionner des fenêtres existantes` dans Mozilla ou `Outils/Options/Contenu/Activer JavaScript/Bouton Avancé/Déplacer ou redimensionner des fenêtres existantes` dans Firefox, ou en positionnant `dom.disable_window_move_resize` à _true_ dans <kbd>about:config</kbd> ou encore en éditant leur [fichier user.js](http://www.mozilla.org/support/firefox/edit#user). En général, les utilisateurs désactivent le déplacement et le redimensionnement des fenêtres, étant donné qu'autoriser les scripts à le faire a été la source d'énormément d'abus dans le passé, et les rares scripts qui n'en abusent pas sont souvent incorrects dans leur manière de redimensionner la fenêtre. 99% de ces scripts désactivent le redimensionnement manuel des fenêtres et les barres de défilement alors qu'ils devraient en fait activer ces deux fonctionnalités pour permettre un mécanisme de récupération sain et circonspect dans le cas où leurs calculs s'avèreraient incorrects.
-
-    La méthode [sizeToContent()](fr/DOM/window.sizeToContent) de l'objet window est également désactivée si l'utilisateur décoche la préférence `Déplacer ou redimensionner des fenêtres existantes`. Déplacer et redimensionner une fenêtre à distance sur l'écran de l'utilisateur l'ennuiera très souvent, le désorientera, et au mieux sera incorrect. Les auteurs Web espèrent souvent avoir un contrôle absolu (et un pouvoir de décision) sur tous les aspects de positionnement et de taille des fenêtres de l'utilisateur ... ce qui n'est tout simplement pas vrai.
-
-- Comment ouvrir une ressource référencée par un lien dans un nouvel onglet&nbsp;? ou dans un onglet spécifique&nbsp;?
-  - : Pour l'instant, ce n'est pas possible. Seul l'utilisateur peut modifier ses préférences avancées pour faire cela. [K-meleon 1.1](http://kmeleon.sourceforge.net/), un navigateur basé sur Mozilla, donne un contrôle et un pouvoir complet à l'utilisateur sur la manière dont les liens sont ouverts. Certaines extensions avancées donnent également à Mozilla et Firefox un grand pouvoir concernant la manière dont les ressources référencées sont chargées. Dans quelques années, la [propriété target du module CSS3 hyperlien](http://www.w3.org/TR/2004/WD-css3-hyperlinks-20040224/#target0) pourrait être implémentée (si le module CSS3 Hyperlink tel qu'il existe à présent est approuvé). Même si cela se fait et lorsque cela se produira, attendez-vous à ce que les développeurs de navigateurs utilisant des onglets donnent un pouvoir de veto à l'utilisateur et un contrôle total de la façon dont les liens peuvent ouvrir des pages Web. La façon d'ouvrir un lien devrait toujours être entièrement sous le contrôle de l'utilisateur.
-- Comment savoir si une fenêtre que j'ai ouverte l'est toujours&nbsp;?
-  - : Vous pouvez tester l'existence de la référence à l'objet `window`, qui est la valeur renvoyée en cas de succès de l'appel à `window.open()`, et vérifier ensuite que la valeur renvoyée par _WindowObjectReference_.closed est bien _false_.
-- Comment savoir si ma fenêtre a été bloquée par un bloqueur de popups&nbsp;?
-  - : Avec les bloqueurs de popups intégrés dans Mozilla/Firefox et Internet Explorer 6 SP2, il est possible de vérifier la valeur renvoyée par `window.open()`&nbsp;: elle sera _null_ si la fenêtre n'a pas été autorisée à s'ouvrir. Cependant, pour la plupart des autres bloqueurs de popups, il n'existe pas de manière fiable.
-- Quelle est la relation JavaScript entre la fenêtre principale et la fenêtre secondaire&nbsp;?
-  - : La valeur renvoyée par la méthode `window.open()` est la propriété [opener](fr/DOM/window.opener). La variable _WindowObjectReference_ lie la fenêtre principale (opener) à la fenêtre secondaire qu'elle a ouverte, tandis que le mot-clé `opener` liera la fenêtre secondaire à sa fenêtre principale (celle qui a déclenché son ouverture).
-- Je n'arrive pas à accéder aux propriétés de la nouvelle fenêtre secondaire. J'obtiens toujours une erreur dans la console JavaScript disant «&nbsp;Erreur&nbsp;: uncaught exception: Permission denied to get property \<property_name or method_name>&nbsp;». Pourquoi cela&nbsp;?
-  - : Ceci est causé par la restriction de sécurité des scripts entre domaines (aussi appelée*Same Origin Policy* , «&nbsp;Politique de même origine&nbsp;»). Un script chargé dans une fenêtre (ou cadre) d'une origine donnée (nom de domaine) **ne peut pas obtenir ou modifier** des propriétés d'une autre fenêtre (ou cadre) ou les propriétés d'aucun de ses objets HTML si celle-ci provient d'une autre origine distincte (nom de domaine). C'est pourquoi, avant d'exécuter un script se référant à une fenêtre secondaire depuis la fenêtre principale, le navigateur vérifiera que la fenêtre secondaire possède le même nom de domaine. Plus d'informations à propos de la restriction de sécurité des scripts entre domaines&nbsp;: [http://www.mozilla.org/projects/secu...me-origin.html](http://www.mozilla.org/projects/security/components/same-origin.html)
-
-### Problèmes d'utilisabilité
-
-#### Évitez de recourir à `window.open()`
-
-De manière générale, il est préférable d'éviter d'utiliser `window.open()` pour plusieurs raisons&nbsp;:
-
-- Tous les navigateurs basés sur Mozilla offrent la navigation par onglets, et il s'agit du mode préféré pour ouvrir des ressources référencées… pas seulement dans le cas des navigateurs basés sur Mozilla, mais dans tous les autres navigateurs offrant la navigation par onglets. En d'autres mots, les utilisateurs de navigateurs utilisant des onglets préfèrent ouvrir des onglets que des fenêtres dans la plupart des situations. Ce type de navigateur gagne rapidement en popularité depuis plusieurs années et cette tendance ne semble pas près de s'arrêter. La version 7 d'Internet Explorer sortie en octobre 2006 propose également la navigation par onglets.
-- Il existe à présent [plusieurs extensions à Mozilla](https://addons.update.mozilla.org/extensions/showlist.php?application=mozilla&category=Tabbed+Browsing&numpg=50&os=windows&version=auto-detect&submit=Update) (comme Multizilla) et [à Firefox](https://addons.update.mozilla.org/extensions/showlist.php?application=firefox&version=1.0+&os=Windows&category=Tabbed%20Browsing) (comme [Tabbrowser preferences](https://addons.update.mozilla.org/extensions/moreinfo.php?application=firefox&version=1.0%20&os=Windows&category=Tabbed%20Browsing&numpg=10&id=158)), fonctionnalités et préférences avancées basées sur la navigation par onglets, sur la conversion des appels à `window.open()` en ouvertures d'onglets, et sur la neutralisation des appels à `window.open()`. En particulier, afin de neutraliser l'ouverture de nouvelles fenêtres non demandées (souvent présentés comme bloquant les fenêtre popups non sollicitées ou les ouvertures automatiques de fenêtres par des scripts). Parmi ces fonctionnalités qu'on peut retrouver dans des extensions, il y a l'ouverture d'un lien dans une nouvelle fenêtre ou non, dans la même fenêtre, dans un nouvel onglet ou non, en arrière-plan ou non. Coder sans réfléchir pour ouvrir de nouvelles fenêtres n'est plus assuré de succès, ne pourra pas se faire par la force, et dans le cas où l'auteur Web y parvient, ne fera qu'ennuyer la majorité des utilisateurs.
-- Les nouvelles fenêtres peuvent avoir leur barre de menu, leurs barres de défilement, leur barre d'état, leur redimensionnabilité etc. désactivées. Ceci n'est pas possible avec de nouveaux onglets. Par conséquent, de nombreux utilisateurs préfèrent utiliser des onglets étant donné que l'interface de leur navigateur est laissée intacte et reste stable.
-- L'ouverture de nouvelles fenêtres, même avec leurs fonctionnalités réduites, utilise des ressources système considérables sur l'ordinateur de l'utilisateur (processeur, mémoire RAM) et met en jeu une grande quantité de code à exécuter (gestion de la sécurité, de la mémoire, diverses options de code parfois assez complexes, la construction du cadre de la fenêtre, des barres d'outils de la fenêtre, son positionnement et sa taille, etc.). L'ouverture de nouveaux onglets demande nettement moins de ressources système et est plus rapide à exécuter que d'ouvrir de nouvelles fenêtres.
-
-#### Offrez d'ouvrir un lien dans une nouvelle fenêtre, en suivant ces recommandations
+## FAQ
 
-Si vous voulez permettre l'ouverture d'un lien dans une nouvelle fenêtre, suivez ces règles d'utilisabilité et d'accessibilité testées et éprouvées&nbsp;:
+- Comment empêcher le message de confirmation demandant si on veut fermer la fenêtre&nbsp;?
 
-##### N'utilisez _jamais_ ce format de code pour les liens&nbsp;:<br>`<a href="javascript:window.open(...)" ...>`
+  - : Ce n'est pas possible. **Les nouvelles fenêtres qui ne sont pas ouvertes par JavaScript ne peuvent pas être fermées par JavaScript.** Pour Firefox, la console JavaScript affichera le message d'avertissement suivant&nbsp;: `"Scripts may not close windows that were not opened by script."`. Dans le cas contraire, il serait trop facile de manipuler l'historique des sites visités.
 
-Les liens «&nbsp;javascript:&nbsp;» sont toujours mauvais pour l'accessibilité et l'utilisabilité des pages Web dans tous les navigateurs.
+    Voir la documentation de la méthode [`window.close()`](/fr/docs/Web/API/Window/close) pour en savoir plus.
 
-- Les pseudo-liens «&nbsp;javascript:» ne fonctionnent plus du tout lorsque la gestion de JavaScript est désactivée ou inexistante. Certaines sociétés n'autorisent leurs employés à utiliser le Web que suivant des politiques de sécurité très strictes&nbsp;: JavaScript désactivé, pas de Java, pas d'ActiveX, pas de Flash. Pour diverses raisons (sécurité, accès public, navigateurs texte, etc.), environ 5% à 10% des utilisateurs naviguent sur le Web avec JavaScript désactivé.
-- Les liens «&nbsp;javascript:&nbsp;» interfèrent avec les fonctionnalités avancées de la navigation par onglets&nbsp;: entre autres, le clic du milieu sur des liens, le raccourci Ctrl+clic sur un lien, les fonctions de certaines extensions, etc.
-- Les liens «&nbsp;javascript:&nbsp;» interfèrent avec le processus d'indexation des pages Web par les moteurs de recherche.
-- Les liens «&nbsp;javascript:&nbsp;» interfèrent avec les technologies d'assistance (par exemple les lecteurs vocaux) et diverses applications utilisant le Web (par exemple les PDA ou les navigateurs pour mobiles).
-- Les liens «&nbsp;javascript:&nbsp;» interfèrent également avec les fonctionnalités de «&nbsp;mouse gestures&nbsp;» proposées par certains navigateurs.
-- Le schéma de protocole «&nbsp;javascript:&nbsp;» sera rapporté comme une erreur par les validateurs et vérificateurs de liens.
+- Comment ramener la fenêtre au premier plan si elle est minimisée ou derrière une autre fenêtre&nbsp;?
+  - : Tout d'abord on vérifiera l'existence de la référence à un objet `window` pour cette fenêtre, et si elle existe et qu'elle n'a pas été fermée, on utilisera la méthode [`window.focus()`](/fr/docs/Web/API/Window/focus). Pour un exemple, voir [la section précédente](#bonnes_pratiques).
+- Comment forcer l'apparition de la fenêtre maximisée&nbsp;?
+  - : Ce n'est pas possible. Les éditeurs de navigateur font le nécessaire pour que l'ouverture d'une nouvelle fenêtre secondaire soit visible et claire afin d'éviter toute confusion pour les utilisatrices et utilisateurs.
+- Comment désactiver la possibilité de redimensionner la fenêtre ou comment masquer les barres d'outils&nbsp;?
+  - : Il n'est pas possible de forcer ce comportement. Ce sont les utilisatrices et utilisateurs du navigateur qui contrôlent ces fonctionnalités. Aussi, il est recommandé de toujours activer (si besoin) la possibilité de redimensionner et la présence des barres de défilement afin de respecter l'accessibilité du contenu et l'utilisabilité des fenêtres, dans l'intérêt de tout le monde.
+- Comment redimensionner une fenêtre afin que sa taille corresponde à celle de son contenu&nbsp;?
 
-**Plus d'informations à ce sujet&nbsp;:**
+  - : On ne peut pas être certain que cela fonctionne, car les utilisatrices et utilisateurs peuvent empêcher le redimensionnement de la fenêtre (par exemple dans Firefox, la préférence `dom.disable_window_move_resize` vaut `true` par défaut).
 
-- [Top Ten Web-Design Mistakes of 2002](http://www.useit.com/alertbox/20021223.html), 6. JavaScript in Links, Jakob Nielsen, Décembre 2002
-- [Links & JavaScript Living Together in Harmony](http://www.evolt.org/article/Links_and_JavaScript_Living_Together_in_Harmony/17/20938/), Jeff Howden, Février 2002
-- [FAQ de la discussion dans le newsgroup comp.lang.javascript sur les liens "javascript:"](http://jibbering.com/faq/#FAQ4_24)
+- Comment savoir qu'une fenêtre précédemment ouverte est toujours ouverte&nbsp;?
+  - : On peut tester l'existence de la référence objet à la fenêtre avec la valeur renvoyée par l'appel à `window.open()` s'il a réussi et vérifier sur cet objet que `windowObjectReference.closed` a la valeur `false`.
+- Comment savoir si la fenêtre a été bloquée par un bloqueur de popup&nbsp;?
+  - : En raison de la présence de bloqueurs de popups natifs, on vérifiera la valeur de retour de `window.open()`. Si celle-ci vaut `null`, cela indique que la fenêtre n'a pu être ouverte. Si le blocage a lieu d'une autre façon, il n'existe pas de méthode garantie.
+- Quelle relation JavaScript existe-t-il entre la fenêtre principale et la fenêtre secondaire&nbsp;?
+  - : La méthode `window.open()` fournit à la fenêtre principale une référence vers la fenêtre secondaire. La propriété [`opener`](/fr/docs/Web/API/Window/opener) fournit à la fenêtre secondaire une référence vers la fenêtre principale.
+- Impossible d'accéder aux propriétés de la fenêtre secondaire en raison d'une exception JavaScript "Error: uncaught exception: Permission denied to get property blablabla". Pourquoi&nbsp;?
 
-##### N'utilisez jamais `<a href="#" onclick="window.open(...);">`
+  - : Des raisons de sécurité, en l'occurrence la règle de même origine, empêche un script chargé dans une fenêtre depuis une autre origine **d'accéder ou de modifier** les propriétés d'une autre fenêtre ou les propriétés des objets HTML provenant d'une autre origine. Avant d'exécuter un script ciblant une fenêtre secondaire, le navigateur vérifiera depuis la fenêtre principale que la fenêtre secondaire partage bien la même origine.
 
-Un tel pseudo-lien met également en péril l'accessibilité des liens. **Utilisez toujours une véritable URL pour la valeur de l'attribut href**, afin que si JavaScript s'avère désactivé ou absent, ou si le navigateur ne peut pas ouvrir de fenêtre secondaire (comme Microsoft Web TV, les navigateurs en mode texte, etc.), de tels navigateurs pourront toujours charger la référence référencée dans leur mode de chargement/gestion de nouvelles ressources par défaut. Cette forme de code interfère également avec les fonctionnalités avancées de navigation par onglets de certains navigateurs, comme le clic du milieu et les raccourcis Ctrl+clic et Ctrl+Entrée sur les liens, les «&nbsp;mouse gestures&nbsp;», etc.
+    Pour en savoir plus, voir [la page de documentation quant à la règle de même origine](/fr/docs/Web/Security/Same-origin_policy)
 
-##### Identifiez toujours les liens qui créeront (ou réutiliseront) une nouvelle fenêtre secondaire
+## Problèmes d'utilisabilité
 
-Identifiez les liens qui ouvriront de nouvelles fenêtre de manière à aider les utilisateurs en utilisant l'attribut `title` du lien, en ajoutant une icône à la fin du lien, ou en modifiant le curseur de la souris.
+### Éviter d'utiliser `window.open()`
 
-Le but est d'avertir les utilisateurs à l'avance des changements de contexte pour réduire la confusion de leur part&nbsp;: changer la fenêtre courante ou afficher subitement une nouvelle fenêtre peut être très désorientant pour certains utilisateurs (le bouton Précédent devient inutilisable).
+De façon générale, il est préférable d'éviter d'utiliser `window.open()`, et ce pour plusieurs raisons&nbsp;:
 
-> «&nbsp;Souvent, les utilisateurs ne remarquent pas qu'une nouvelle fenêtre s'est ouverte, particulièrement si ils utilisent un petit écran où les fenêtres sont agrandies pour utiliser toute la surface de l'écran. Ainsi, l'utilisateur voulant retourner à la page initiale sera dérouté par un bouton*Précédente* grisé.&nbsp;»
-> citation de [The Top Ten*New* Mistakes of Web Design](http://www.useit.com/alertbox/990530.html): 2. Opening New Browser Windows, Jakob Nielsen, mai 1999
+- La plupart des navigateurs modernes permettent de naviguer avec des onglets et les personnes qui les utilisent privilégient l'ouverture de nouveaux onglets à l'ouverture de nouvelles fenêtres dans la majorité des situations.
+- La plupart des navigateurs modernes fournissent des fonctionnalités pour bloquer les popups. De fait, on ne peut pas être certain que l'ouverture d'une nouvelle fenêtre de cette façon réussisse et, dans le cas contraire, cela ennuiera une majorité de personnes.
+- Les nouvelles fenêtres peuvent ne pas avoir de barres de menu, de barres de défilement, de barres de statut, la possibilité d'être redimensionnées. Ce n'est pas le cas pour les nouveaux onglets (au moins pour les barres d'outils présentes par défaut). Aussi, la navigation avec les onglets est privilégiée par de nombreuses personnes.
+- Ouvrir de nouvelles fenêtres, même avec des fonctionnalités réduites, utilise considérablement de ressources système (processeur, mémoire vive) et sollicite du code plus complexe côté navigateur. Ouvrir de nouveaux onglets est plus simple et plus efficace que d'ouvrir de nouvelles fenêtres.
 
-Lorsque des changements complets de contexte sont identifiés explicitement avant qu'ils se produisent, l'utilisateur peut déterminer s'il désire le faire ou s'y préparer&nbsp;: non seulement il ne sera pas perturbé ni désorienté, mais des utilisateurs plus expérimentés pourront eux-mêmes décider comment ouvrir de tels liens (dans une nouvelle fenêtre ou non, dans la même fenêtre, dans un nouvel onglet ou non, en arrière-plan ou non).
+### Permettre d'ouvrir un lien vers une nouvelle fenêtre, en utilisant ces lignes directrices
 
-**Références**
+Si vous souhaitez permettre d'ouvrir un lien dans une nouvelle fenêtre, nous vous invitons à suivre les conseils suivants, testés et recommandés en termes d'utilisabilité et d'accessibilité.
 
-- «&nbsp;Si votre lien crée une nouvelle fenêtre, ou fait apparaitre d'autres fenêtres sur votre affichage, ou déplace le focus du système vers un autre cadre ou une autre fenêtre, alors la chose sympathique à faire est d'indiquer à l'utilisateur que quelque chose de ce genre va se produire.&nbsp;» [World Wide Web Consortium Accessibility Initiative regarding popups](http://www.w3.org/WAI/wcag-curric/sam77-0.htm)
-- «&nbsp;Utilisez les titres de liens pour donner aux utilisateurs un aperçu d'où chaque lien les emmènera, avant qu'ils aient cliqué dessus.&nbsp;» [Ten Good Deeds in Web Design](http://www.useit.com/alertbox/991003.html), Jakob Nielsen, octobre 1999
-- [Using Link Titles to Help Users Predict Where They Are Going](http://www.useit.com/alertbox/980111.html), Jakob Nielsen, janvier 1998
+#### Ne jamais utiliser `<a href="javascript:window\.open(…)" …>`
 
-##### Utilisez toujours l'attribut target
+Les liens de la forme `"javascript:"` cassent l'accessibilité et l'utilisabilité des pages web dans chaque navigateur.
 
-Si JavaScript est désactivé ou absent, le navigateur créera une fenêtre secondaire ou affichera la ressource demandée selon sa gestion habituelle de l'attribut target&nbsp;: par exemple certains navigateurs ne pouvant pas créer de nouvelles fenêtres comme Microsoft Web TV, chargeront la ressource demandée et l'ajouteront à la fin du document courant. Le but et l'idée est d'essayer de fournir — **sans l'imposer** — à l'utilisateur une manière d'ouvrir la ressource référencée, de suivre le lien. Votre code ne doit pas interférer avec les fonctionnalités du navigateur à disposition de l'utilisateur, et doit toujours lui laisser le chemin libre et le choix de la décision finale.
+- Les pseudo-liens `"javascript:"` ne fonctionnent plus lorsque JavaScript est désactivé ou pas pris en charge.
+- Ces liens interfèrent avec les fonctionnalités avancées des navigateurs pour les onglets comme clic-milieu sur les liens, <kbd>Ctrl</kbd>+clic sur les liens, etc.
+- Ces liens interfèrent avec le processus d'indexation des pages web par les moteurs de recherche.
+- Ces liens interfèrent avec les technologies d'assistance (outils de lecture d'écran) et mobiles.
+- Le protocole "javascript:" sera marqué en erreur par les validateurs et vérificateurs de liens.
 
-##### N'utilisez pas `target="_blank"`
+#### Ne jamais utiliser `<a href="#" onclick="window.open(…);">`
 
-Fournissez toujours un nom significatif dans votre attribut target, et essayez de le réutiliser dans votre page afin qu'un clic sur un autre lien puisse charger la ressource dans une fenêtre déjà utilisée (ce qui rend l'opération beaucoup plus rapide pour l'utilisateur), ce qui justifie la raison (et les ressources système, et le temps dépensé) d'avoir créé une fenêtre secondaire. Utiliser une seule cible et la réutiliser pour plusieurs liens est bien moins gourmand en matière de ressources puisqu'une seule fenêtre est créée et recyclée. D'un autre côté, utiliser «&nbsp;_blank&nbsp;» comme attribut target créera plusieurs nouvelles fenêtre anonymes sur le bureau de l'utilisateur qui ne peuvent ni être recyclées ni réutilisées.
-
-Dans tous les cas, si votre code est bien fait, il ne devrait pas interférer avec le choix final de l'utilisateur mais lui offrira plutôt des choix supplémentaires, plus de façons d'ouvrir les liens et plus de pouvoir sur l'outil qu'il utilise (son navigateur).
-
-### Glossaire
-
-- Fenêtre ouvrante, opener, fenêtre parente, fenêtre principale, première fenêtre
-  - : Termes souvent utilisés pour décrire ou identifier la même fenêtre. Il s'agit de la fenêtre depuis laquelle une nouvelle fenêtre sera créée. C'est la fenêtre dans laquelle l'utilisateur clique sur un lien qui mène à la création d'une autre, nouvelle fenêtre.
-- Sous-fenêtre, fenêtre enfant, fenêtre secondaire, deuxième fenêtre
-  - : Termes souvent utilisés pour décrire ou identifier la même fenêtre. C'est la nouvelle fenêtre qui a été créée.
-- Fenêtres popup non sollicitées
-  - : Ouverture automatique de fenêtres initiée par un script sans le consentement de l'utilisateur.
-
-### Spécification
-
-{{ DOM0() }} `window.open()` ne fait partie d'aucune spécification ou recommandation technique du W3C.
-
-### Notes
-
-#### Note sur les priorités
-
-Dans les cas où `left` et `screenX` (et/ou `top` et `screenY`) ont des valeurs contradictoires, `left` et `top` ont priorité sur `screenX` et `screenY` respectivement. Si `left` et `screenX` (et/ou `top` et `screenY`) sont définies dans la liste _strWindowFeatures_, les valeurs `left` (et/ou `top`) seront reconnues et utilisées. Dans l'exemple suivant, la nouvelle fenêtre sera positionnée à 100 pixels du bord gauche de la zone de travail des applications du système d'exploitation de l'utilisateur, et non à 200 pixels.
-
-```html
-<script type="text/javascript">
-WindowObjectReference = window.open("http://www.lemonde.fr/",
-           "NomDeLaFenetreLeMonde",
-           "left=100,screenX=200,resizable,scrollbars,status");
-</script>
-```
-
-Si `left` est défini, mais que `top` n'a aucune valeur mais que `screenY` en a une, `left` et `screenY` seront les coordonnées de positionnement de la fenêtre secondaire.
-
-`outerWidth` a priorité sur `width`, et `width` a priorité sur `innerWidth`. `outerHeight` a priorité sur `height` et `height` a priorité sur `innerHeight`. Dans l'exemple suivant, les navigateurs basés sur Mozilla créeront une nouvelle fenêtre avec une taille extérieure (outerWidth) de 600 pixels de large et ignoreront la requête d'une largeur (width) de 500 pixels ainsi que celle d'une taille intérieure (innerWidth) de 400 pixels.
-
-```html
-<script type="text/javascript">
-WindowObjectReference = window.open("http://www.wwf.org/",
-           "NomDeLaFenetreWWF",
-           "outerWidth=600,width=500,innerWidth=400,resizable,scrollbars,status");
-</script>
-```
+De tels liens cassent l'accessibilité des liens. **On utilisera toujours une URL réelle pour l'attribut `href`** pour bien gérer le cas de JavaScript est désactivé ou le cas où l'agent utilisateur ne prend pas en charge les fenêtres secondaires. Cette forme interfère également avec les fonctionnalités avancées des navigateurs pour les onglets comme clic-milieu sur les liens, <kbd>Ctrl</kbd>+clic sur les liens, etc.
 
-#### Note sur les corrections d'erreurs de position et de dimension
+#### Toujours identifier les liens créant (ou réutilisant) une nouvelle fenêtre secondaire
 
-Les positions et dimensions demandées dans la liste _strWindowFeatures_ ne seront pas respectées et **seront corrigées** si n'importe laquelle de ces valeurs ne permet pas à la fenêtre complète d'être affichée dans la zone de travail des applications du système d'exploitation de l'utilisateur. **Aucune partie de la nouvelle fenêtre ne peut être initialement positionnée hors de l'écran. Ceci est le réglage par défaut de tous les navigateurs basés sur Mozilla.**
+On identifiera de façon notable les liens qui ouvrent une nouvelle fenêtre, par exemple en ajoutant une icône supplémentaire à la fin du lien.
 
-[Internet Explorer 6 SP2 dispose d'un mécanisme de correction d'erreur similaire](http://msdn.microsoft.com/security/productinfo/xpsp2/default.aspx?pull=/library/en-us/dnwxp/html/xpsp2web.asp#xpsp_topic5), mais celui-ci n'est pas activé par défaut pour tous les niveaux de sécurité&nbsp;: un niveau de sécurité trop bas peut désactiver ce mécanisme de correction d'erreurs.
+Cela permet d'avertir correctement les personnes qui utilisent le site et de réduire l'éventuelle confusion créée par l'ouverture d'une fenêtre. Elles peuvent ainsi choisir d'ouvrir ou non un tel lien.
 
-#### Note sur les barres de défilement
+À ce sujet, on pourra lire&nbsp;:
 
-Lorsque le contenu dépasse les dimensions de la zone de visualisation de la fenêtre, des barres de défilement (ou un mécanisme de définement similaire) sont nécessaires pour s'assurer que les utilisateurs puissent accéder au contenu. Le contenu ou la boîte du document d'une page web peut outrepasser, excéder les dimensions demandées pour la fenêtre pour plusieurs raisons qui sont hors du contrôle des auteurs Web&nbsp;:
+- [La section Accessibilité de la page de référence sur `<a>`](/fr/docs/Web/HTML/Element/a#accessibilité)
+- [G200 : Ouvrir de nouvelles fenêtres et onglets à partir d'un lien lorsque c'est strictement nécessaire - WCAG 2.0 (en anglais)](https://www.w3.org/TR/WCAG20-TECHS/G200.html)
+- [G201 : Fournir un avertissement aux utilisateurs lorsqu'ils ouvrent une nouvelle fenêtre WCAG 2.0 (en anglais)](https://www.w3.org/TR/WCAG20-TECHS/G201.html)
 
-- l'utilisateur a redimensionné la fenêtre
-- l'utilisateur a augmenté la taille de police du texte via le menu Affichage/Taille du texte (%) dans Mozilla ou Affichage/Taille du texte/Plus grande ou Plus petite dans Firefox
-- l'utilisateur a défini une taille minimale de police pour les pages qui est plus grande que celle demandée par l'auteur. Les personnes de plus de 40 ans ou ayant des habitudes particulières de lecture choisissent souvent une taille minimale de police dans les navigateurs basés sur Mozilla.
-- l'auteur n'est pas conscient des marges par défaut (et/ou bordures et/ou padding) appliquées à l'élément racine ou nœud `body` dans les différents navigateurs et versions de ceux-ci
-- l'utilisateur utilise une feuille de style utilisateur ([userContent.css in Mozilla-based browsers](http://www.mozilla.org/support/firefox/edit#content)) pour ses habitudes de navigation qui modifie les dimensions habituelles pour ses habitudes de lecture (marges, padding, taille de police par défaut)
-- l'utilisateur peut personnaliser individuellement la taille (hauteur ou largeur) de la plupart des barres d'outils via son système d'exploitation. Par exemple les bordures de fenêtres, la hauteur de la barre de titre, des menus et des barres de défilement, ainsi que la taille du texte sont entièrement personnalisables par l'utilisateur dans le système d'exploitation Windows XP. Ces dimensions de barres d'outils peuvent également être changées par des thèmes du navigateur, ou du système d'exploitation
-- l'auteur ne s'attend pas à ce que la fenêtre de l'utilisateur dispose de barres d'outils spécifiques supplémentaires&nbsp;; comme des barres de préférences, la barre web developer, des barres d'accessibilité, de blocage de popups et de recherche, etc.
-- l'utilisateur utilise des technologies assistives ou addons qui modifient la zone de travail des applications, par exemple Microsoft Magnifier
-- l'utilisateur repositionne et/ou redimensionne directement la zone de travail des apllications&nbsp;: par exemple il redimensionne la barre des tâches de Windows, la place sur le côté gauche de l'écran (versions en langues arabes) ou sur la droite (versions en hébreu), l'utilisateur a une barre de lancement rapide Microsoft Office, etc.
-- certains systèmes d'exploitation (Mac OS X) forcent la présence de barres d'outils qui peuvent démentir les anticipations et calculs de l'auteur Web sur les dimensions effectives de la fenêtre de navigation
+#### Toujours utiliser l'attribut `target`
 
-#### Note sur la barre d'état
+Si JavaScript n'est pas pris en charge ou est désactivé, l'agent utilisateur pourra se reposer sur l'attribut `target` pour créer le nouveau contexte de navigation.
 
-Vous devez vous attendre à ce qu'une large majorité des navigateurs affichent la barre d'état, ou qu'une large majorité des utilisateurs voudront forcer sa présence&nbsp;: le mieux est de toujours positionner cette fonctionnalité à yes. De plus, si vous demandez spécifiquement de retirer la barre d'état, les utilisateurs de Firefox ne pourront plus utilser la barre de navigation de site si elle est installée. Dans Mozilla et dans Firefox, toutes les fenêtres peuvent être redimensionnées à partir de la zone inférieure droite de la barre d'état. Celle-ci fournit également des informations sur la connexion http, l'emplacement des ressources hypertextes, la barre de progression du téléchargement, l'icône de chiffrement/connexion sécurisée avec SSL (affichant une icône de cadenas jaune), des icônes de zones de sécurité, de politique de sécurité en matière de cookies, etc. **Enlever la barre d'état retire souvent de très nombreuses fonctionnalités et informations considérées comme utiles (et parfois vitales) par les utilisateurs.**
+L'idée est de fournir (et non d'imposer) une méthode pour ouvrir la ressource référencée et de ne pas interférer avec les fonctionnalités et les réglages du navigateur.
 
-#### Note sur les problèmes de sécurité liés à la présence de la barre d'état
+#### Ne pas utiliser `target="_blank"`
 
-Dans Internet Explorer 6 pour XP SP2, pour les fenêtres ouvertes à l'aide de `window.open()`&nbsp;:
+Utiliser un nom significatif pour la cible permet de la réutiliser au cas où un autre lien pointe également vers celle-ci. Cela permet d'accélérer le processus car la page est déjà chargée et aussi d'économiser les ressources du système (on ne charge qu'une seule fois.
 
-> «&nbsp;Pour les fenêtres ouvertes à l'aide de `window.open()`&nbsp;:
-> Attendez-vous à ce que la barre d'état soit présente, et codez en conséquence. **La barre d'état sera activée par défaut** et fait entre 20 et 25 pixels de haut. (...)&nbsp;»
-> citation de [Fine-Tune Your Web Site for Windows XP Service Pack 2, Browser Window Restrictions in XP SP2](http://msdn.microsoft.com/security/productinfo/xpsp2/default.aspx?pull=/library/en-us/dnwxp/html/xpsp2web.asp#xpsp_topic5)
+En revanche, utiliser `\_blank` comme valeur pour l'attribut `target` créera à chaque fois une nouvelle fenêtre anonyme qui ne pourra pas être réutilisée.
 
-> «&nbsp;(...) les fenêtres créées à l'aide de la méthode `window.open()` peuvent être appelées par des scripts et utilisées pour imiter une fausse interface utilisateur ou bureau, ou pour masquer des informations ou des activités malveillantes en dimensionnant la fenêtre de manière à rendre la barre d'état invisible.
-> Les fenêtres d'Internet Explorer fournissent des informations de sécurité visibles par l'utilisateur pour l'aider à identifier avec certitude la source de la page et le niveau de sécurité de la communication avec cette page. Lorsque ces éléments ne sont pas visibles, les utilisateurs peuvent penser qu'ils sont sur une page plus digne de confiance ou interagissent avec un processus système alors qu'il sont en train d'interagir avec un hôte malveillant. (...)
-> **Les fenêtres lancées par des scripts seront affichées entièrement, avec la barre de titre d'Internet Explorer et sa barre d'état.** (...)
-> Gestion de la barre d'état d'Internet Explorer par les scripts
-> Description détaillée
-> **Internet Explorer a été modifié pour ne désactiver la barre d'état pour aucune fenêtre. La barre d'état est toujours visible pour toutes les fenêtres d'Internet Explorer.** (...) Sans ce changement, les fenêtres créées à l'aide de la méthode `window.open()` peuvent être appelées par des scripts et imiter une fausse interface utilisateur ou bureau, ou pour masquer des informations importantes pour l'utilisateur.
-> La barre d'état est une fonction de sécurité des fenêtres d'Internet Explorer qui fournissent à l'utilisateur des informations sur les zones de sécurité. Cette zone ne peut pas être imitée (...)"
-> citation de [Changes to Functionality in Microsoft Windows XP Service Pack 2, Internet Explorer Window Restrictions](http://www.microsoft.com/technet/prodtechnol/winxppro/maintain/sp2brows.mspx#ECAA)
+## Glossaire
 
-#### Note sur le plein écran (fullscreen)
+- Fenêtre ouvrante, fenêtre parente, fenêtre principale, fenêtre initiale
+  - : Les termes généralement utilisés pour décrire ou identifier la fenêtre à partir de laquelle la nouvelle fenêtre est créée. Il s'agit de la fenêtre dans laquelle on a cliqué sur un lien qui a entraîné la création de la nouvelle fenêtre.
+- Fenêtre enfant, fenêtre secondaire, deuxième fenêtre
+  - : Les termes généralement utilisés pour faire référence à la fenêtre qui vient d'être créée.
+- Popup indésirable
+  - : Une fenêtre s'ouvrant automatiquement depuis un script, sans consentement préalable.
 
-Dans Internet Explorer 6 pour XP SP2&nbsp;:
+## Notes
 
-- «&nbsp;`window.open()` avec fullscreen=yes donnera à présent une fenêtre maximisée, et non une fenêtre en mode kiosque.&nbsp;»
-- «&nbsp;La définition de la spécification de fullscreen=yes est modifiée pour signifier "afficher la fenêtre maximisée," ce qui gardera la barre de titre, la barre d'adresse et la barre d'état visibles.&nbsp;»
+### Conditions pour déterminer l'ouverture d'une popup
 
-_Références&nbsp;:_
+La plupart des navigateurs web récents, ne permettent pas au contenu web de contrôler la visibilité des éléments de l'interface utilisateur&nbsp;:
 
-- [Fine-Tune Your Web Site for Windows XP Service Pack 2](http://msdn.microsoft.com/security/productinfo/xpsp2/default.aspx?pull=/library/en-us/dnwxp/html/xpsp2web.asp#xpsp_topic5)
-- [Changes to Functionality in Microsoft Windows XP Service Pack 2, Script sizing of Internet Explorer windows](http://www.microsoft.com/technet/prodtechnol/winxppro/maintain/sp2brows.mspx#ECAA)
+- Firefox 76 ou ultérieur
+- Google Chrome
+- Safari
+- Chromium Edge
 
-#### Note sur la différence entre outerHeight et height
+Les valeurs relatives à l'interface utilisateurs qui sont passées via `windowFeatures` servent uniquement à déterminer si le nouveau contexte s'ouvre dans une popup, un onglet ou une fenêtre. Les éléments de l'interface utilisateur pour chacun de ses modes sont exclusivement déterminés par le navigateur.
 
-### Tutoriels
+Pour plus de détails sur la détermination, voir [la section correspondante de la spécification](https://html.spec.whatwg.org/multipage/window-object.html#popup-window-is-requested).
 
-**en français&nbsp;:**
+### Notes sur les barres de défilement
 
-[Créer des pop-up intelligentes](http://openweb.eu.org/articles/popup/) par Fabrice Bonny, OpenWeb
+Lorsque le contenu dépasse de la zone d'affichage (<i lang="en">viewport</i>), des barres de défilement sont nécessaires pour s'assurer que le contenu puisse être accessible. Le contenu peut dépasser des dimensions de la fenêtre pour plusieurs raisons. Pour plus de détails, voir [le dépassement du contenu](/fr/docs/Learn/CSS/Building_blocks/Overflowing_content).
 
-**en anglais&nbsp;:**
+### Note sur les corrections de position et de dimensions
 
-[JavaScript windows (tutorial)](http://www.infimum.dk/HTML/JSwindows.html) par Lasse Reichstein Nielsen
+La position et les dimensions demandées via la liste des fonctionnalités **sera corrigée** par le navigateur si une des valeurs demandée empêche que la fenêtre du navigateur soit affichée complètement dans la zone de travail des applications fournies par le système d'exploitation. 
 
-[The perfect pop-up (tutorial)](http://www.accessify.com/tutorials/the-perfect-pop-up.asp) par Ian Lloyd
+**Aucune partie de la nouvelle fenêtre ne pourra être initialement située en dehors de l'écran (il s'agit du comportement par défaut pour Firefox).**
 
-[Popup windows and Firefox (interactive demos)](http://www.gtalbot.org/FirefoxSection/Popup/PopupAndFirefox.html) par Gérard Talbot
+## Spécifications
 
-### Références
+{{Specifications}}
 
-[Links Want To Be Links](http://www.cs.tut.fi/~jkorpela/www/links.html) by Jukka K. Korpela
+## Compatibilité des navigateurs
 
-[Links & JavaScript Living Together in Harmony](http://www.evolt.org/article/Links_and_JavaScript_Living_Together_in_Harmony/17/20938/) by Jeff Howden
+{{Compat}}
diff --git a/files/fr/web/api/window/opendialog/index.md b/files/fr/web/api/window/opendialog/index.md
index 7605377e7d636f..372096266915bd 100644
--- a/files/fr/web/api/window/opendialog/index.md
+++ b/files/fr/web/api/window/opendialog/index.md
@@ -1,105 +1,102 @@
 ---
-title: window.openDialog
+title: Window.openDialog()
 slug: Web/API/Window/openDialog
-tags:
-  - DOM
-  - Gecko
-  - Window
-  - boîte de dialogue
 translation_of: Web/API/Window/openDialog
+browser-compat: api.Window.openDialog
 ---
-{{ ApiRef() }}
+{{APIRef("HTML DOM")}}{{Non-standard_header}}
 
-`window.openDialog` est une extension à [window.open()](/fr/DOM/window.open). Elle s'utilise de la même manière, excepté qu'elle peut prendre plusieurs paramètres optionnels après`windowFeatures`, et que`windowFeatures` est traîté différemment.
+La méthode `window.openDialog()` est une extension de [`window.open()`](/fr/docs/Web/API/Window/open). Elle se comporte de la même façon mais possède plus de paramètres et traite le paramètre `windowFeatures` différemment.
 
-Les paramètres optionnels, si présents, seront regroupés dans un objet JavaScript Array et seront accessibles depuis la nouvelle fenêtre par la propriété `window.arguments`. Ils sont accessibles depuis les scripts de la fenêtre à tout moment, notamment lors du traitement d'un évênement`load` . Ces paramètres peuvent donc être utilisés pour passer des arguments à une boîte de dialogue, et pour les récupérer ensuite.
+Les paramètres optionnels, s'ils sont présents, sont empaquetés dans un tableau JavaScript ([`Array`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array)) et ajouté à la nouvelle fenêtre ainsi créée via une propriété intitulée [`window.arguments`](/fr/docs/Web/API/window/arguments). Ils pourront être utilisés par le code JavaScript de la fenêtre à tout moment, y compris lors de l'exécution d'un gestionnaire d'évènement pour [`load`](/fr/docs/Web/API/Window/load_event). Ces paramètres pourront alors être utilisés afin de passer des arguments entre la fenêtre et la boîte de dialogue.
 
-Notez que l'appel à la méthode`openDialog()` se termine immédiatement. Si vous souhaitez le bloquer jusqu'à ce que l'utilisateur ferme la boîte de dialogue, utilisez la valeur`modal` pour le paramètre f`eatures`. En conséquence, l'utilisateur ne pourra pas interagir avec la fenêtre parente jusqu'à ce qu'il ferme la boîte de dialogue modale.
+L'appel à `openDialog()` renvoie immédiatement. Si on souhaite que l'appel soit bloquant jusqu'à ce que la personne ait fermé la boîte de dialogue, on pourra fournir `modal` comme paramètre pour `windowFeatures`. Cela signifie également que l'utilisateur ne pourra pas interagir avec la fenêtre ouvrante tant que la boîte modale n'est pas fermée.
 
-### Syntaxe
+## Syntaxe
 
-    newWindow = openDialog(url, name, features, arg1, arg2, ...)
+```js
+openDialog(url)
+openDialog(url, nom)
+openDialog(url, nom, fonctionnalites)
+openDialog(url, nom, fonctionnalites, arg0, arg1, /* ... ,*/ argN)
+```
+
+### Paramètres
+
+- `url`
+  - : L'URL à charger dans la nouvelle fenêtre ouverte.
+- `nom` {{optional_inline}}
+  - : Le nom de la fenêtre. Voir la description de [`window.open()`](/fr/docs/Web/API/Window/open) pour plus de détails.
+- `fonctionnalites` {{optional_inline}}
+  - : Voir [`window.open()`](/fr/docs/Web/API/Window/open) pour plus de détails.
+- `arg1`, `arg2`… {{optional_inline}}
+  - : Les arguments à passer à la nouvelle fenêtre.
 
-- newWindow
-  - : La nouvelle fenêtre ouverte.
-- url
-  - : L'URL du document à charger dans la nouvelle fenêtre.
-- name
-  - : Le nom de la fenêtre (optionnel). Voir la description de[window.open()](/fr/DOM/window.open) pour plus de détails.
-- features
-  - : Voir la description de[window.open()](/fr/DOM/window.open) pour la description.
-- arg1, arg2, ...
-  - : Les arguments à passer à la nouvelle fenêtre (optionnel).
+### Valeur de retour
 
-### Exemple
+La nouvelle fenêtre ouverte.
+
+## Exemples
 
 ```js
-var win = openDialog("http://example.tld/zzz.xul", "dlg", "", "pizza", 6.98);
+let win = openDialog("http://example.tld/zzz.xul", "dlg", "", "pizza", 6.98);
 ```
 
-### Notes
+## Notes
 
 #### Nouvelles fonctionnalités
 
-- `all`
-  - : Active ou désactive (`"all=no"`) toutes les fonctionnalités (excepté `chrome`, `dialog` et`modal`). Peut être utilisé conjointement avec les autres drapeaux (par exemple, `"menubar=no, all"` active toutes les fonctionnalités excepté `menubar`). Ce drapeau est ignorée par la méthode[window.open()](/fr/DOM/window.open) mais pas par `window.openDialog()`.
+`all` active (ou désactive avec `("all=no")`) initialement tout le chrome (excepté pour le comportement des marqueurs `chrome`, `dialog` et `modal`). Ce comportement peut être surchargé (par exemple afin que `"menubar=no,all"` affiche tout le chrome sauf la barre de menu). Cette fonctionnalité est explicitement ignorée par [`window.open()`](/fr/docs/Web/API/Window/open). `window.openDialog()` l'utilise en raison de ses hypothèses différentes.
 
-#### Comportement
+#### Comportement par défaut
 
-La méthode`window.openDialog()` traite l'absence du paramètre`features` de la même manière que[window.open()](/fr/DOM/window.open) (une chaîne vide désactive toutes les fonctionnalités) excepté pour`chrome` et`dialog` qui sont activés par défaut et peuvent être explicitement désactivées par "`chrome=no`".
+Les fonctionnalités `chrome` et `dialog` sont prises par défaut comme actives, à moins d'être explicitement désactivées ("`chrome=no`"). `openDialog()` considère l'absence de paramètres de la même façon que [`window.open()`](/fr/docs/Web/API/Window/open). Autrement dit, une chaîne de caractères vide désactive toutes les fonctionnalités sauf `chrome` et `dialog`. Si le paramètre `features` est une chaîne de caractères de longueur nulle ou contient uniquement une ou plusieurs fonctionnalités (`chrome`, `dependent`, `dialog` et `modal`), les fonctionnalités du chrome sont déterminées afin de correspondre le mieux possible au système d'exploitation.
 
-#### Passage de paramètres supplémentaires
+#### Passer des paramètres supplémentaires à la boîte de dialogue
 
-Pour passer des paramètres supplémentaires à la boîte de dialogue, vous pouvez simplement les ajouter après le paramètre f`eatures` :
+Afin de passer des paramètres supplémentaires à la boîte de dialogue, on pourra les fournir après le paramètre `windowFeatures`&nbsp;:
 
 ```js
 openDialog("http://example.tld/zzz.xul", "dlg", "", "pizza", 6.98);
 ```
 
-Ces paramètres seront ensuite regroupés dans une propriété `arguments` de type[Array](/en/Core_JavaScript_1.5_Reference/Global_Objects/Array), et cette propriété sera ajoutée à la nouvelle boîte de dialogue.
+Les paramètres supplémentaires sont alors empaquetés dans une propriété intitulée `arguments` et qui est un tableau ([`Array`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Array)). Cette propriété est ajoutée à la fenêtre de dialogue ainsi créée.
 
-Pour accéder à ces paramètres depuis un script de la boîte de dialogue, utilisez le procédé suivant :
+Pour accéder à ces paramètres depuis le code de la boîte de dialogue, on pourra utiliser la structure suivante&nbsp;:
 
 ```js
-var food = window.arguments[0];
-var price = window.arguments[1];
+let food  = window.arguments[0];
+let price = window.arguments[1];
 ```
 
-Notez que vous pouvez accéder à cette propriété depuis n'importe où dans le script. ([Autre exemple](/en/Code_snippets/Dialogs_and_Prompts#Passing_arguments_and_displaying_a_dialog)).
+Il est possible d'accéder à cette propriété depuis n'importe quel endroit dans le code de la boîte de dialogue.
 
-#### Retourner des arguments depuis la boîte de dialogue
+#### Renvoyer des valeurs depuis la boîte de dialogue
 
-Depuis que[`window.close()`](/fr/DOM/window.close) efface toutes les propriétés associées à la boîte de dialogue (c'est-à-dire les variables spécifiées depuis le code JavaScript chargé depuis la boîte de dialogue), il n'est pas possible de retourner des valeur après la fermeture de la boîte de dialogue en utilisant des variables globales (ou toute autre méthode).
+Comme [`window.close()`](/fr/docs/Web/API/Window/close) efface toutes les propriétés associées à la fenêtre de dialogue (comme les paramètres supplémentaires vus avant), il n'est pas possible de fournir des valeurs en retour après la fermeture de la fenêtre en utilisant des variables globales (ou d'autres structures).
 
-Pour pouvoir retourner des valeurs à la fenêtre parente, vous devez passer un objet via les paramètres supplémentaires. Vous pouvez ensuite accéder à cet objet depuis la boîte de dialogue et modifier ces propriétés, dont les données que vous souhaiter conserver après l'appel à la méthode`window.close()`.
+Afin de pouvoir renvoyer des valeurs à la fenêtre appelante, il faudra fournir des objets via les paramètres supplémentaires. Le code de la fenêtre de dialogue pourra alors modifier des propriétés de cet objet, qui contiendront les valeurs qu'on veut renvoyer ou conserver après l'opération `window.close()`.
 
 ```js
-var retVals = { address: null, delivery: null };
-openDialog("http://example.tld/zzz.xul", "dlg", "modal", "pizza", 6.98, retVals);
+let retVals = { address: null, delivery: null };
+openDialog("http://example.tld/zzz.xul", "dlg", "modal", "pizza", 6.98,
+    retVals);
 ```
 
-Si vous modifiez les propriétés de l'objet`retVals` depuis la boîte de dialogue comme décrit précédemment, vous pouvez y accéder via le tableau`retVals` après l'appel à `openDialog()`.
+Si on modifie les propriétés de l'objet `retVals` dans le code de la boîte de dialogue, comme ci-après, on pourra consulter leurs valeurs depuis la fenêtre d'origine après le retour de l'appel à `openDialog()`.
 
-Depuis la boîte de dialogue, vous pouvez modifier les propriétés comme suit :
+Au sein de la fenêtre de dialogue, on pourra modifier les propriétés comme suit&nbsp;:
 
 ```js
-var retVals = window.arguments[2];
-retVals.address = enteredAddress;
+let retVals = window.arguments[2];
+retVals.address  = enteredAddress;
 retVals.delivery = "immediate";
 ```
 
-Voir aussi[ce message](http://groups.google.com/group/netscape.public.dev.xul/msg/02075a1736406b40). ([Autre exemple](/en/Code_snippets/Dialogs_and_Prompts#Passing_arguments_and_displaying_a_dialog)).
-Voir aussi[window.importDialog()](/fr/DOM/window.importDialog).
-
-### Spécification
-
-{{ DOM0() }}
-
-### Compatibilité des navigateurs
+## Spécifications
 
-{{Compat("api.Window.openDialog")}}
+Cette méthode ne fait partie d'aucune spécification.
 
-### Voir également
+## Compatibilité des navigateurs
 
-- [Another example](/en-US/Add-ons/Code_snippets/Dialogs_and_Prompts#Passing_arguments_and_displaying_a_dialog)
-- [`window.importDialog`](/en-US/docs/Archive/Web/Window.importDialog) (mobile) {{deprecated_inline}}
+{{Compat}}
diff --git a/files/fr/web/api/window/opener/index.md b/files/fr/web/api/window/opener/index.md
index 950654278bd930..faf09b8f785cca 100644
--- a/files/fr/web/api/window/opener/index.md
+++ b/files/fr/web/api/window/opener/index.md
@@ -1,32 +1,31 @@
 ---
-title: window.opener
+title: Window.opener
 slug: Web/API/Window/opener
-tags:
-  - DOM
-  - DOM_0
-  - Référence_du_DOM_Gecko
 translation_of: Web/API/Window/opener
+browser-compat: api.Window.opener
 ---
-{{ ApiRef() }}
+{{APIRef("HTML DOM")}}
 
-### Résumé
+La propriété **`opener`**, rattachée à l'interface [`Window`](/fr/docs/Web/API/Window), renvoie une référence à la fenêtre ayant ouvert la fenêtre courante, que ce soit avec [`open()`](/fr/docs/Web/API/Window/open), ou via une navigation avec un lien doté d'un attribut [`target`](/fr/docs/Web/HTML/Element/a#attr-target).
 
-Renvoie une référence vers la fenêtre qui a ouvert la fenêtre courante.
+Autrement dit, si la fenêtre `A` ouvre la fenêtre `B`, `B.opener` renvoie `A`.
 
-### Syntaxe
+## Valeur
 
-    refObj = window.opener
+Un objet semblable à un objet [`Window`](/fr/docs/Web/API/Window) qui fait référence à la fenêtre ayant ouvert la fenêtre courante (avec [`window.open()`](/fr/docs/Web/API/Window/open), ou avec un lien doté d'un attribut [`target`](/fr/docs/Web/HTML/Element/a#attr-target)). Si la fenêtre n'a pas été ouverte par un lien ou créée par une autre fenêtre, la propriété renvoie [`null`](/fr/docs/Web/JavaScript/Reference/Global_Objects/null).
 
-### Exemple
+Si l'ouvreur n'a pas la même origine que la page courante, les fonctionnalités de cet objet seront limitées. Ainsi, les variables et fonction associés à l'objet `window` ne seront pas accessibles. Toutefois, la navigation vers la fenêtre ouvrante est possible, autrement dit que la fenêtre ouverte peut ouvrir une URL dans l'onglet ou la fenêtre d'origine. Dans certains cas, cela peut permettre de l'hameçonnage où une page de confiance, ouverte par la fenêtre originale est remplacée par une page d'hameçonnage par la page nouvellement ouverte.
 
-     if window.opener&nbsp;!= indexWin {
-         referToTop(window.opener);
-     }
+Dans les cas suivants, le navigateur ne renseigne pas `window.opener`, mais le laisse à [`null`](/fr/docs/Web/JavaScript/Reference/Global_Objects/null)&nbsp;:
 
-### Notes
+- Si [`rel="noopener"`](/fr/docs/Web/HTML/Element/a#attr-rel) est présent sur le lien ou si on a passé `noopener` via le paramètre [`windowFeatures`](/fr/docs/Web/API/Window/open).
+- Si la fenêtre a été ouverte avec un lien dont l'attribut [`target`](/fr/docs/Web/HTML/Element/a#attr-target) vaut `_blank`, à moins qu'il ait été explicitement demandé avec with [`rel="opener"`](/fr/docs/Web/HTML/Element/a#attr-rel).
+- Si l'en-tête [`Cross-Origin-Opener-Policy`](/fr/docs/Web/HTTP/Headers/Cross-Origin-Opener-Policy) possède la valeur `same-origin`. La nouvelle fenêtre étant chargée dans un contexte de navigation différent, elle n'aura pas de référence à la fenêtre ouvrante.
 
-Lorsqu'une fenêtre est ouverte depuis une autre fenêtre, elle conserve une référence à cette première fenêtre dans `window.opener`. Si la fenêtre courante n'a pas été ouverte par une autre fenêtre, la méthode renvoie `null`.
+## Spécifications
 
-### Spécification
+{{Specifications}}
 
-{{ DOM0() }}
+## Compatibilité des navigateurs
+
+{{Compat}}
diff --git a/files/fr/web/api/window/parent/index.md b/files/fr/web/api/window/parent/index.md
index c82013ed40e924..19bbca760b4b98 100644
--- a/files/fr/web/api/window/parent/index.md
+++ b/files/fr/web/api/window/parent/index.md
@@ -1,34 +1,38 @@
 ---
-title: window.parent
+title: Window.parent
 slug: Web/API/Window/parent
-tags:
-  - DOM
-  - DOM_0
-  - Référence_du_DOM_Gecko
 translation_of: Web/API/Window/parent
+browser-compat: api.Window.parent
 ---
-{{ ApiRef() }}
+{{APIRef}}
 
-### Résumé
+La propriété **`Window.parent`** est une référence au parent de la fenêtre ou du cadre embarqué (<i lang="en">subframe</i>).
 
-Renvoie une référence à la fenêtre parente ou cadre parent de la fenêtre courante ou du cadre courant.
+Si une fenêtre n'a pas de parent, la propriété `parent` sera une référence à elle-même.
 
-### Syntaxe
+Lorsqu'une fenêtre est chargée dans un élément [`<iframe>`](/fr/docs/Web/HTML/Element/iframe), [`<object>`](/fr/docs/Web/HTML/Element/object), ou [`<frame>`](/fr/docs/Web/HTML/Element/frame), son parent correspond à la fenêtre de l'élément qui embarque la fenêtre.
 
-    refObj = window.parent
+## Valeur
 
-### Exemple
+Un objet `Window` ou [`<iframe>`](/fr/docs/Web/HTML/Element/iframe).
 
-    if (window.parent&nbsp;!= window.top) {
-         // on se trouve dans une imbrication de cadres
-    }
+## Exemples
 
-### Notes
+```js
+if (window.parent != window.top) {
+  // Nous sommes à plus d'un niveau de profondeur
+}
+```
 
-Si une fenêtre n'a pas de parent, sa propriété **parent** est une référence vers elle-même.
+## Spécifications
 
-Lorsqu'une fenêtre est chargée dans un ensemble de cadres (frameset), son parent est le cadre parent (c'est-à-dire le document dans lequel se trouve l'élément `<frame>` qui fait référence à la fenêtre).
+{{Specifications}}
 
-### Spécification
+## Compatibilité des navigateurs
 
-{{ DOM0() }}
+{{Compat}}
+
+## Voir aussi
+
+- [`window.frameElement`](/fr/docs/Web/API/Window/frameElement) renvoie l'élément spécifique (par exemple `<iframe>`) dans lequel `window` est embarqué.
+- [`window.top`](/fr/docs/Web/API/Window/top) renvoie une référence à la fenêtre de plus haut niveau.
diff --git a/files/fr/web/api/window/scrollto/index.md b/files/fr/web/api/window/scrollto/index.md
index ff56d9f26943bc..60047be7afafe4 100644
--- a/files/fr/web/api/window/scrollto/index.md
+++ b/files/fr/web/api/window/scrollto/index.md
@@ -1,34 +1,69 @@
 ---
-title: window.scrollTo
+title: Window.scrollTo()
 slug: Web/API/Window/scrollTo
-tags:
-  - DOM
-  - DOM_0
 translation_of: Web/API/Window/scrollTo
+browser-compat: api.Window.scrollTo
 ---
-{{ ApiRef() }}
+{{APIRef}}
 
-### Résumé
+La méthode **`Window.scrollTo()`** permet de faire défiler la fenêtre pour atteindre les coordonnées données dans le document.
 
-Fait défiler le document jusqu'à un jeu de coordonnées particulier.
+## Syntaxe
 
-### Syntaxe
-
-    window.scrollTo(coord-x,coord-y);
+```js
+scrollTo(x-coord, y-coord)
+scrollTo(options)
+```
 
 ### Paramètres
 
-- `coord-x` est le pixel le long de l'axe horizontal du document qui doit être affiché en haut à gauche.
-- `coord-y` est le pixel le long de l'axe vertical du document qui doit être affiché en haut à gauche.
+- `x-coord`
+  - : Le pixel sur l'axe horizontal du document dont on veut qu'il soit affiché dans le coin supérieur gauche.
+- `y-coord`
+  - : Le pixel sur l'axe vertical du document dont on veut qu'il soit affiché dans le coin supérieur gauche.
+
+ou
+
+- `options`
+  - : Un dictionnaire avec les paramètres suivants&nbsp;:
+    - `top`
+      - : Indique le nombre de pixels le long desquels faire défiler la fenêtre ou l'élément sur l'axe vertical.
+    - `left`
+      - : Indique le nombre de pixels le long desquels faire défiler la fenêtre ou l'élément sur l'axe horizontal.
+    - `behavior`
+      - : Indique si le défilement devrait être doux (valeur `smooth`), ou s'il devrait avoir lieu instantanément, en une seule fois (valeur `auto`, qui est la valeur par défaut).
+
+### Valeur de retour
+
+Aucune ([`undefined`](/fr/docs/Web/JavaScript/Reference/Global_Objects/undefined)).
+
+## Exemples
+
+### Usage simple
+
+```js
+window.scrollTo(0, 1000);
+```
+### En utilisant `options`
+
+```js
+window.scrollTo({
+  top: 100,
+  left: 100,
+  behavior: 'smooth'
+});
+```
+
+## Notes
 
-### Exemple
+[`Window.scroll()`](/fr/docs/Web/API/Window/scroll) est la même que cette méthode. Pour le défilement relatif, voir les méthodes [`Window.scrollBy()`](/fr/docs/Web/API/Window/scrollBy), [`Window.scrollByLines()`](/fr/docs/Web/API/Window/scrollByLines), et [`Window.scrollByPages()`](/fr/docs/Web/API/Window/scrollByPages).
 
-    window.scrollTo(0, 1000);
+Pour le défilement des éléments, voir [`Element.scrollTop`](/fr/docs/Web/API/Element/scrollTop) et [`Element.scrollLeft`](/fr/docs/Web/API/Element/scrollLeft).
 
-### Notes
+## Spécifications
 
-Cette fonction est fonctionnellement identique à [window.scroll](scroll). Pour un défilement relatif, consultez [window.scrollBy](scrollBy), [window.scrollByLines](scrollByLines) et [window.scrollByPages](scrollByPages).
+{{Specifications}}
 
-### Spécification
+## Compatibilité des navigateurs
 
-{{ DOM0() }}
+{{Compat}}