recursal/MDN huggingface dataset:
Document.lastModified
=====================

Retourne une chaîne de caractère contenant la date et l'heure à laquelle le présent document a été modifié pour la dernière fois.

Syntaxe
-------


```js
string = document.lastModified;
```

Exemples
--------

### Exemple #1: Utilisation simple


```js
alert(document.lastModified);
// renvoie: 11/28/2015 16:11:15
```

### Exemple #2: Transformer `lastModified` en un objet de type `Date` (en-US)


```js
var oLastModif = new Date(document.lastModified);
```

### Exemple #3: Transformer `lastModified` en un nombre de millisecondes passées depuis le 1 Janvier 1970 à 00:00:00, heure locale


```js
var nLastModif = Date.parse(document.lastModified);
```

Notes
-----

Veuillez noter qu'en tant que chaîne de caractères, `lastModified` ne peut être *facilement* utilisé pour des comparaisons entre les dates modifiées des documents. Voici un exemple possible qui montre comment afficher une alerte quand la page change (voir aussi l'API des cookies en JavaScript (en-US)) :


```js
if (
  Date.parse(document.lastModified) >
  parseFloat(
    document.cookie.replace(
      /(?:(?:^|.\*;)\s\*last\_modif\s\*\=\s\*([^;]\*).\*$)|^.\*$/,
      "$1",
    ) || "0",
  )
) {
  document.cookie =
    "last\_modif=" +
    Date.now() +
    "; expires=Fri, 31 Dec 9999 23:59:59 GMT; path=" +
    location.pathname;
  alert("Cette page a changé !");
}
```


… le même exemple, mais en ignorant la première visite:


```js
var nLastVisit = parseFloat(
    document.cookie.replace(
      /(?:(?:^|.\*;)\s\*last\_modif\s\*\=\s\*([^;]\*).\*$)|^.\*$/,
      "$1",
    ),
  ),
  nLastModif = Date.parse(document.lastModified);

if (isNaN(nLastVisit) || nLastModif > nLastVisit) {
  document.cookie =
    "last\_modif=" +
    Date.now() +
    "; expires=Fri, 31 Dec 9999 23:59:59 GMT; path=" +
    location.pathname;
  if (isFinite(nLastVisit)) {
    alert("Cette page a changé !");
  }
}
```


**Note :** WebKit renvoie le temps sous forme de chaîne de caractère en UTC; Gecko et Internet Explorer renvoient le temps selon le fuseau horaire local. (Voir: Bogue 4363 – document.lastModified renoive la date en UTC, mais devrait la renvoyer selon le fuseau horaire local)

Si vous voulez savoir **si *une page externe* a changé,** veuillez lire ce paragraphe à propos de l'API `XMLHttpRequest()`.

Spécification
-------------

HTML5

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

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

`createCDATASection()` crée un nouveau noeud de section CDATA et le renvoie.

Syntaxe
-------


```js
CDATASectionNode = document.createCDATASection(data);
```


* `CDATASectionNode` est un noeud de Section CDATA.
* `data` est une string (*chaîne de caractères*) contenant les données à ajouter à la section CDATA.
Exemple
-------


```js
var docu = new DOMParser().parseFromString("<xml></xml>", "application/xml");

var cdata = docu.createCDATASection("Some <CDATA> data & then some");

docu.getElementsByTagName("xml")[0].appendChild(cdata);

alert(new XMLSerializer().serializeToString(docu));
// Affiche : <xml><![CDATA[Some <CDATA> data & then some]]></xml>
```

Notes
-----

* Cela fonctionnera uniquement avec XML, pas avec les documents HTML (car les documents HTML ne supportent pas les sections CDATA) ; le tenter sur un document HTML va lancer une exception `NOT_SUPPORTED_ERR`.
* Va lancer une exception `NS_ERROR_DOM_INVALID_CHARACTER_ERR` si on essaye de soumettre la séquence CDATA de fermeture ("]]>") en tant que partie des données ; les données fournies par l'utilisateur non échappées, ne peuvent pas être utilisées en toute sécurité sans qu'avec cette méthode on obtienne cette exception (`createTextNode()` peut souvent être utilisé à sa place).
Spécification
-------------

* createCDATASection
Document.applets
================

`applets` retourne une liste ordonnée des applets contenus dans un document.

### Syntaxe


```js
nodeList = document.applets;
```

### Exemple


```js
// ( Si vous savez que le second applet est celui que vous voulez )
my_java_app = document.applets[1];
```

### Spécification

DOM Level 2 HTML: applets
Document.hidden
===============

La propriété **`Document.hidden`** retourne un Booléen qui indique si la page est considérée cachée ou pas.

Syntaxe
-------


```js
var boolean = document.hidden;
```

Exemples
--------


```js
document.addEventListener("visibilitychange", function () {
  console.log(document.hidden);
  // Modifier le comportement...
});
```

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

| Specification |
| --- |
| HTML Standard # dom-document-hidden |

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

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

Retourne un objet `Range`.

Syntaxe
-------


```js
range = document.createRange();
```


`range` devient un objet `Range`.

Exemple
-------


```js
var range = document.createRange();

range.setStart(startNode, startOffset);
range.setEnd(endNode, endOffset);
```

Notes
-----

Une fois un objet `Range` créé, il est nécessaire de spécifier les limites de départ et de fin avant de pouvoir utiliser la plupart des méthodes.

Spécification
-------------

* DOM Level 2 Range: DocumentRange.createRange
Document.forms
==============

La propriété `forms` de `Document` retourne une collection (`HTMLCollection`) des éléments `<form>` présents dans le document actuel.

**Note :** De même, vous pouvez accéder à une liste des éléments d'entrée utilisateur d'un formulaire à l'aide de la propriété `HTMLFormElement.elements`.

Syntaxe
-------


```js
collection = document.forms;
```

### Valeur

Un objet `HTMLCollection` listant tous les formulaires du document. Chaque élément de la collection est un `HTMLFormElement` représentant un seul élément `<form>`.

Exemples
--------

### Récupérer les informations d'un formulaire


```html
<!doctype html>
<html lang="en">
  <head>
    <title>document.forms example</title>
  </head>

  <body>
    <form id="robby">
      <input
 type="button"
 onclick="alert(document.forms[0].id);"
 value="robby's form" />
    </form>

    <form id="dave">
      <input
 type="button"
 onclick="alert(document.forms[1].id);"
 value="dave's form" />
    </form>

    <form id="paul">
      <input
 type="button"
 onclick="alert(document.forms[2].id);"
 value="paul's form" />
    </form>
  </body>
</html>
```

### Accéder à un élément contenu dans un formulaire


```js
var selectForm = document.forms[index];
var selectFormElement = document.forms[index].elements[index];
```

### Accéder aux formulaires nommés


```html
<!doctype html>
<html lang="en">
  <head>
    <title>document.forms example</title>
  </head>

  <body>
    <form name="login">
      <input name="email" type="email" />
      <input name="password" type="password" />
      <button type="submit">Log in</button>
    </form>

    <script>
 var loginForm = document.forms.login; // Ou document.forms['login']
 loginForm.elements.email.placeholder = "test@example.com";
 loginForm.elements.password.placeholder = "password";
 </script>
  </body>
</html>
```

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

| Specification |
| --- |
| HTML Standard # dom-document-forms-dev |

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

* Formulaires HTML
* `<form>` et l'interface `HTMLFormElement`
Document.anchors
================

**Obsolète:** Cette fonctionnalité a été supprimée des standards du Web. Bien que quelques navigateurs puissent encore la supporter, elle est en cours d'éradication. Ne l'utilisez ni dans d'anciens projets, ni dans de nouveaux. Les pages et applications Web l'utilisant peuvent cesser de fonctionner à tout moment.

`anchors` retourne une liste de toutes les ancres du document.

Syntaxe
-------


```js
nodeList = document.anchors;
```

Exemple
-------


```js
if (document.anchors.length >= 5) {
  dump("Trop d'ancres trouvées !");
  window.location = "http://www.google.com";
}
```


L'exemple suivant remplit un tableau avec chaque ancre présente sur la page :


```html
<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>Test</title>
    <script>
 function init() {
 var toc = document.getElementById("toc");
 var i, li, newAnchor;
 for (i = 0; i < document.anchors.length; i++) {
 li = document.createElement("li");
 newAnchor = document.createElement("a");
 newAnchor.href = "#" + document.anchors[i].name;
 newAnchor.innerHTML = document.anchors[i].text;
 li.appendChild(newAnchor);
 toc.appendChild(li);
 }
 }
 </script>
  </head>
  <body onload="init()">
    <h1>Title</h1>
    <h2><a name="contents">Contents</a></h2>
    <ul id="toc"></ul>

    <h2><a name="plants">Plants</a></h2>
    <ol>
      <li>Apples</li>
      <li>Oranges</li>
      <li>Pears</li>
    </ol>

    <h2><a name="veggies">Veggies</a></h2>
    <ol>
      <li>Carrots</li>
      <li>Celery</li>
      <li>Beats</li>
    </ol>
  </body>
</html>
```


Voir dans JSFiddle

Notes
-----

Pour des raisons de rétrocompatibilité, la liste d'ancres retournée contient seulement les ancres créées avec l'attribut `name`, pas celles créées avec l'attribut `id`.

Spécification
-------------

* DOM Level 2 HTML: anchors
Document.onafterscriptexecute
=============================

**Non standard:** Cette fonctionnalité n'est ni standard, ni en voie de standardisation. Ne l'utilisez pas pour des sites accessibles sur le Web : elle ne fonctionnera pas pour tout utilisateur. Il peut également y avoir d'importantes incompatibilités entre les implémentations et son comportement peut être modifié dans le futur.

Résumé
------

Lancé lorsqu'un élément `<script>` statique achève l'exécution de son script. N'est pas lancé si l'élément est ajouté dynamiquement, par exemple avec appendChild().

Syntaxe
-------


```js
document.onafterscriptexecute = funcRef;
```


*funcRef* est une référence de fonction appelée lorsqu'un évènement est lancé. L'attribut de la `target` (cible) d'évènement est défini sur l'`Element` script dont l'exécution vient de s'achever.

Exemple
-------


```js
function finished(e) {
  logMessage("Finished script with ID: " + e.target.id);
}

document.addEventListener("afterscriptexecute", finished, true);
```


Voir l'exemple sur une page

Spécification
-------------

* HTML5
Voir aussi
----------

* `Document.onbeforescriptexecute`
* `Document.currentScript`
document.compatMode
===================

Indique si le document est affiché en mode dégradé (Quirks mode) ou dans le respect des standards.

Syntaxe
-------


```js
mode = document.compatMode;
```

Valeurs
-------

* `"BackCompat"` si le document est a ffiché en mode "quirks" ;

mode

est une valeur énumérée qui peut être :

* `"CSS1Compat"` si le document est affiché en mode "no-quirks" (aussi connu sous le nom de mode "standard") ou "limited-quirks" (mo de "proche du standard").

**Note :** tous ces modes sont maintenant définis dans les normes, de sorte que les anciens «standards» et «presque standards» sont absurdes et ne sont plus utilisés dans les normes.

Exemple
-------


```js
if (document.compatMode == "BackCompat") {
  // en mode Quirks
}
```

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

* DOM: Document.compatMode
document.open
=============

La méthode **`document.open()`** ouvre un document pour l'écriture.

Syntaxe
-------


```js
document.open();
```

Exemple
-------


```js
// Dans cet exemple, le contenu du document est
// écrasé au cours de la réinitialisation avec open()
document.write("<html><p>supprimez-moi</p></html>");
document.open();
// Le document est vide.
```

Notes
-----

Si un document existe dans la cible, cette méthode le supprime (voir l'exemple ci-dessus).

Par ailleurs, un appel automatique à `document.open()` est réalisé lorsque document.write() est appelé après que la page ait été chargée, bien que ce ne soit pas défini dans la spécification du W3C. documenter les paramètres à document.open ne figurant pas dans la spécification

Cette méthode ne doit pas être confondue avec window.open(). `document.open` permet d'écrire par dessus le document courant ou d'y ajouter du contenu, alors que `window.open` fournit une manière d'ouvrir une nouvelle fenêtre laissant le document courant intact. Comme `window` est l'objet, si on appelle juste `open(...)`, il sera traité comme un appel à `window.open(...)`. Le document ouvert peut être fermé à l'aide de document.close() (en-US).

Voir Security check basics pour plus d'informations sur les principaux.

Si vous ne voulez pas créer une entrée d'historique, remplacez `open()` par `open("text/html", "replace")`.

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

| Specification |
| --- |
| HTML Standard # dom-document-open-dev |

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

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

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

* `Document`
* `Window.open()`
Document.alinkColor
===================

**Obsolète:** Cette fonctionnalité a été supprimée des standards du Web. Bien que quelques navigateurs puissent encore la supporter, elle est en cours d'éradication. Ne l'utilisez ni dans d'anciens projets, ni dans de nouveaux. Les pages et applications Web l'utilisant peuvent cesser de fonctionner à tout moment.

Retourne ou définit la couleur d'un lien actif dans le corps du document. Un lien hypertexte est actif durant le temps entre les événements `mousedown` et `mouseup`.

Syntaxe
-------


```js
var color = document.alinkColor;
document.alinkColor = color;
```


*color* est un echaîne de caractère contenant le nom de la couleur en anglais(exemple., `blue` pour bleu, `darkblue` pour bleu foncé, etc.) ou la valeur hexadécimal de la couleur (exemple, `#0000FF`)

Notes
-----

La valeur par défaut pour cette propriété est rouge (`#ee000` en hexadécimal) sur Mozilla Firefox.

`document.alinkColor` est obsolète dans DOM Level 2 HTML (lien en anglais). Une alternative est le sélecteur CSS `:active`.

Une autre alternative est `document.body.aLink`, même si elle est obsolète dans HTML 4.01 (lien en anglais) en faveur de l'alternative CSS ci-dessus.

Gecko supporte `alinkColor`/`:active` et `:focus`. Internet Explorer 6 et 7 supportent `alinkColor`/`:active` seulement pour la balise HTML des liens (`<a>`) et le comportement est le même que `:focus` sur Gecko. Il n'y a pas de support pour `:focus` dans IE.

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

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

La propriété en lecture seule **`Document.visibilityState`** renvoie la visibilité du `document`, c'est-à-dire informe si l'élément est visible dans son contexte. Il est utile de savoir si le document est en arrière-plan ou sur un onglet invisible ou seulement chargé pour le pré-rendu. Les valeurs possibles sont :

* **`'visible'`** : le contenu de la page peut être au-moins partiellement visible. Dans la pratique, cela signifie que la page est l'onglet de premier plan d'une fenêtre non réduite.
* **`'hidden`'** (*caché*) : le contenu de la page n'est pas visible pour l'utilisateur. Dans la pratique , cela signifie que le document est soit dans un onglet d'arrière-plan ou une partie d'une fenêtre réduite, soit que le verrouillage de l'écran du système d'exploitation est actif.
* **`'prerender'`** (*prérendu*) : le contenu de la page est prérendu et n'est pas visible par l'utilisateur (considéré caché aux fins de `document.hidden`). Le document peut démarrer dans cet état mais ne changera jamais à partir d'une autre valeur. Note : le support du navigateur est facultatif.
* **`'unloaded`'** (*déchargé*) : la page est en train d'être déchargée de la mémoire. Remarque : le support du navigateur est facultatif.

Lorsque la valeur de cette propriété change, l'évènement `visibilitychange` (en-US) est envoyé au `Document`.

L'utilisation typique de ceci peut être d'empêcher le téléchargement de certains éléments actifs lorsque le document est uniquement prérendu, ou d'arrêter certaines activités lorsque le document est en arrière-plan ou réduit au minimum.

Syntaxe
-------


```js
var string = document.visibilityState;
```

Exemples
--------


```js
document.addEventListener("visibilitychange", function () {
  console.log(document.visibilityState);
  // Modifier le comportement...
});
```

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

| Specification |
| --- |
| HTML Standard # dom-document-visibilitystate |

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

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

Retourne l'**`URL`** du `Document` sous forme de string (lecture seule).

Syntaxe
-------


```js
var string = document.URL;
```

Exemple
-------


```js
var currentURL = document.URL;
alert(currentURL);
```

Specification
-------------

* DOM Level 2 HTML: URL
Document.xmlEncoding
====================

**Obsolète:** Cette fonctionnalité a été supprimée des standards du Web. Bien que quelques navigateurs puissent encore la supporter, elle est en cours d'éradication. Ne l'utilisez ni dans d'anciens projets, ni dans de nouveaux. Les pages et applications Web l'utilisant peuvent cesser de fonctionner à tout moment.

Renvoie le codage déterminé par la déclaration XML. Devrait être `null` si non précisé ou inconnu.

**Attention :** N'utilisez pas cet attribut ; il a été supprimé de la spécification DOM Niveau 4 et n'est plus pris en charge dans Gecko 10.0.

Si la déclaration XML indique :


```xml
<?xml version="1.0" encoding="UTF-16"?>
```


... le résultat doit être "UTF-16".

Cependant, Firefox 3.0 inclut des informations sur l'"endianness" (par exemple, UTF-16BE pour le codage "big endian") et, tandis que cette information supplémentaire est supprimée à partir de Firefox 3.1b3, Firefox 3.1b3 consulte toujours l'encodage du fichier plutôt que la déclaration XML, comme la spécification le prévoit ("Un attribut spécifiant, *dans le cadre de la déclaration XML*, l'encodage de ce document.").

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

| Specification |
| --- |
| DOM Standard # dom-document-xmlencoding |
document.write
==============

Écrit une chaîne de texte dans un document ouvert par document.open().

**Note :** comme `document.write` écrit dans le flux de documents, appeler `document.write` sur un document fermé (chargé) appelle automatiquement `document.open`, ce qui efface le document.

Syntaxe
-------


```js
document.write(balisage);
```

### Paramètres

`markup`

est une chaîne de caractères contenant le texte à écrire dans le document.

### Exemple


```html
<html>
  <head>
    <title>Exemple de document.write</title>

    <script type="text/javascript">
 function nouveauContenu() {
 alert("chargement du nouveau contenu");
 document.open();
 document.write(
 "<h1>Assez de l'ancien contenu, passons au nouveau&nbsp;!</h1>",
 );
 document.close();
 }
 </script>
  </head>

  <body onload="nouveauContenu();">
    <p>Ceci est le contenu original du document.</p>
  </body>
</html>
```

Notes
-----

Écrire dans un document qui a déjà été chargé sans appeler document.open() provoquera un appel automatique à `document.open`. Une fois l'écriture terminée, il est recommandé d'appeler document.close() (en-US) pour indiquer au navigateur qu'il peut terminer de charger la page. Le texte fourni est analysé et intégré à la structure du modèle de document. Dans l'exemple ci-dessus, l'élément `h1` devient un nœud dans le document.

Si l'appel à `document.write()` est intégré directement dans le code HTML, il n'appellera pas `document.open()`. Par exemple :


```html
<script>
 document.write("<h1>Main title</h1>");
</script>
```


**Note :** `document.write` et `document.writeln` ne fonctionnent pas dans les documents XHTML (vous obtiendrez une erreur « Operation is not supported [`NS_ERROR_DOM_NOT_SUPPORTED_ERR`] » dans la console d'erreurs). Cela arrive lors de l'ouverture d'un fichier local avec l'extension de fichier `.xhtm` ou pour tout document servi avec une `application/xhtml+xml` de type MIME. Plus d'informations disponibles dans la foire aux questions W3C XHTML (en anglais).

**Note :** `document.write` dans les scripts deferred (*différé*) ou asynchronous (*asynchrone*) sera ignoré et vous recevrez un message comme "A call to `document.write()` from an asynchronously-loaded external script was ignored" dans la console d'erreurs.

**Note :** Dans Edge seulement, appeler plusieurs fois `document.write` dans un "iframe" déclenche une erreur "SCRIPT70: Permission denied." *(autorisation refusée)*.

**Note :** À partir de la version 55, Chrome n'exécute pas les éléments `<script>` injectés via `document.write()` en cas d'échec de cache HTTP pour les utilisateurs sur une connexion 2G.

Spécification
-------------

* DOM Level 2 HTML: `write()` Method
* Dynamic markup insertion in HTML
Voir aussi
----------

* `element.innerHTML`
* `document.createElement()`
Introduction à WebRTC
=====================

**Note :** WebRTC vous permet de faire de la communication pair-à-pair dans une application du navigateur.

Etablir la connexion
--------------------

La connexion initiale entre les pairs doit être accomplie par un service d'application qui se charge de la découverte des utilisateurs, communication, translation d'adresse réseau (NAT) avec les flux de données.

### Signalisation

La signalisation est le mécanisme par lequel les pairs envoient des messages de contrôle à chacun dans le but d'établir le protocole de communication, le canal et la méthode. Ceux-ci ne sont pas spécifiés dans le standard WebRTC. En fait, le dévelopeur peut choisir n'importe quel protocole de message (comme SIP ou XMPP), et n'importe quel canal de communication duplex (comme WebSocket ou XMLHttpRequest) en tandem avec une API de connexion persistante à un serveur (comme l'API Google Channel) pour AppEngine.

Transmission
------------

### getUserMedia

Objet LocalMediaStream

Reception
---------

Le support WebRTC dans Firefox est caché derrière une préférence. Allez à about:config et positionnez 'media.navigator.enabled' à 'true'.

**Note :** Il y a des fichiers de tests dans les sources pour vous donner une idée sur ce qui fonctionne. Voir: dom/media/tests/local\_video\_test.html. Essayez aussi la demo de service d'appel, sa page source, et son serveur source.