recursal/MDN huggingface dataset:
Atomics.store()
===============

La méthode statique **`Atomics.store()`** enregistre une valeur donnée à un emplacement donné du tableau partagé et renvoie cette valeur.

Exemple interactif
------------------

Syntaxe
-------


```js
Atomics.store(typedArray, index, valeur);
```

### Paramètres

`typedArray`

Un tableau typé entier partagé parmi `Int8Array`, `Uint8Array`, `Int16Array`, `Uint16Array`, `Int32Array` ou `Uint32Array`.

`index`

La position du tableau `typedArray` à laquelle on souhaite stocker la valeur.

`valeur`

Le nombre à enregistrer.

### Valeur de retour

La valeur qui a été enregistrée.

### Exceptions

* Cette méthode lève `TypeError` si le type de `typedArray` n'est pas un des types entiers autorisés.
* Cette méthode lève `TypeError` si `typedArray` n'est pas tableau typé partagé.
* Cette méthode lève `RangeError` si `index` est en dehors des limites de `typedArray`.
Exemples
--------


```js
var buffer = new ArrayBuffer(4); // Buffer classique
var float32 = new Float32Array(buffer); // Nombre flottant
var uint32 = new Uint32Array(buffer); // Représentation IEEE754

float32[0] = 0.5;
console.log("0x" + uint32[0].toString(16));

uint32[0] = 0x3f000000; /// Représentation sur 32 bits de 0.5 (IEEE754)
console.log(float32[0]);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.store |

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

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

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

* `Atomics`
* `Atomics.load()`
Atomics.add()
=============

La méthode statique **`Atomics.add()`** ajoute une valeur donnée à un élément du tableau à une position donnée. Elle renvoie l'ancienne valeur qui était contenue à cet emplacement. Cette opération atomique garantit qu'aucune autre opération d'écriture n'est appliquée tant que la valeur modifiée n'est pas écrite.

Exemple interactif
------------------

Syntaxe
-------


```js
Atomics.add(typedArray, index, valeur);
```

### Paramètres

`typedArray`

Un tableau typé entier partagé parmi `Int8Array`, `Uint8Array`, `Int16Array`, `Uint16Array`, `Int32Array` ou `Uint32Array`.

`index`

La position du tableau `typedArray` auquel on souhaite ajouter une `valeur`.

`valeur`

La valeur à ajouter.

### Valeur de retour

L'ancienne valeur qui était contenue à (`typedArray[index]`).

### Exceptions levées

* Cette méthode lève `TypeError` si le type de `typedArray` n'est pas un des types entiers autorisés.
* Cette méthode lève `TypeError` si `typedArray` n'est pas tableau typé partagé.
* Cette méthode lève `RangeError` si `index` est en dehors des limites de `typedArray`.
Exemples
--------


```js
var sab = new SharedArrayBuffer(1024);
var ta = new Uint8Array(sab);

Atomics.add(ta, 0, 12); // renvoie 0, l'ancienne valeur
Atomics.load(ta, 0); // 12
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-atomics.add |

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

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

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

* `Atomics`
* `Atomics.sub()`
Object.prototype.propertyIsEnumerable()
=======================================

La méthode **`propertyIsEnumerable()`** renvoie un booléen qui indique si la propriété donnée est énumérable.

Exemple interactif
------------------

Syntaxe
-------


```js
obj.propertyIsEnumerable(prop);
```

### Paramètres

`prop`

Le nom de la propriété dont on souhaite savoir si elle est énumérable ou non.

### Valeur de retour

Un booléen qui indique si la propriété passée en argument est énumérable.

Description
-----------

Chaque objet possède une méthode `propertyIsEnumerable`. Cette méthode est utilisée afin de savoir s'il est possible d'énumérer la propriété donnée au moyen d'une boucle `for...in`. Cela concerne uniquement les propriétés propres à l'objet (celles qui ne sont pas héritées via la chaîne de prototypes). Si un objet ne possède pas la propriété, cette méthode renverra `false`.

Exemples
--------

### Utiliser `propertyIsEnumerable`

Dans l'exemple qui suit, on illustre comment utiliser `propertyIsEnumerable` sur les objets et tableaux :


```js
var o = {};
var a = [];
o.prop = "est énumérable";
a[0] = "est énumérable";

o.propertyIsEnumerable("prop"); // renvoie true
a.propertyIsEnumerable(0); // renvoie true
```

### Objets natifs et objets définis par l'utilisateur

Dans l'exemple ci-dessous, on illustre l'énumérabilité des propriétés des objets natifs et celle des objets tiers, définis dans les scripts :


```js
var a = ["est énumérable"];

a.propertyIsEnumerable(0); // renvoie true
a.propertyIsEnumerable("length"); // renvoie false

Math.propertyIsEnumerable("random"); // renvoie false
this.propertyIsEnumerable("Math"); // renvoie false
```

### Propriétés héritées et propriétés propres


```js
var a = [];
a.propertyIsEnumerable("constructor"); // renvoie false

function premierConstructeur() {
  this.propriete = "non énumérable";
}

premierConstructeur.prototype.premiereMethode = function () {};

function secondConstructeur() {
  this.methode = function methode() {
    return "énumérable";
  };
}

secondConstructeur.prototype = new premierConstructeur();
secondConstructeur.prototype.constructor = secondConstructeur;

var o = new secondConstructeur();
o.propArbitraire = "is enumerable";

o.propertyIsEnumerable("propArbitraire"); // renvoie true
o.propertyIsEnumerable("méthode"); // renvoie true
o.propertyIsEnumerable("propriété"); // renvoie false

o.propriete = "énumérable";

o.propertyIsEnumerable("propriété"); // renvoie true

// Ces instructions renvoient false car propertyIsEnumerable
// ne prend pas en compte la chaîne de prototypes
o.propertyIsEnumerable("prototype"); // renvoie false
o.propertyIsEnumerable("constructor"); // renvoie false
o.propertyIsEnumerable("premièreMéthode"); // renvoie false
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.propertyisenumerable |

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

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

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

* Caractère énumérable et rattachement des propriétés
* `for...in`
* `Object.keys()`
* `Object.defineProperty()`
Object.prototype.\_\_lookupGetter\_\_()
=======================================

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

La méthode **`__lookupGetter__`** renvoie la fonction liée comme accesseur d'une propriété donnée.

Syntaxe
-------


```js
obj.\_\_lookupGetter\_\_(sprop);
```

### Paramètres

`sprop`

Une chaîne de caractères qui contient le nom de la propriété dont on souhaite obtenir l'accesseur (*getter*).

### Valeur de retour

La fonction qui est l'accesseur lié à la propriété indiquée.

Description
-----------

Si un accesseur a été défini pour une propriété, il n'est pas possible d'obtenir la fonction utilisée en accédant à la propriété car on obtiendrait la valeur de retour de l'accesseur au lieu de l'accesseur lui-même. `__lookupGetter__` permet de récupérer la valeur de la fonction pour l'accesseur.

Cette méthode ne doit plus être utilisée et il est possible de la remplacer de façon standard en utilisant : `Object.getOwnPropertyDescriptor()` et `Object.getPrototypeOf()`.

Exemples
--------


```js
var obj = {
  get toto() {
    return Math.random() > 0.5 ? "toto" : "truc";
  },
};

// Méthode non-standard et dépréciée
obj.\_\_lookupGetter\_\_("toto");
// (function() { return Math.random() > 0.5 ? 'toto' : 'truc'; })

// Méthode standard
Object.getOwnPropertyDescriptor(obj, "toto").get;
// (function() { return Math.random() > 0.5 ? 'toto' : 'truc'; })
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.\_\_lookupGetter\_\_ |

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

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

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

* `Object.prototype.__lookupSetter__()`
* L'opérateur `get`
* `Object.getOwnPropertyDescriptor()` et `Object.getPrototypeOf()`
* `Object.prototype.__defineGetter__()`
* `Object.prototype.__defineSetter__()`
* Guide JavaScript : Définir des *getters* et *setters*
Object.keys()
=============

La méthode **`Object.keys()`** renvoie un tableau contenant les noms des propriétés propres à un objet (qui ne sont pas héritées via la chaîne de prototypes) et qui sont énumérables. L'ordre de ce tableau est le même que celui obtenu par une boucle `for...in` (à la différence qu'une boucle for-in liste également les propriétés héritées).

Exemple interactif
------------------

Syntaxe
-------


```js
Object.keys(obj);
```

### Paramètres

`obj`

L'objet dont on souhaite lister les propriétés propres et énumérables.

### Valeur de retour

Un tableau de chaînes de caractères qui sont les noms des propriétés énumérables de l'objet passé en argument.

Description
-----------

`Object.keys()` renvoie un tableau dont les éléments sont les chaînes de caractères des noms des propriétés propres et énumérables d`'obj`. L'ordre des propriétés obtenu est le même que celui obtenu lorsqu'on boucle manuellement sur les propriétés de l'objet.

Exemples
--------


```js
var arr = ["a", "b", "c"];
console.log(Object.keys(arr));
// affichera ['0', '1', '2']

// un objet semblable à un tableau
var obj = { 0: "a", 1: "b", 2: "c" };
console.log(Object.keys(obj));
// affichera ['0', '1', '2']

// un objet semblable à un tableau avec
// un ordre de clé aléatoire
var an_obj = { 100: "a", 2: "b", 7: "c" };
console.log(Object.keys(an_obj));
// affichera ['2', '7', '100']

// getToto est une propriété non énumérable
var monObjet = Object.create(
  {},
  {
    getToto: {
      value: function () {
        return this.toto;
      },
    },
  },
);
monObjet.toto = 1;

console.log(Object.keys(monObjet));
// affichera ['toto']
```


Si on souhaite lister toutes les propriétés, y compris celles qui ne sont pas énumérables, on pourra utiliser `Object.getOwnPropertyNames()`.

Notes
-----

Pour ES5, si l'argument passé à la méthode n'est pas un objet mais une valeur d'un autre type primitif, cela entraînera une exception `TypeError`. Pour ES2015 (ES6), un argument qui n'est pas un objet sera d'abord converti en objet.


```js
Object.keys("toto");
// TypeError: "toto" n'est pas un objet (code ES5)

Object.keys("toto");
// ["0", "1", "2", "3"] (code ES2015)
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.keys |

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

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

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

* Énumérabilité et possession des propriétés
* `Object.prototype.propertyIsEnumerable()`
* `Object.create()`
* `Object.getOwnPropertyNames()`
* `Object.values()`
* `Object.entries()`
Object.getPrototypeOf()
=======================

La méthode **`Object.getPrototypeOf()`** renvoie le prototype d'un objet donné (i.e. la valeur de la propriété `[[Prototype]]` interne).

Exemple interactif
------------------

Syntaxe
-------


```js
Object.getPrototypeOf(obj);
```

### Paramètres

`obj`

L'objet dont on souhaite obtenir le prototype.

### Valeur de retour

Le prototype de l'objet passé en argument. Si aucune propriété n'est héritée, c'est la valeur `null` qui est renvoyée.

Exemples
--------


```js
var proto = {};
var obj = Object.create(proto);
Object.getPrototypeOf(obj) === proto; // true
```

Notes
-----

Pour ES5, la méthode renvoie une exception `TypeError` si le paramètre `obj` n'est pas un objet. Pour ES2015, le paramètre sera converti en un objet avant l'application de la méthode.


```js
Object.getPrototypeOf("toto");
// TypeError: "toto" n'est pas un objet (code ES5)
Object.getPrototypeOf("toto");
// String.prototype (code ES2015)
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.getprototypeof |

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

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

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

* `Object.prototype.isPrototypeOf()`
* `Object.setPrototypeOf()`
* `Object.prototype.__proto__`
* Le billet de John Resig sur getPrototypeOf (en anglais)
* `Reflect.getPrototypeOf()`
Object.values()
===============

La méthode **`Object.values()`** renvoie un tableau contenant les valeurs des propriétés propres énumérables d'un objet dont l'ordre est le même que celui obtenu avec une boucle `for...in` (la boucle `for-in` est différente car elle parcourt également les propriétés héritées).

Exemple interactif
------------------

Syntaxe
-------


```js
Object.values(obj);
```

### Paramètres

`obj`

L'objet dont on souhaite connaître les valeurs des propriétés propres énumérables.

### Valeur de retour

Un tableau dont les éléments sont les valeurs des propriétés énumérables de l'objet passé en argument.

Description
-----------

`Object.values()` renvoie un tableau dont les éléments sont les valeurs des propriétés énumérables directement rattachées à l'objet passé en argument. L'ordre du tableau est le même que celui obtenu lorsqu'on parcourt les propriétés manuellement.

Exemples
--------


```js
var obj = { toto: "truc", machin: 42 };
console.log(Object.values(obj)); // ['truc', 42]

// un objet semblable à un tableau
var obj = { 0: "a", 1: "b", 2: "c" };
console.log(Object.values(obj)); // ['a', 'b', 'c']

// un objet semblable à un tableau
// dont les clés sont ordonnées aléatoirement
// lorsque des clés numériques sont utilisées, les valeurs sont
// renvoyées selon l'ordre numérique des clés
var un_obj = { 100: "a", 2: "b", 7: "c" };
console.log(Object.values(un_obj)); // ['b', 'c', 'a']

// getToto est une propriété qui
// n'est pas énumérable
var mon_obj = Object.create(
  {},
  {
    getToto: {
      value: function () {
        return this.toto;
      },
    },
  },
);
mon_obj.toto = "truc";
console.log(Object.values(mon_obj)); // ['truc']

// un argument de type primitif sera
// converti en un objet
console.log(Object.values("toto")); // ['t', 'o', 't', 'o']
```

Prothèse d'émulation (*polyfill*)
---------------------------------

Afin d'ajouter le support pour `Object.values` dans des environnements plus anciens qui ne supportent pas la méthode nativement, vous pouvez utiliser une prothèse comme celle proposée sur le dépôt tc39/proposal-object-values-entries ou sur le dépôt es-shims/Object.values.

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.values |

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

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

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

* Énumérabilité et rattachement des propriétés
* `Object.keys()`
* `Object.entries()`
* `Object.prototype.propertyIsEnumerable()`
* `Object.create()`
* `Object.getOwnPropertyNames()`
Object.isSealed()
=================

La méthode **`Object.isSealed()`** permet de déterminer si un objet est scellé.

Exemple interactif
------------------

Syntaxe
-------


```js
Object.isSealed(obj);
```

### Paramètres

`obj`

L'objet dont on souhaite savoir s'il est scellé.

### Valeur de retour

Un booléen indiquant si l'objet est scellé ou non.

Description
-----------

Renvoie `true` si l'objet est scellé, `false` sinon. Un objet scellé est un objet qui n'est pas extensible et dont toutes les propriétés sont non-configurables (on ne peut donc pas les retirer, en revanche on peut avoir un droit de modification).

Exemples
--------


```js
// Par défaut, les objets ne sont pas scellés
var vide = {};
Object.isSealed(vide); // false

// Si un objet vide est rendu non-extensible,
// il est scellé
Object.preventExtensions(vide);
Object.isSealed(vide); // true

// Ce qui n'est pas vrai pour un objet non-vide,
// sauf si toutes ses propriétés sont non-configurables
var avecPropriétés = { pif: "paf pouf" };
Object.preventExtensions(avecPropriétés);
Object.isSealed(avecPropriétés); // false

// Si on rend les propriétés non configurables,
// l'objet est scellé
Object.defineProperty(avecPropriétés, "pif", { configurable: false });
Object.isSealed(avecPropriétés); // true

// La méthode la plus simple est d'utiliser Object.seal.
var scellé = {};
Object.seal(scellé);
Object.isSealed(scellé); // true

// Un objet scellé est, par définition, non-extensible
Object.isExtensible(scellé); // false

// Un objet scellé peut être gelé mais ce n'est pas
// nécessaire. gelé signifie que les propriétés ne
// peuvent pas être modifiées
Object.isFrozen(scellé); // true

var s2 = Object.seal({ p: 3 });
Object.isFrozen(s2); // false ("p" est toujours modifiable)

var s3 = Object.seal({
  get p() {
    return 0;
  },
});
// pour les accesseurs, seule l'accès en
// configuration est important
Object.isFrozen(s3); // true
```

Notes
-----

Pour ES5, si l'argument passé à la méthode n'est pas un objet mais une valeur d'un autre type primitif, cela entraînera une exception `TypeError`. Pour ES2015, une valeur qui n'est pas un objet sera traitée comme si c'était un objet scellé et la méthode renverra `true`.


```js
Object.isSealed(1);
// TypeError: 1 is not an object (ES5 code)

Object.isSealed(1);
// true (ES2015 code)
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.issealed |

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

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

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

* `Object.seal()`
* `Object.preventExtensions()`
* `Object.isExtensible()`
* `Object.freeze()`
* `Object.isFrozen()`
Object.getOwnPropertySymbols()
==============================

La méthode **`Object.getOwnPropertySymbols()`** renvoie un tableau contenant tous les symboles des propriétés trouvées directement sur un objet donné.

Exemple interactif
------------------

Syntaxe
-------


```js
Object.getOwnPropertySymbols(obj);
```

### Paramètres

`obj`

L'objet dont on souhaite lister les symboles des propriétés propres.

### Valeur de retour

Un tableau des symboles trouvés directement sur l'objet passé en argument.

Description
-----------

De la même façon que `Object.getOwnPropertyNames()`, il est possible d'avoir la liste des symboles des propriétés d'un objet donné sous forme d'un tableau. La méthode `Object.getOwnPropertyNames()` ne contiendra uniquement que les propriétés « nommées » d'un objet et non pas les propriétés uniquement accessibles via un symbole.

Par défaut, aucun objet ne possède de propriété accessible via un symbole à l'état initial. Ainsi, `Object.getOwnPropertySymbols()` renvoie un tableau vide sauf si des propriétés nommées avec des symboles ont été définies pour l'objet.

Exemples
--------


```js
var obj = {};
var a = Symbol("a");
var b = Symbol.for("b");

obj[a] = "symboleLocal";
obj[b] = "symboleGlobal";

var objectSymboles = Object.getOwnPropertySymbols(obj);

console.log(objectSymboles.length); // 2
console.log(objectSymboles); // [Symbol(a), Symbol(b)]
console.log(objectSymboles[0]); // Symbol(a)
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.getownpropertysymbols |

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

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

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

* `Object.getOwnPropertyNames()`
* `Symbol`
Object.prototype.\_\_defineGetter\_\_()
=======================================

**Attention :** Cette fonctionnalité est dépréciée et il est préférable d'utiliser l'API `Object.defineProperty()` et la syntaxe d'initialisation d'objets. Toutefois, `__defineGetter__` est largement utilisée sur le Web et est implémentée. Il est donc peu probable que les navigateurs retirent cette méthode.

La méthode **`__defineGetter__`** permet de lier une propriété d'un objet à une fonction à exécuter lorsqu'on accède à la propriété.

Syntaxe
-------


```js
obj.\_\_defineGetter\_\_(prop, func);
```

### Paramètres

`prop`

Une chaîne de caractères contenant le nom de la propriété à lier à la fonction donnée.

`func`

Une fonction à utiliser à chaque fois qu'on accède à la propriété.

### Valeur de retour

`undefined`.

Description
-----------

La méthode `__defineGetter__` permet de définir un accesseur sur un objet pré-existant.

Exemples
--------


```js
// Méthode non-standard et dépréciée

var o = {};
o.\_\_defineGetter\_\_("gimmeFive", function () {
  return 5;
});
console.log(o.gimmeFive); // 5

// Façon standard

// En utilisant l'opérateur get
var o = {
  get gimmeFive() {
    return 5;
  },
};
console.log(o.gimmeFive); // 5

// En utilisant Object.defineProperty
var o = {};
Object.defineProperty(o, "gimmeFive", {
  get: function () {
    return 5;
  },
});
console.log(o.gimmeFive); // 5
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.\_\_defineGetter\_\_ |

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

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

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

* `Object.prototype.__defineSetter__()`
* L'opérateur `get`
* `Object.defineProperty()`
* `Object.prototype.__lookupGetter__()`
* `Object.prototype.__lookupSetter__()`
* Guide JavaScript : définir des getters et setters
* [Billet de blog] Deprecation of \_\_defineGetter\_\_ and \_\_defineSetter\_\_ (en anglais)
* bug Firefox 647423