recursal/MDN huggingface dataset:
PerformanceObserverEntryList.getEntriesByName()
===============================================

La méthode **`getEntriesByName()`** de l'interface `PerformanceObserverEntryList` retourne une liste d'objets d'entrée de performance explicitement *observés* pour un *`name`* et *`entryType`* donnés. Les membres de la liste sont déterminés par l'ensemble des types d'entrées spécifiés dans l'appel à la méthode `observe()`. La liste est disponible dans la fonction de rappel de l'observateur (en tant que premier paramètre de la fonction de rappel).

**Note :** Cette interface est exposée à `Window` et `Worker`.

Syntaxe
-------


```js
let entries = list.getEntriesByName(name, type);
```

### Paramètres

*`name`*

Une chaîne de caractères `DOMString` représentant le nom de l'entrée à récupérer.

*`type`* Facultatif

Une chaîne de caractères `DOMString` représentant le type d'entrée à récupérer tel que « `mark` ». Les types d'entrée valides sont énumérés dans `PerformanceEntry.entryType`.

### Valeur de retour

Une liste d'objets d'entrée de performance explicitement *observés* qui ont le `name` et le `type` spécifiés. Si l'argument `type` n'est pas spécifié, seul `name` sera utilisé pour déterminer les entrées à retourner. Les éléments seront triés dans l'ordre chronologique selon 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 print\_perf\_entry(pe) {
  console.log(
    "name: " +
      pe.name +
      "; entryType: " +
      pe.entryType +
      "; startTime: " +
      pe.startTime +
      "; duration: " +
      pe.duration,
  );
}

// Crée un observateur pour tous les types d'événements de performance
const observe_all = new PerformanceObserver(function (list, obs) {
  let perfEntries;

  // Imprime toutes les entrées
  perfEntries = list.getEntries();
  for (let i = 0; i < perfEntries.length; i++) {
    print\_perf\_entry(perfEntries[i]);
  }

  // Imprime les entrées nommées "Begin" avec le type "mark".
  perfEntries = list.getEntriesByName("Begin", "mark");
  for (let i = 0; i < perfEntries.length; i++) {
    print\_perf\_entry(perfEntries[i]);
  }

  // Imprime les entrées de type "mark".
  perfEntries = list.getEntriesByType("mark");
  for (let i = 0; i < perfEntries.length; i++) {
    print\_perf\_entry(perfEntries[i]);
  }
});
// inscrire tous les types d'événements de performance
observe_all.observe({
  entryTypes: ["frame", "mark", "measure", "navigation", "resource", "server"],
});

const observe_frame = new PerformanceObserver(function (list, obs) {
  let perfEntries = list.getEntries();
  // Ne devrait avoir que des entrées "frame"
  for (let i = 0; i < perfEntries.length; i++) {
    print\_perf\_entry(perfEntries[i]);
  }
});
// inscrire à l'événement "frame" uniquement
observe_frame.observe({ entryTypes: ["frame"] });
```

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

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

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

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

La méthode **`toJSON()`** de l'interface `Performance` est un sérialiseur standard : elle renvoie une représentation JSON des propriétés de l'objet performance.

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

Syntaxe
-------


```js
myPerf = performance.toJSON();
```

### Arguments

Aucun

### Valeur de retour

`myPerf`

Un objet JSON qui est la sérialisation de l'objet `Performance`.

Exemple
-------


```js
var js;
js = window.performance.toJSON();
console.log("json = " + JSON.stringify(js));
```

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

| Specification |
| --- |
| High Resolution Time # dom-performance-tojson |

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

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

**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.

Syntaxe
-------


```js
timingInfo = performance.memory;
```

Attributs
---------

`jsHeapSizeLimit`

La taille maximale du tas, en octets, qui est disponible pour le contexte.

`totalJSHeapSize`

La taille totale du répertoire alloué, en octets.

usedJSHeapSize

Le segment actuellement actif du répertoire JS, en octets.

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

Aucune

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

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

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

* L'interface `Performance` à laquelle il appartient.
Performance.navigation
======================

**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.

L'ancienne propriété **`Performance.navigation`** en lecture seule renvoie un objet `PerformanceNavigation` représentant le type de navigation qui se produit dans le contexte de navigation donné, comme le nombre de redirections nécessaires pour aller chercher la ressource.

Cette propriété n'est pas disponible pour les *workers*.

**Attention :** Cette propriété est dépréciée dans la spécification de mesure des durées de navigation (*Navigation Timing*). Veuillez utiliser l'interface `PerformanceNavigationTiming` à la place.

Valeur
------

Un objet `PerformanceNavigation`.

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

Cette fonctionnalité n'est plus en voie de standardisation, car elle est indiquée comme dépréciée dans la spécification de mesure des durées de navigation (*Navigation Timing*). Utilisez à la place l'interface `PerformanceNavigationTiming`.

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

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

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

* L'interface qui porte cette propriété, `Performance`.
performance.mark()
==================

La méthode **`mark()`** crée un `timestamp` dans le *tampon d'entrée de performance* du navigateur avec le nom donné en argument.

L'horodatage ainsi défini par l'application peut être récupéré par l'une des méthodes `getEntries*()` de l'interface `Performance` (`getEntries()`, `getEntriesByName()` ou `getEntriesByType()`).

La méthode `mark()` stocke ses données en interne sous la forme d'objets `PerformanceEntry`.

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

Syntaxe
-------


```js
performance.mark(name);
```

### Arguments

`name`

Une chaîne de caractères (`DOMString`) représentant le nom du marqueur. Si le nom donné à cette méthode existe déjà dans l'interface `PerformanceTiming`, une exception `SyntaxError` est levée.

### Valeur de retour

Aucune.

>

Exemple
-------

L'exemple suivant montre comment utiliser `mark()` pour créer et récupérer des entrées `PerformanceMark`.


```js
// Crée un ensemble de marqueurs.
performance.mark("squirrel");
performance.mark("squirrel");
performance.mark("monkey");
performance.mark("monkey");
performance.mark("dog");
performance.mark("dog");

// Obtient toutes les entrées de PerformanceMark.
const allEntries = performance.getEntriesByType("mark");
console.log(allEntries.length);
// 6

// Obtient toutes les entrées "monkey" de PerformanceMark.
const monkeyEntries = performance.getEntriesByName("monkey");
console.log(monkeyEntries.length);
// 2

// Efface tous les marqueurs.
performance.clearMarks();
```

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

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

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
Performance : Événement resourcetimingbufferfull
================================================

L'événement `resourcetimingbufferfull` se déclenche lorsque la mémoire tampon de synchronisation des ressources du navigateur est pleine.

|  |  |
| --- | --- |
| Propagation | Oui |
| Annulable | Oui |
| Interface | `Event` |
| Propriété pour le gestionnaire d'événements correspondant | `onresourcetimingbufferfull` |

Exemples
--------

L'exemple suivant définit une fonction de rappel sur la propriété `onresourcetimingbufferfull`.


```js
function buffer\_full(event) {
  console.log("AVERTISSEMENT : La mémoire tampon des ressources est COMPLÈTE !");
  performance.setResourceTimingBufferSize(200);
}
function init() {
  // Définit un rappel si le tampon de ressources est rempli.
  performance.onresourcetimingbufferfull = buffer_full;
}
<body onload="init()">
```


Notez que vous pouvez également configurer le gestionnaire à l'aide de la fonction addEventListener() :


```js
performance.addEventListener("resourcetimingbufferfull", buffer_full);
```

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

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

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

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

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

* `Performance.clearResourceTimings()`
* `Performance.setResourceTimingBufferSize()`
performance.clearMarks()
========================

La méthode **`clearMarks()`** supprime les *marqueurs nommés* du tampon d'entrée des performances du navigateur. Si la méthode est appelée sans arguments, toutes les entrées de performance avec un `entryType` de « `mark` » seront supprimées du tampon d'entrée de performance.

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

Syntaxe
-------


```js
performance.clearMarks();
performance.clearMarks(name);
```

### Arguments

name Facultatif

Un `DOMString` représentant le nom de l'horodatage. Si cet argument est omis, toutes les entrées de performance avec un `entryType` de « `mark` » seront supprimés.

### Valeur de retour

Aucune.

Exemple
-------

L'exemple suivant montre les deux utilisations de la méthode `clearMarks()`.


```js
// Créé une petite aide pour montrer combien d'entrées PerformanceMark il y a.
function logMarkCount() {
  console.log(
    "J'ai trouvé autant d'entrées : " +
      performance.getEntriesByType("mark").length,
  );
}

// Crée une série de marqueurs.
performance.mark("squirrel");
performance.mark("squirrel");
performance.mark("monkey");
performance.mark("monkey");
performance.mark("dog");
performance.mark("dog");

logMarkCount(); // "J'ai trouvé autant d'entrées : 6"

// Supprime seulement les entrées "squirrel" de PerformanceMark.
performance.clearMarks("squirrel");
logMarkCount(); // "J'ai trouvé autant d'entrées : 4"

// Supprime toutes les entrées de PerformanceMark.
performance.clearMarks();
logMarkCount(); // "J'ai trouvé autant d'entrées : 0"
```

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

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

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

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

**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 **`timeOrigin`** de l'interface `Performance` renvoie l'horodatage haute résolution de l'heure de début de la mesure de performance.

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

Syntaxe
-------


```js
var timeOrigin = performance.timeOrigin;
```

### Valeur

Un horodatage haute résolution (voir le type `DOMHighResTimeStamp`).

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

| Specification |
| --- |
| High Resolution Time # dom-performance-timeorigin |

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

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

La méthode **`clearResourceTimings()`** supprime toutes les entrées de performance avec un `entryType` de « `resource` » du tampon d'entrée de performance et fixe la taille du tampon de données de performance à zéro. Pour définir la taille du tampon de données de performance du navigateur, utilisez la méthode `Performance.setResourceTimingBufferSize()`.

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

Syntaxe
-------


```js
performance.clearResourceTimings();
```

### Arguments

Aucun.

### Valeur de retour

Aucune.

Exemple
-------


```js
function load\_resource() {
  var image = new Image();
  image.src = "https://developer.mozilla.org/mdn-social-share.png";
}
function clear\_performance\_timings() {
  if (performance === undefined) {
    log("Le navigateur ne prend pas en charge les performances Web");
    return;
  }
  // Crée une entrée de performance de synchronisation des ressources en chargeant une image
  load\_resource();

  var supported = typeof performance.clearResourceTimings == "function";
  if (supported) {
    console.log("Exécuter : performance.clearResourceTimings()");
    performance.clearResourceTimings();
  } else {
    console.log("performance.clearResourceTimings() N'EST PAS supporté");
    return;
  }
  // getEntries devrait maintenant retourner zéro
  var p = performance.getEntriesByType("resource");
  if (p.length == 0)
    console.log("... Le tampon de données de performance a été effacé");
  else
    console.log("... Le tampon de données de performance n'a PAS été effacé !");
}
```

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

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

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

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

**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.

L'ancienne propriété **`Performance.timing`** en lecture seule renvoie un objet `PerformanceTiming` contenant des informations de performance liées à la latence.

Cette propriété n'est pas disponible pour les *workers*.

**Attention :** Cette propriété est dépréciée dans la spécification de mesure des durées de navigation (*Navigation Timing*). Veuillez utiliser l'interface `PerformanceNavigationTiming` à la place.

Valeur
------

Un objet `PerformanceTiming`.

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

Cette fonctionnalité n'est plus en voie de standardisation, car elle est indiquée comme dépréciée dans la spécification de mesure des durées de navigation (*Navigation Timing*). Utilisez à la place l'interface `PerformanceNavigationTiming`.

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

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

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

* L'interface qui porte cette propriété, `Performance`.
performance.getEntries()
========================

La méthode **`getEntries()`** renvoie une liste de tous les objets `PerformanceEntry` pour la page. Les membres de la liste (*entrées*) peuvent être créés en faisant des *marqueurs* ou des *mesures* de performance (par exemple en appelant la méthode `mark()`) à des moments explicites. Si vous souhaitez filtrer les entrées de performance en fonction de leur type ou de leur nom, consultez la documentation des méthodes `getEntriesByType()` et `getEntriesByName()`.

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

Syntaxe
-------


```js
entries = window.performance.getEntries();
```

### Valeur de retour

`entries`

Un tableau (`Array`) d'objets `PerformanceEntry`. Les éléments seront classés par ordre chronologique en fonction des entrées `startTime`.

Exemple
-------


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

  if (performance.mark === undefined) {
    console.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.
  let p = performance.getEntries();
  for (var i = 0; i < p.length; i++) {
    console.log("Entry[" + i + "]");
    check\_PerformanceEntry(p[i]);
  }

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

  // Utilise getEntriesByName() pour obtenir toutes les entrées "mark" nommées "Begin".
  p = performance.getEntriesByName("Begin", "mark");
  for (let i = 0; i < p.length; i++) {
    console.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-getentries |

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

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

La méthode **`clearMeasures()`** supprime les *mesures nommées* du tampon d'entrée des performances du navigateur. Si la méthode est appelée sans arguments, toutes les entrées de performance avec un `entryType` de « `measure` » seront supprimées du tampon d'entrée de performance.

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

Syntaxe
-------


```js
performance.clearMeasures();
performance.clearMeasures(name);
```

### Arguments

name Facultatif

Un `DOMString` représentant le nom de l'horodatage. Si cet argument est omis, toutes les entrées de performance avec un `entrType` de « `measure` » seront supprimés.

### Valeur de retour

Aucune.

Exemple
-------

L'exemple suivant montre les deux utilisations de la méthode `clearMeasures()`.


```js
// Crée une petite aide pour montrer combien d'entrées PerformanceMeasure il y a.
function logMeasureCount() {
  console.log(
    "J'ai trouvé ces nombreuses entrées : " +
      performance.getEntriesByType("measure").length,
  );
}

// Crée un ensemble de mesures.
performance.measure("from navigation");
performance.mark("a");
performance.measure("from mark a", "a");
performance.measure("from navigation");
performance.measure("from mark a", "a");
performance.mark("b");
performance.measure("between a and b", "a", "b");

logMeasureCount(); // "J'ai trouvé ces nombreuses entrées : 5"

// Supprime uniquement les entrées PerformanceMeasure "from navigation".
performance.clearMeasures("from navigation");
logMeasureCount(); // "J'ai trouvé ces nombreuses entrées : 3"

// Supprime toutes les entrées de PerformanceMeasure.
performance.clearMeasures();
logMeasureCount(); // "J'ai trouvé ces nombreuses entrées : 0"
```

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

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

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

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

La méthode **`getEntriesByName()`** renvoie une liste de tous les objets `PerformanceEntry` pour le type donné. 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
let entries = window.performance.getEntriesByType(type);
```

### Arguments

`type`

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 *type* spécifié. Les éléments seront triés dans l'ordre chronologique basé sur les propriétés `startTime` des entrées. Si aucun objet ne possède le type spécifié, ou si aucun argument n'est fourni, une liste vide est renvoyée.

Exemple
-------


```js
function usePerformanceEntryMethods() {
  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");
  doWork(50000);
  performance.mark("End");
  performance.mark("Begin");
  doWork(100000);
  performance.mark("End");
  doWork(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 + "]");
    checkPerformanceEntry(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 + "]");
    checkPerformanceEntry(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,
    );
  }

  // Utilise 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-getentriesbytype |

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

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