recursal/MDN huggingface dataset:
performance.setResourceTimingBufferSize()
=========================================

La méthode **`setResourceTimingBufferSize()`** définit la taille du tampon mémoire du navigateur dans lequel sont stockés les objets de mesures de performance de type `"resource"` (voir `entryType`).

La taille recommandée du tampon de synchronisation des ressources d'un navigateur est au moins 150 objets ``PerformanceEntry``.

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

Syntaxe
-------


```js
performance.setResourceTimingBufferSize(maxSize);
```

### Arguments

`maxSize`

Un nombre (cf. `Number`) représentant le nombre maximal d'objets d'entrée de performance avec le type `"resource"` que le navigateur doit contenir dans le tampon correspondant.

### Valeur de retour

Aucune.

Exemple
-------


```js
function setResourceTimingBufferSize(maxSize) {
  if (performance === undefined) {
    log("Le navigateur ne prend pas en charge les performances Web");
    return;
  }
  var supported = typeof performance.setResourceTimingBufferSize == "function";
  if (supported) {
    log("... Performance.setResourceTimingBufferSize() = Oui");
    performance.setResourceTimingBufferSize(maxSize);
  } else {
    log("... Performance.setResourceTimingBufferSize() = NON pris en charge");
  }
}
```

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

| Specification |
| --- |
| Resource Timing # dom-performance-setresourcetimingbuffersize |

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

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

La méthode **`getEntriesByName()`** renvoie une liste de tous les objets `PerformanceEntry` ayant un nom (et éventuellement un type) donné(s). Les entrées de performance auront pu être créées au préalable avec des *marqueurs* ou des *mesures* de performance (par exemple en appelant la méthode `mark()`) à des moments explicites.

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

Syntaxe
-------


```js
entries = window.performance.getEntriesByName(name, type);
```

### Arguments

`name`

Le nom de l'entrée à récupérer.

`type` Facultatif

Le type d'entrée à récupérer tel que « `mark` ». Les types d'entrées valides sont listés dans `PerformanceEntry.entryType`.

### Valeur de retour

`entries`

Une liste de tous les objets `PerformanceEntry` ayant le nom et le type spécifiés. Si l'argument `type` n'est pas spécifié, seul le nom (`name`) sera utilisé pour déterminer les entrées à renvoyer. Les éléments seront dans l'ordre chronologique basé sur les `startTime` des entrées. Si aucun objet ne répond aux critères spécifiés, une liste vide est retournée.

Exemple
-------


```js
function use\_PerformanceEntry\_methods() {
  log("PerformanceEntry tests ...");

  if (performance.mark === undefined) {
    log("... performance.mark Non pris en charge");
    return;
  }

  // Crée quelques entrées de performance via la méthode mark()
  performance.mark("Begin");
  do\_work(50000);
  performance.mark("End");
  performance.mark("Begin");
  do\_work(100000);
  performance.mark("End");
  do\_work(200000);
  performance.mark("End");

  // Utilise getEntries() pour itérer à travers chaque entrée
  var p = performance.getEntries();
  for (var i = 0; i < p.length; i++) {
    log("Entry[" + i + "]");
    check\_PerformanceEntry(p[i]);
  }

  // Utilise getEntries(name, entryType) pour obtenir des entrées spécifiques
  p = performance.getEntries({ name: "Begin", entryType: "mark" });
  for (var i = 0; i < p.length; i++) {
    log("Begin[" + i + "]");
    check\_PerformanceEntry(p[i]);
  }

  // Utilise getEntriesByType() pour obtenir toutes les entrées "mark"
  p = performance.getEntriesByType("mark");
  for (var i = 0; i < p.length; i++) {
    log(
      "Mark only entry[" +
        i +
        "]: name = " +
        p[i].name +
        "; startTime = " +
        p[i].startTime +
        "; duration = " +
        p[i].duration,
    );
  }

  // Utilisez getEntriesByName() pour obtenir toutes les entrées "mark" nommées "Begin"
  p = performance.getEntriesByName("Begin", "mark");
  for (var i = 0; i < p.length; i++) {
    log(
      "Mark and Begin entry[" +
        i +
        "]: name = " +
        p[i].name +
        "; startTime = " +
        p[i].startTime +
        "; duration = " +
        p[i].duration,
    );
  }
}
```

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

| Specification |
| --- |
| Performance Timeline # dom-performance-getentriesbyname |

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

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

La méthode **`measure()`** crée un `timestamp` nommé dans le *tampon d'entrée de performance* du navigateur entre deux marqueurs, l'heure de début de navigation ou l'heure actuelle. Lors d'une mesure entre deux marqueurs, on aura un *marqueur de début* et un *marqueur de fin*. L'horodatage ainsi nommé est désigné comme une *mesure*.

La mesure correspondante peut être récupérée par l'une des méthodes suivantes de l'interface `Performance` : `getEntries()`, `getEntriesByName()` ou `getEntriesByType()`.

L'entrée de performance créée par `measure()` aura les valeurs de propriété suivantes :

* `entryType` : `"measure"`.
* `name` : le nom passé en argument lors de la création de la mesure (cf. ci-après).
* `startTime` : fixé selon le marqueur de départ (type `DOMHighResTimeStamp`).
* `duration` : fixé à un `DOMHighResTimeStamp` qui correspond à la durée de la mesure (généralement, l'horodatage du marqueur de fin moins l'horodatage du marqueur de début).

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

Syntaxe
-------


```js
performance.measure(name);
performance.measure(name, startMark);
performance.measure(name, startMark, endMark);
performance.measure(name, undefined, endMark);
```

### Arguments

`name`

Une `DOMString` représentant le nom de la mesure.

`startMark` Facultatif

Une `DOMString` représentant le nom du marqueur de départ de la mesure. Peut également être le nom d'une propriété `PerformanceTiming`. Si elle est omise, l'heure de début sera celle de la navigation.

`endMark` Facultatif

Une `DOMString` représentant le nom du marqueur de fin de la mesure. Peut également être le nom d'une propriété `PerformanceTiming`. Si elle est omise, le temps actuel est utilisé.

### Valeur de retour

Aucune

Exemple
-------

L'exemple suivant montre comment `measure()` est utilisé pour créer une nouvelle *mesure* d'entrée de performance dans le tampon d'entrée de performance du navigateur.


```js
const markerNameA = "example-marker-a";
const markerNameB = "example-marker-b";

// Exécute des temporisations imbriquées et crée un PerformanceMark pour chacune d'entre elles.
performance.mark(markerNameA);
setTimeout(function () {
  performance.mark(markerNameB);
  setTimeout(function () {
    // Crée une variété de mesures.
    performance.measure("mesure a à b", markerNameA, markerNameB);
    performance.measure("mesure a à maintenant", markerNameA);
    performance.measure(
      "mesure du début de la navigation à b",
      undefined,
      markerNameB,
    );
    performance.measure("mesure du début de la navigation à maintenant");

    // Sort toutes les mesures.
    console.log(performance.getEntriesByType("measure"));

    // Enfin, nettoye les entrées.
    performance.clearMarks();
    performance.clearMeasures();
  }, 1000);
}, 1000);
```

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

| Specification |
| --- |
| User Timing # dom-performance-measure |

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

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

La méthode **`Geolocation.watchPosition()`** permet de manipuler une fonction appelée automatiquement à chaque fois que la position de l'appareil change. Vous pouvez de même, en option, manipuler une autre fonction appelée automatiquement pour gérer les erreurs.

Cette méthode retourne une valeur ID de veille qui permet de libérer les fonctions déclarées automatiquement, évoquées précédemment, à l'aide de la méthode `Geolocation.clearWatch()`.

Syntaxe
-------


```js
watchPosition(success)
watchPosition(success, error)
watchPosition(success, error, options)
```

### Paramètres

*success*

Nom d'une fonction appelée qui a pour paramètre l'objet `Position` (en-US).

*error* Facultatif

Nom d'une fonction optionnelle qui a pour paramètre l'objet `PositionError` (en-US).

*options* Facultatif

Un objet optionnel `PositionOptions`.

Exemple
-------


```js
var id, target, options;

function success(pos) {
  var crd = pos.coords;

  if (target.latitude === crd.latitude && target.longitude === crd.longitude) {
    console.log("Bravo, vous avez atteint la cible");
    navigator.geolocation.clearWatch(id);
  }
}

function error(err) {
  console.warn("ERROR(" + err.code + "): " + err.message);
}

target = {
  latitude: 0,
  longitude: 0,
};

options = {
  enableHighAccuracy: false,
  timeout: 5000,
  maximumAge: 0,
};

id = navigator.geolocation.watchPosition(success, error, options);
```


**Note :** Si votre application fonctionne sous Firefox OS, veillez à la geolocation wake lock pour que votre application continue à recevoir les changements de positions si votre application tourne en tâche de fond, ou si votre écran est éteint.

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

| Specification |
| --- |
| Geolocation API # watchposition-method |

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

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

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

* geolocation wake lock
* Utiliser geolocation (en-US)
* L'interface qui lui est réservée, `Geolocation`, et la façon d'y accéder `NavigatorGeolocation.geolocation` (en-US).
* L'opération inverse : `Geolocation.clearWatch()`
* Une méthode similaire : `Geolocation.getCurrentPosition()`
Geolocation.clearWatch()
========================

La méthode **`Geolocation.clearWatch()`** est utilisée pour libérer les ressources de localisation/erreur créées antérieurement en utilisant `Geolocation.watchPosition()`.

Syntaxe
-------


```js
navigator.geolocation.clearWatch(id);
```

### Paramètres

*id*

Le nombre ID est donné par la méthode qui permet la localisation : `Geolocation.watchPosition()` ; ressource que vous désirez supprimer.

Exemple
-------


```js
var id, target, option;

function success(pos) {
  var crd = pos.coords;

  if (target.latitude === crd.latitude && target.longitude === crd.longitude) {
    console.log("Congratulation, you reach the target");
    navigator.geolocation.clearWatch(id);
  }
}

function error(err) {
  console.warn("ERROR(" + err.code + "): " + err.message);
}

target = {
  latitude: 0,
  longitude: 0,
};

options = {
  enableHighAccuracy: false,
  timeout: 5000,
  maximumAge: 0,
};

id = navigator.geolocation.watchPosition(success, error, options);
```

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

| Specification |
| --- |
| Geolocation API # clearwatch-method |

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

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

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

* Utiliser geolocation
* `Geolocation`
* `Geolocation.watchPosition()`
* `Geolocation.getCurrentPosition()`
Geolocation.getCurrentPosition()
================================

**Contexte sécurisé:** Cette fonctionnalité est uniquement disponible dans des contextes sécurisés (HTTPS), pour certains navigateurs qui la prennent en charge.

La méthode **`Geolocation.getCurrentPosition()`** fournit la position actuelle de l'appareil.

Syntaxe
-------


```js
navigator.geolocation.getCurrentPosition(success[, error[, [options]])
```

### Paramètres

`success`

Une fonction de rappel qui prend un objet `Position` (en-US) comme argument.

`error` Facultatif

Une fonction de rappel qui prend un objet `PositionError` (en-US) comme argument.

`options` Facultatif

Un objet `PositionOptions` optionnel. Les options décrites par cet objet sont :

* `maximumAge` : un entier qui exprime une durée en millisecondes ou l'infini pour indiquer la durée maximale pendant laquelle mettre en cache la position.
* `timeout` : un entier qui exprime la durée, en millisecondes, avant que la fonction de rappel `error` soit appelé. Si cette propriété vaut `0`, la fonction d'erreur ne sera jamais appelée.
* `enableHighAccuracy` : un booléen qui indique si une précision élevée est requise.

Exemples
--------


```js
var options = {
  enableHighAccuracy: true,
  timeout: 5000,
  maximumAge: 0,
};

function success(pos) {
  var crd = pos.coords;

  console.log("Votre position actuelle est :");
  console.log(`Latitude : ${crd.latitude}`);
  console.log(`Longitude : ${crd.longitude}`);
  console.log(`La précision est de ${crd.accuracy} mètres.`);
}

function error(err) {
  console.warn(`ERREUR (${err.code}): ${err.message}`);
}

navigator.geolocation.getCurrentPosition(success, error, options);
```

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

| Specification |
| --- |
| Geolocation API # getcurrentposition-method |

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

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

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

* Utiliser la géolocalisation (en-US)
* `Navigator.geolocation`
AnimationEvent()
================

Le constructeur **`AnimationEvent()`** renvoie un nouvel objet `AnimationEvent`, qui représente un évènement relatif à une animation.

Syntaxe
-------


```js
new AnimationEvent(type);
new AnimationEvent(type, options);
```

### Paramètres

`type`

Une chaîne représentant le nom du type de l'objet `AnimationEvent`, sensible à la casse. Les valeurs possibles sont `animationstart`, `animationend` ou `animationiteration`.

`options` Facultatif

Un objet qui, *en plus des propriétés définies par le constructeur `Event()`*, contient les propriétés suivantes :

`animationName` Facultatif

Une chaîne contenant la valeur de la propriété CSS `animation-name` associée à la transition. La valeur par défaut est `""`.

`elapsedTime` Facultatif

Un nombre à virgule flottante, équivalent à la durée pendant laquelle l'animation s'est déroulée, en secondes, depuis le déclenchement de cet évènement (excluant les temps de pause de l'animation). `elapsedTime` vaudra `0.0` pour un évènement `animationstart`, à moins que `animation-delay` n'ait une valeur négative. Dans ce cas, l'évènement sera déclenché avec une valeur de `(-1 * délai)` pour `elapsedTime`. La valeur par défaut est `0.0`.

`pseudoElement` Facultatif

Une chaîne commençant par `::`, qui contient le nom du pseudo-élément sur lequel l'animation s'exécute. Si l'animation est exécutée sur l'élément et non sur un pseudo-élément, la chaîne sera vide (`""`). La valeur par défaut est `""` (chaîne vide).


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

| Specification |
| --- |
| CSS Animations Level 1 # dom-animationevent-animationevent |

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

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

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

* Utiliser les animations CSS
* Les propriétés CSS et règles @ relatives aux animations :
    + `animation`
    + `animation-delay`
    + `animation-direction`
    + `animation-duration`
    + `animation-fill-mode`
    + `animation-iteration-count`
    + `animation-name`
    + `animation-play-state`
    + `animation-timing-function`
    + `@keyframes`
* L'interface qui porte ce constructeur, `AnimationEvent`
AnimationEvent.pseudoElement
============================

**Expérimental:** **Cette fonction est expérimentale**  
Puisque cette fonction est toujours en développement dans certains navigateurs, veuillez consulter le tableau de compatibilité pour les préfixes à utiliser selon les navigateurs.  
Il convient de noter qu'une fonctionnalité expérimentale peut voir sa syntaxe ou son comportement modifié dans le futur en fonction des évolutions de la spécification.

La propriété en lecture seule **`AnimationEvent.pseudoElement`** est une `DOMString`, commençant par `'::'`, contenant le nom du pseudo-élément sur lequel tourne l'animation. Si l'animation ne tourne pas sur un pseudo-élément, mais sur un élément, c'est une chaîne de caractère vide : `''`.

Syntaxe
-------


```js
nom = AnimationEvent.pseudoElement;
```

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

| Specification |
| --- |
| CSS Animations Level 1 # dom-animationevent-pseudoelement |

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

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

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

* Utiliser les animations CSS
* Propriétés et règles @ en relation avec les animations CSS : `animation`, `animation-delay`, `animation-direction`, `animation-duration`, `animation-fill-mode`, `animation-iteration-count`, `animation-name`, `animation-play-state`, `animation-timing-function`, `@keyframes`.
* L'interface `AnimationEvent` à laquelle elle est rattachée.
AnimationEvent.elapsedTime
==========================

**Expérimental:** **Cette fonction est expérimentale**  
Puisque cette fonction est toujours en développement dans certains navigateurs, veuillez consulter le tableau de compatibilité pour les préfixes à utiliser selon les navigateurs.  
Il convient de noter qu'une fonctionnalité expérimentale peut voir sa syntaxe ou son comportement modifié dans le futur en fonction des évolutions de la spécification.

Résumé
------

La propriété en lecture seule **`AnimationEvent.elapsedTime`** est un `float` indiquant la quantité de temps pendant laquelle l'animation a tourné, en secondes, quand l'évènement a été déclenché, excluant tout temps où l'animation était en pause. Pour un évènement `animationstart`, `elapsedTime` est `0.0` sauf si `animation-delay` a une valeur négative, dans ce cas l'évènement est déclenché avec `elapsedTime` contenant `(-1 * délai)`.

Syntaxe
-------


```js
temps = AnimationEvent.elapsedTime;
```

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

| Specification |
| --- |
| CSS Animations Level 1 # dom-animationevent-elapsedtime |

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

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

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

* Utiliser les animations CSS
* Propriétés CSS et règles @ en relations avec les animations CSS: `animation`, `animation-delay`, `animation-direction`, `animation-duration`, `animation-fill-mode`, `animation-iteration-count`, `animation-name`, `animation-play-state`, `animation-timing-function`, `@keyframes`.
* L'interface `AnimationEvent` à laquelle elle appartient.
AnimationEvent.animationName
============================

**Expérimental:** **Cette fonction est expérimentale**  
Puisque cette fonction est toujours en développement dans certains navigateurs, veuillez consulter le tableau de compatibilité pour les préfixes à utiliser selon les navigateurs.  
Il convient de noter qu'une fonctionnalité expérimentale peut voir sa syntaxe ou son comportement modifié dans le futur en fonction des évolutions de la spécification.

La propriété en lecture seule **`AnimationEvent.animationName`** est une `DOMString` contenant la valeur de la propriété CSS `animation-name` associée à la transition.

Syntaxe
-------


```js
nom = AnimationEvent.animationName;
```

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

| Specification |
| --- |
| CSS Animations Level 1 # dom-animationevent-animationname |

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

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

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

* Utiliser les animations CSS
* `animation`, `animation-delay`, `animation-direction`, `animation-duration`, `animation-fill-mode`, `animation-iteration-count`, `animation-name`, `animation-play-state`, `animation-timing-function`, `@keyframes`.
* L'interface `AnimationEvent` à laquelle elle appartient.
element.dispatchEvent
=====================

Envoie un `Event` (*évènement*) à la `EventTarget` (*cible*) spécifiée (synchrone) en appelant les `EventListener` (*écouteurs*) dans l'ordre approprié. Le processus normal de traitement de l'évènement (y compris les phases de capture et l'éventuelle propagation) s'applique aussi aux évènements diffusés manuellement avec `dispatchEvent()`.

Syntaxe
-------


```js
cancelled = !target.dispatchEvent(event);
```

### Paramètres

* `event` est un objet `Event` à envoyer.
* `target` (*cible*) est utilisée pour initialiser la `Event.target` et déterminer quels écouteurs d'évènements doivent être invoqués.
### Valeur retournée

* La valeur de retour est `false` (*faux*) si l'évènement est annulable et au moins l'un des gestionnaires d'événements qui ont géré cet événement appelé `Event.preventDefault ()`. Sinon, elle est `true` (*vrai*).

La méthode `dispatchEvent` lance une exception `UNSPECIFIED_EVENT_TYPE_ERR` si le type de l'évènement n'a pas été spécifié par son initialisation avant l'appel de la méthode ou s'il est `null` ou une chaîne vide. Les exceptions lancées par les gestionnaires d'évènements sont signalées comme exceptions non interceptées ; les gestionnaires d'événements s'exécutent sur une pile d'appels imbriquée : ils bloquent l'appelant jusqu'à ce qu'ils se terminent, mais les exceptions ne se propagent pas à l'appelant.

Notes
-----

Contrairement aux événements "natifs", qui sont déclenchés par le DOM et invoquent les gestionnaires d'événements de manière asynchrone via la boucle des événements, `dispatchEvent` appelle les gestionnaires d'événements de manière synchrone. Tous les gestionnaires d'événements applicables s'exécuteront et retourneront avant que le code ne continue après l'appel à `dispatchEvent`.

Comme montré dans l'exemple qui précède, `dispatchEvent` est la dernière étape du processus création-initialisation-envoi, qui est utilisé pour envoyer des évènements dans le modèle de l'implémentation des évènements. Ceux-ci peuvent être créés en utilisant le constructeur d'évènements.

Voir aussi Objet Event référence.

Exemple
-------

Voir Création et déclenchement d'évènements.

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

| Specification |
| --- |
| DOM Standard # ref-for-dom-eventtarget-dispatchevent③ |

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

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

Le constructeur **`EventTarget()`** crée une nouvelle instance d'objet `EventTarget`.

Syntaxe
-------


```js
var myEventTarget = new EventTarget();
```

### Paramètres

Aucun.

### Valeur retournée

Une instance d'objet `EventTarget`.

Exemples
--------


```js
class MyEventTarget extends EventTarget {
  constructor(mySecret) {
    super();
    this._secret = mySecret;
  }

  get secret() {
    return this._secret;
  }
}

let myEventTarget = new MyEventTarget(5);
let value = myEventTarget.secret; // == 5
myEventTarget.addEventListener("foo", function (e) {
  this._secret = e.detail;
});

let event = new CustomEvent("foo", { detail: 7 });
myEventTarget.dispatchEvent(event);
let newValue = myEventTarget.secret; // == 7
```

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

| Specification |
| --- |
| DOM Standard # ref-for-dom-eventtarget-eventtarget① |

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

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

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

* `EventTarget`