recursal/MDN huggingface dataset:
Object.prototype.valueOf()
==========================

La méthode **`valueOf()`** renvoie la valeur primitive d'un objet donné.

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

Syntaxe
-------


```js
object.valueOf();
```

### Valeur de retour

La valeur primitive de l'objet appelant.

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

JavaScript appelle la méthode `valueOf` pour convertir un objet en une valeur primitive. Il est rarement nécessaire d'appeler soi-même la méthode `valueOf` ; JavaScript l'invoque automatiquement lorsqu'il rencontre un objet alors qu'il attend une valeur primitive.

Par défaut, la méthode `valueOf` est héritée par tout objet descendant d'`Object`. Tous les objets globaux natifs redéfinissent cette méthode pour renvoyer une valeur appropriée. Si un objet n'a pas de valeur primitive, `valueOf` renvoie l'objet lui-même, ce qui sera affiché comme :


```js
[object Object]
```


`valueOf` peut être utilisée afin de convertir un objet prédéfini en une valeur primitive. Si un objet est défini dans un script, il est possible de surcharger `Object.prototype.valueOf` pour appeler une méthode personnalisée au lieu de la méthode par défaut d'`Object`.

### Surcharger `valueOf` pour des objets personnalisés

Il est possible de créer une fonction à appeler à la place de la méthode `valueOf` par défaut. Celle-ci ne peut pas recevoir de paramètres.

Supposons qu'on ait un type d'objet `monTypeDeNombre` et qu'on désire lui ajouter une méthode `valueOf` spécifique, on pourra utiliser le code suivant :


```js
monTypeDeNombre.prototype.valueOf = function () {
  return valeurPrimitive;
};
```


En utilisant ce code, chaque fois qu'un objet de type `monTypeDeNombre` sera utilisé dans un contexte où il doit être représenté comme une valeur primitive, JavaScript appellera automatiquement la fonction qui y est définie.

C'est habituellement JavaScript qui invoquera la méthode `valueOf`, mais il est aussi possible de l'appeler soi-même :


```js
monNombre.valueOf();
```


**Note :** Les objets à utiliser dans un contexte textuel sont convertis avec la méthode `toString()` ce qui est différent de la conversion d'objets `String` en valeurs primitives avec `valueOf`. Tous les objets peuvent être convertis en chaînes de caractères (la façon la plus générique étant "`[object type]`"). En revanche, la plupart des objets ne peut pas être convertie en nombre ou booléen par exemple.

Exemples
--------

### Utiliser `valueOf`


```js
function MonTypeDeNombre(n) {
  this.nombre = n;
}

MonTypeDeNombre.prototype.valueOf = function () {
  return this.nombre;
};

var monObj = new MonTypeDeNombre(4);
console.log(monObj + 3); // 7 car l'opération a implicitement utilisé valueOf
```

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

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

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

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

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

* `Object.prototype.toString()`
* `parseInt()`
* `Symbol.toPrimitive`
Object.isExtensible()
=====================

La méthode **`Object.isExtensible()`** permet de déterminer si un objet est extensible (c'est-à-dire qu'on peut lui ajouter de nouvelles propriétés).

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

Syntaxe
-------


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

### Paramètres

`obj`

L'objet dont on souhaite vérifier s'il est extensible.

### Valeur de retour

Un booléen qui indique si oui ou non l'objet passé en argument peut être étendu.

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

Par défaut, les objets sont extensibles, on peut leur ajouter de nouvelles propriétés (et pour les moteurs qui supportent `Object.prototype.__proto__` 
Obsolète
, leur propriété \_\_proto\_\_ peut être modifiée). Un objet peut devenir non-extensible en utilisant les méthodes `Object.preventExtensions()`, `Object.seal()`, ou `Object.freeze()`.

Exemples
--------


```js
// Les nouveaux objets sont extensibles.
var vide = {};
Object.isExtensible(vide); // true

// ...mais on peut les rendre non-extensibles.
Object.preventExtensions(vide);
Object.isExtensible(vide); // false

// Les objets scellés sont, par définition, non-extensibles.
var scellé = Object.seal({});
Object.isExtensible(scellé); // false

// Les objets gelés sont également, par définition, non-extensibles.
var gelé = Object.freeze({});
Object.isExtensible(gelé); // false
```

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, un argument qui n'est pas un objet sera traité comme un objet ordinaire non-extensible, la méthode renverra `false`.


```js
Object.isExtensible(1);
// TypeError: 1 n'est pas un objet (code ES5)

Object.isExtensible(1);
// false (code ES2015)
```

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

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

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

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

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

* `Object.preventExtensions()`
* `Object.seal()`
* `Object.isSealed()`
* `Object.freeze()`
* `Object.isFrozen()`
* `Reflect.isExtensible()`
Object.prototype.isPrototypeOf()
================================

La méthode **`isPrototypeOf()`** permet de tester si un objet existe dans la chaîne de prototypes d'un autre objet.

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

**Note :** `isPrototypeOf()` est différent de l'opérateur `instanceof`. Dans l'expression "`object instanceof AFunction`", on compare la chaîne de prototypes d'`object` avec `AFunction.prototype` et non avec `AFunction`.

Syntaxe
-------


```js
prototypeObj.isPrototypeOf(objet);
```

### Paramètres

`objet`

L'objet dont la chaîne de prototypes sera parcourue.

### Valeur de retour

Un `Boolean` indiquant si l'objet appelant se trouve dans sa chaîne de prototypes de l'objet indiqué.

### Erreurs déclenchées

`TypeError`

Une exception `TypeError` est déclenchée si `prototypeObj` est `undefined` ou `null`.

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

La méthode isPrototypeOf () vous permet de vérifier si un objet existe ou non dans la chaîne de prototypes d'un autre objet.

Exemples
--------

Cet exemple montre que `Bidule.prototype`, `Truc.prototype`, `Machin.prototype` et `Object.prototype` font bien partie de la chaîne de prototype pour l'objet `bidule` :


```js
function Machin() {}
function Truc() {}
function Bidule() {}

Truc.prototype = Object.create(Machin.prototype);
Bidule.prototype = Object.create(Truc.prototype);

var bidule = new Bidule();

console.log(Bidule.prototype.isPrototypeOf(bidule)); // true
console.log(Truc.prototype.isPrototypeOf(bidule)); // true
console.log(Machin.prototype.isPrototypeOf(bidule)); // true
console.log(Object.prototype.isPrototypeOf(bidule)); // true
```


La méthode `isPrototypeOf()`, avec l'opérateur `instanceof` en particulier, s'avère particulièrement utile si vous avez du code qui ne peut fonctionner que lorsqu'il traite des objets descendant d'une chaîne de prototypes donnée, par ex., pour garantir que certaines méthodes ou propriétés seront présentes dans cet objet.

Par exemple, vérifier que `bidule` descend bien de `Machin.prototype` :


```js
if (Toto.prototype.isPrototypeOf(bidule)) {
  // effectuer quelque chose de sûr
}
```

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

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

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

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

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

* `instanceof`
* `Object.getPrototypeOf()`
* `Object.setPrototypeOf()`
* `Object.prototype.__proto__`
Object.fromEntries()
====================

La méthode **`Object.fromEntries()`** permet de transformer une liste de paires de clés/valeurs en un objet.

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

Syntaxe
-------


```js
Object.fromEntries(iterable);
```

### Paramètres

`iterable`

Un itérable tel qu'un tableau (`Array`) ou une `Map` ou tout autre objet qui implémente le protocole itérable.

### Valeur de retour

Un nouvel objet dont les propriétés sont fournies par les éléments de l'itérable.

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

La méthode `Object.fromEntries()` prend comme argument une liste de paires de clés-valeurs et renvoie un nouvel objet dont les propriétés sont fournies par ces clés-valeurs. L'argument `iterable` doit implémenter une méthode `@@iterator` qui renvoie un itérateur produisant un objet semblable à un tableau avec deux éléments ; le premier élément est une valeur qui sera utilisée comme clé de la propriété et le second élément sera utilisé comme valeur associée à cette clé.

`Object.fromEntries()` est la fonction inverse de `Object.entries()`.

Exemples
--------

### Convertir une `Map` en un `Object`

Grâce à `Object.fromEntries`, on peut convertir des objets `Map` en `Object` :


```js
const map = new Map([
  ["toto", "truc"],
  ["machin", 42],
]);
const obj = Object.fromEntries(map);
console.log(obj); // { toto: "truc", machin: 42 }
```

### Convertir un `Array` en un `Object`

Grâce à `Object.fromEntries`, on peut convertir des objets `Array` en `Object` :


```js
const arr = [
  ["0", "a"],
  ["1", "b"],
  ["2", "c"],
];
const obj = Object.fromEntries(arr);
console.log(obj); // { 0: "a", 1: "b", 2: "c" }
```

### Transformer des objets

Avec `Object.fromEntries` et la méthode réciproque `Object.entries()`, et les méthodes de manipulation de tableaux, on peut transformer des objets :


```js
const object1 = { a: 1, b: 2, c: 3 };

const object2 = Object.fromEntries(
  Object.entries(object1).map(([key, val]) => [key, val \* 2]),
);

console.log(object2);
// { a: 2, b: 4, c: 6 }
```

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

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

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

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

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

* `Object.entries()`
* `Object.keys()`
* `Object.values()`
* `Map.prototype.entries()`
* `Map.prototype.keys()`
* `Map.prototype.values()`
Object.prototype.toLocaleString()
=================================

La méthode **`toLocaleString()`** renvoie une chaine de caractères représentant l'objet. Cette méthode est destinée à être surchargée par les objets dérivés à des fins spécifiques pour prendre en compte les locales.

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

Syntaxe
-------


```js
obj.toLocaleString();
```

### Valeur de retour

Une chaîne de caractères qui représente l'objet en tenant compte de la locale.

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

La méthode `toLocaleString` renvoie le résultat de l'appel à la méthode `toString()`.

Cette fonction est destinée à fournir aux objets une méthode générique `toLocaleString`, même si tous ne peuvent l'utiliser. Voir la liste ci-dessous.

### Objets surchargeant la méthode toLocaleString

* `Array` : `Array.prototype.toLocaleString()`
* `Number` : `Number.prototype.toLocaleString()`
* `Date` : `Date.prototype.toLocaleString()`
Spécifications
--------------

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

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

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

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

* `Object.prototype.toString()`
Object.prototype.\_\_lookupSetter\_\_()
=======================================

**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 **`__lookupSetter__`** renvoie la fonction définie comme mutateur pour une propriété donnée.

Syntaxe
-------


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

### Paramètres

`sprop`

Une chaîne qui contient le nom de la propriété dont on souhaite obtenir le mutateur correspondant.

### Valeur de retour

La fonction associée comme mutateur à la propriété indiquée.

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

Si un mutateur a été défini pour une propriété, on ne peut pas l'obtenir en faisant référence à la propriété directement. `__lookupSetter__` peut être utilisée pour obtenir une référence vers la fonction utilisée comme mutateur.

Cette méthode ne doit plus être utilisée et peut être remplacée avec la méthodes standard `Object.getOwnPropertyDescriptor()`.

Exemples
--------


```js
var obj = {
  set toto(valeur) {
    this.truc = value;
  },
};

// Méthode non-standard et dépréciée
obj.\_\_lookupSetter\_\_("toto");
// (function(valeur) { this.truc = valeur; })

// Méthode standard
Object.getOwnPropertyDescriptor(obj, "toto").set;
// (function(valeur) { this.truc = valeur; })
```

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

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

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

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

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

* `Object.prototype.__lookupGetter__()`
* L'opérateur `set`
* `Object.getOwnPropertyDescriptor()` et `Object.getPrototypeOf()`
* `Object.prototype.__defineGetter__()`
* `Object.prototype.__defineSetter__()`
* Guide JavaScript : Utiliser des *getters* et *setters*
Constructeur Object()
=====================

Le **constructeur `Object`** crée une enveloppe objet pour la valeur passée en argument.

* Si la valeur est `null` ou `undefined`, il crée et renvoie un nouvel objet vide.
* Sinon, il renvoie un objet du type correspondant à la valeur passée en argument.
* Si la valeur est déjà un objet, il renvoie la valeur.

Lorsqu'il est appelé comme une fonction plutôt que comme un constructeur (c'est-à-dire sans être précédé de l'opérateur `new`), `Object` se comporte de façon identique à `new Object()`.

Syntaxe
-------


```js
new Object();
new Object(valeur);
```

### Paramètres

`valeur`

N'importe quelle valeur.

Exemples
--------

### Créer un nouvel objet


```js
let o = new Object();
o.toto = 42;

console.log(o);
// Object { toto: 42 }
```

### Utiliser Object() avec undefined et null

Dans l'exemple suivant, on crée un objet vide dans la variable `o` :


```js
let o = new Object();
```



```js
let o = new Object(undefined);
```



```js
let o = new Object(null);
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-object-constructor |

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

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

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

* Initialisateur d'objet
Object.is()
===========

La méthode **`Object.is()`** permet de déterminer si deux valeurs sont les mêmes.

Syntaxe
-------


```js
Object.is(value1, value2);
```

### Paramètres

`valeur1`

La première valeur à comparer.

`valeur2`

La seconde valeur à comparer.

### Valeur de retour

Un booléen indiquant si les arguments ont la même valeur.

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

`Object.is()` permet de déterminer si deux valeurs sont identiques. Deux valeurs sont considérées identiques si :

* elles sont toutes les deux `undefined`
* elles sont toutes les deux `null`
* elles sont toutes les deux `true` ou toutes les deux `false`
* elles sont des chaînes de caractères de la même longueur et avec les mêmes caractères (dans le même ordre)
* elles sont toutes les deux le même objet
* elles sont des nombres et
    + sont toutes les deux égales à `+0`
    + sont toutes les deux égales à `-0`
    + sont toutes les deux égales à `NaN`
    + sont non-nulles, ne sont pas `NaN` et ont toutes les deux la même valeur

Attention, ce n'est pas la même égalité qu'avec l'opérateur `==`. L'opérateur == applique différentes conversions à chaque opérande (si ils ne sont pas du même type) avant de tester l'égalité (d'où le comportement `"" == false` qui donne `true`), `Object.is` ne convertit aucune des deux valeurs.

Cette égalité est également différente de l'égalité stricte qu'on peut avoir avec l'opérateur `===`. L'opérateur === (et également l'opérateur ==) considère que `-0` et `+0` sont égales et que `Number.NaN` n'est pas égal à `NaN`.

Exemples
--------


```js
Object.is("toto", "toto"); // true
Object.is(window, window); // true

Object.is("toto", "truc"); // false
Object.is([], []); // false

var toto = { a: 1 };
var truc = { a: 1 };
Object.is(toto, toto); // true
Object.is(toto, truc); // false

Object.is(null, null); // true

// Cas aux limites (cas spéciaux)
Object.is(0, -0); // false
Object.is(-0, -0); // true
Object.is(NaN, 0 / 0); // true
```

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


```js
if (!Object.is) {
  Object.is = function (v1, v2) {
    // Algorithme SameValue
    if (v1 === v2) {
      //Étapes 1-5, 7-10
      //Étapes 6.b-6.b +0 !=-0
      return v1 !== 0 || 1 / v1 === 1 / v2;
    } else {
      //Étapes 6.a: NaN == NaN
      return v1 !== v1 && v2 !== v2;
    }
  };
}
```

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

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

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

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

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

* Guide JavaScript : L'égalité en JavaScript qui illustre les trois manières de comparer en JavaScript
* Les opérateurs de comparaison
Object.prototype.\_\_defineSetter\_\_()
=======================================

**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 **`__defineSetter__`** permet de lier une propriété d'un objet à une fonction qui sera exécutée pour toute tentative de définition/changement de cette propriété.

Syntaxe
-------


```js
obj.\_\_defineSetter\_\_(prop, fun);
```

### Paramètres

`prop`

Une chaîne de caractères qui contient le nom de la propriété qu'on souhaite lier à la fonction.

`fun`

Une fonction à appeler pour chaque modification de la propriété. Cette fonction prend la forme suivante :


```js
function(val) { . . . }
```


`val`

Un alias pour la variable contenant la nouvelle valeur qu'on souhaite affecter à `prop`.


### Valeur de retour

`undefined`.

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

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

Exemples
--------


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

var o = {};
o.\_\_defineSetter\_\_("valeur", function (val) {
  this.uneAutreValeur = val;
});
o.valeur = 5;
console.log(o.valeur); // undefined
console.log(o.uneAutreValeur); // 5

// Façons standard

// En utilisant l'opérateur set
var o = {
  set valeur(val) {
    this.uneAutreValeur = val;
  },
};
o.valeur = 5;
console.log(o.valeur); // undefined
console.log(o.uneAutreValeur); // 5

// En utilisant Object.defineProperty
var o = {};
Object.defineProperty(o, "valeur", {
  set: function (val) {
    this.uneAutreValeur = val;
  },
});
o.valeur = 5;
console.log(o.valeur); // undefined
console.log(o.uneAutreValeur); // 5
```

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

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

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

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

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

* `Object.prototype.__defineGetter__()`
* L'opérateur `set`
* `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
RegExp.prototype.ignoreCase
===========================

La propriété **`ignoreCase`** indique si le drapeau (*flag*) "`i`" est utilisé ou non pour cette expression rationnelle. `ignoreCase` est une propriété accessible en lecture seule d'une instance d'expression rationnelle donnée.

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

| Attributs de `RegExp.prototype.ignoreCase` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Oui |

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

La valeur de `ignoreCase` est un booléen. Elle vaut `true` si le flag "`i`" a été utilisé et `false` sinon. Le drapeau "`i`" indique si la recherche de correspondances doit être sensible à la casse ou non.

Cette propriété ne peut pas être modifiée directement.

Exemples
--------


```js
var regex = new RegExp("toto", "i");

console.log(regex.ignoreCase); // true
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.ignorecase |

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

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

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

* `RegExp.prototype.global`
* `RegExp.prototype.lastIndex`
* `RegExp.prototype.multiline`
* `RegExp.prototype.source`
* `RegExp.prototype.sticky`
RegExp.leftContext ($`)
=======================

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

La propriété non-standard **`leftContext`** est une propriété statique accessible uniquement en lecture. Cette propriété liée aux expressions rationnelles contient la sous-chaîne qui précède la correspondance la plus récente. `RegExp.$`` est un alias pour cette propriété.

Syntaxe
-------


```js
RegExp.leftContext;
RegExp["$`"];
```

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

La propriété `leftContext` est une propriété statique, elle n'est donc pas distincte entre les différents objets représentants les expressions rationnelles. Il faut donc toujours utiliser la syntaxe `RegExp.leftContext` ou `RegExp['$`'].`

La valeur de la propriété `leftContext` n'est accessible uniquement qu'en lecture. Elle est modifiée par le moteur à chaque fois qu'une nouvelle correspondance est trouvée.

L'alias ne peut pas être utilisé avec la notation utilisant le point (`RegExp.$``). En effet, le parseur attend un gabarit de chaîne à la suite de l'accent grave. Si on utilise le point, on aura donc une exception `SyntaxError`. Pour cet alias, on utilisera la notation à base de crochets.

Exemples
--------


```js
var re = /monde/g;
re.test("coucou monde !");
RegExp.leftContext; // "coucou "
RegExp["$`"]; // "coucou "
```

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

Cette propriété n'est pas standard et ne fait partie d'aucune spécification.

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

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

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

* Non-standard
 `RegExp.input ($_)`
* Non-standard
 `RegExp.lastMatch ($&)`
* Non-standard
 `RegExp.lastParen ($+)`
* Non-standard
 `RegExp.rightContext ($')`
* Non-standard
 `RegExp.$1-$9`