Articles
Introduction à JavaScript
Objets enveloppeurs en JavaScript

Objets enveloppeurs en JavaScript

Cet article explique les objets enveloppeurs en JavaScript.

YouTube Video

Objets enveloppants

JavaScript dispose de types primitifs ainsi que d'objets pour les gérer (objets enveloppants).

Types Primitifs

Les types primitifs représentent une valeur unique et sont simples et légers. Ceux-ci sont immutables (inchangés) et n'ont pas directement de méthodes ou de propriétés d'objet, mais ils peuvent temporairement être convertis en objets enveloppes pour des opérations.

string et number sont des exemples de types primitifs. En revanche, les objets enveloppeurs commencent par une majuscule, comme String et Number.

Objets enveloppeurs

Pour manipuler les types primitifs, JavaScript génère temporairement des objets enveloppes (Object enveloppes). Les objets enveloppes contiennent des méthodes et des propriétés pour les types primitifs.

Number 

1let numObject = new Number(42);   // Wrapper object
2
3console.log(typeof numObject);    // object
4console.log(numObject.valueOf()); // 42
5
6let numValue = Number(42);        // Return primitive value
7
8console.log(typeof numValue);     // number
9console.log(numValue);            // 42
  • Number est un type d’objet qui enveloppe un number primitif. En créant explicitement un objet Number, vous pouvez gérer les nombres comme un number, mais il est généralement recommandé d’utiliser le type primitif number.

typeof numObject est "object", mais typeof 42 est "number".

  • Sachez que l’utilisation de l’opérateur new pour générer un objet enveloppe produit un résultat différent de l’usage de Number comme fonction. Lorsqu'il est appelé en tant que fonction, un number primitif est retourné.

String 

1let strObject = new String("Hello"); // Wrapper object
2
3console.log(typeof strObject);    // object
4console.log(strObject.valueOf()); // Hello
  • C’est un type d’objet qui enveloppe une string primitive. En utilisant un objet String, vous pouvez accéder aux propriétés et méthodes de chaîne, mais généralement une string primitive est utilisée.

typeof strObject est "object", mais typeof "Hello" est "string".

  • Comme Number, appeler String en tant que fonction retourne une string primitive.

Boolean 

1let boolObject = new Boolean(true); // Wrapper object
2
3console.log(typeof boolObject);    // object
4console.log(boolObject.valueOf()); // true
  • C’est un type d’objet qui enveloppe un boolean primitif. Vous pouvez également créer explicitement un objet Boolean, mais généralement un boolean primitif est utilisé.

typeof boolObject est "object", mais typeof true est "boolean".

  • Similairement à Number, appeler Boolean en tant que fonction retourne un boolean primitif.

BigInt 

 1let bigIntObject = Object(9007199254740991n); // Wrapper object
 2
 3console.log(typeof bigIntObject);    // object
 4console.log(bigIntObject.valueOf()); // 9007199254740991n
 5
 6let bigIntValue = BigInt(9007199254740991);   // Return primitive BigInt
 7
 8console.log(typeof bigIntValue);     // bigint
 9console.log(bigIntValue);            // 9007199254740991n
10
11// Error
12let bigIntObject2 = new BigInt(9007199254740991n);
  • Objectを使ってBigIntのラッパーオブジェクトを生成できますが、通常はプリミティブ型のbigintを直接使うのが一般的です。

typeof bigIntObjectは"object"であるのに対し、typeof 9007199254740991nは"bigint"です。

  • BigIntを関数として呼び出すとプリミティブなbigintを返しますが、new演算子をつけてBigIntのラッパーオブジェクトを生成することはできません。

Symbol 

1let symObject = Object(Symbol("id")); // Wrapper object for Symbol
2
3console.log(typeof symObject);    // object
4console.log(symObject.valueOf()); //
  • Vous pouvez utiliser Object pour créer un objet enveloppe pour un Symbol, mais en général, vous utilisez directement le type primitif Symbol.

Différences entre les types primitifs et les objets enveloppes

  • Les types primitifs sont légers et économes en mémoire, mais ils n’ont ni propriétés ni méthodes directes. Cependant, en JavaScript, même avec les types primitifs, des objets enveloppes temporaires sont créés automatiquement si nécessaire pour fournir des méthodes et propriétés.
1let text = "Hello";
2
3// A temporary String object is created,
4// allowing access to the length property
5console.log(text.length);
  • Les objets enveloppes sont des objets générés explicitement qui peuvent avoir un impact sur la mémoire et les performances, donc il est généralement recommandé d'utiliser des types primitifs.

Conclusion

  • Types Primitifs : Types légers comme number, string, boolean, null, undefined et symbol qui n'ont pas de méthodes directes.
  • Objets Enveloppants : Objets tels que Number, String et Boolean qui sont temporairement convertis à partir de types primitifs.

Vous pouvez suivre l'article ci-dessus avec Visual Studio Code sur notre chaîne YouTube. Veuillez également consulter la chaîne YouTube.

YouTube Video

Types de données en JavaScriptLes opérateurs en JavaScript