Wrapper-objecten in JavaScript

Dit artikel legt uit wat wrapper-objecten in JavaScript zijn.

YouTube Video

Wrapper-objecten

JavaScript heeft primitieve typen en objecten om deze te verwerken (wrapper-objecten).

Primitieve typen

Primitieve typen vertegenwoordigen een enkele waarde en zijn eenvoudig en lichtgewicht. Deze zijn onveranderlijk (niet aan te passen) en hebben niet direct objectmethoden of -eigenschappen, maar ze kunnen tijdelijk worden omgezet in wrapper-objecten voor bewerkingen.

string en number zijn voorbeelden van primitieve typen. Aan de andere kant beginnen wrapper-objecten met een hoofdletter, zoals String en Number.

Wrapper-objecten

Om primitieve typen te manipuleren, genereert JavaScript tijdelijk wrapper-objecten (Object-wrappers). Wrapper-objecten bevatten methoden en eigenschappen voor de primitieve typen.

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 is een objecttype dat een primitief number omhult. Door expliciet een Number-object te maken, kunt u getallen behandelen als een number, maar het wordt meestal aanbevolen om het primitieve number-type te gebruiken.

typeof numObject is "object", maar typeof 42 is "number".

• Wees ervan bewust dat het gebruik van de new-operator om een nieuw wrapper-object te genereren een ander resultaat oplevert dan het aanroepen van Number als een functie. Wanneer aangeroepen als functie, wordt een primitieve number geretourneerd.

String

1let strObject = new String("Hello"); // Wrapper object
2
3console.log(typeof strObject);    // object
4console.log(strObject.valueOf()); // Hello

• Het is een objecttype dat een primitieve string omhult. Door een String-object te gebruiken, kunt u toegang krijgen tot eigendommen en methoden van strings, maar meestal wordt een primitieve string gebruikt.

typeof strObject is "object", maar typeof "Hello" is "string".

• Net als bij Number retourneert het aanroepen van String als een functie een primitieve string.

Boolean

1let boolObject = new Boolean(true); // Wrapper object
2
3console.log(typeof boolObject);    // object
4console.log(boolObject.valueOf()); // true

• Het is een objecttype dat een primitieve boolean omhult. U kunt ook expliciet een Boolean-object maken, maar meestal wordt een primitief boolean-type gebruikt.

typeof boolObject is "object", maar typeof true is "boolean".

• Net als bij Number retourneert het aanroepen van Boolean als een functie een primitieve boolean.

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()); //

• U kunt Object gebruiken om een wrapper-object te maken voor Symbol, maar meestal gebruikt u direct het primitieve type Symbol.

Verschillen tussen primitieve typen en wrapper-objecten

• Primitieve typen zijn lichtgewicht en geheugenefficiënt, maar ze hebben geen directe eigenschappen of methoden. In JavaScript worden echter, zelfs bij primitieve typen, tijdelijke wrapper-objecten automatisch gecreëerd wanneer dat nodig is om methoden en eigenschappen aan te bieden.

1let text = "Hello";
2
3// A temporary String object is created,
4// allowing access to the length property
5console.log(text.length);

• Wrapper-objecten zijn expliciet gegenereerde objecten die geheugen en prestaties kunnen beïnvloeden, dus het gebruik van primitieve typen wordt over het algemeen aanbevolen.

Conclusie

• Primitieve Typen: Lichtgewicht typen zoals number, string, boolean, null, undefined en symbol die geen directe methoden hebben.
• Wrapper-objecten: Objecten zoals Number, String en Boolean die tijdelijk worden geconverteerd van primitieve typen.

Je kunt het bovenstaande artikel volgen met Visual Studio Code op ons YouTube-kanaal. Bekijk ook het YouTube-kanaal.

YouTube Video