Articles
Introduzione a JavaScript
Oggetti wrapper in JavaScript

Oggetti wrapper in JavaScript

Questo articolo spiega gli oggetti wrapper in JavaScript.

YouTube Video

Oggetti wrapper

JavaScript ha tipi primitivi e oggetti per gestirli (oggetti wrapper).

Tipi primitivi

I tipi primitivi rappresentano un valore singolo e sono semplici e leggeri. Questi sono immutabili (immutabili) e non hanno direttamente metodi o proprietà degli oggetti, ma possono essere temporaneamente convertiti in oggetti involucro per le operazioni.

string e number sono esempi di tipi primitivi. D'altra parte, gli oggetti wrapper iniziano con una lettera maiuscola, come String e Number.

Oggetti Wrapper

Per manipolare i tipi primitivi, JavaScript genera temporaneamente oggetti wrapper (Object wrapper). Gli oggetti wrapper contengono metodi e proprietà per i tipi primitivi.

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 è un tipo di oggetto che avvolge un tipo primitivo number. Creando esplicitamente un oggetto Number, puoi gestire i numeri come un number, ma è generalmente consigliato utilizzare il tipo primitivo number.

typeof numObject è "object", ma typeof 42 è "number".

  • Tieni presente che usare l'operatore new per generare un nuovo oggetto wrapper produce un risultato diverso rispetto alla chiamata di Number come funzione. Quando viene chiamato come una funzione, restituisce un tipo primitivo number.

String 

1let strObject = new String("Hello"); // Wrapper object
2
3console.log(typeof strObject);    // object
4console.log(strObject.valueOf()); // Hello
  • È un tipo di oggetto che avvolge un tipo primitivo string. Usando un oggetto String, puoi accedere alle proprietà e ai metodi delle stringhe, ma di solito viene utilizzato un tipo primitivo string.

typeof strObject è "object", ma typeof "Hello" è "string".

  • Come Number, chiamare String come funzione restituisce un tipo primitivo string.

Boolean 

1let boolObject = new Boolean(true); // Wrapper object
2
3console.log(typeof boolObject);    // object
4console.log(boolObject.valueOf()); // true
  • È un tipo di oggetto che avvolge un tipo primitivo boolean. Puoi anche creare esplicitamente un oggetto Boolean, ma di solito si utilizza un tipo primitivo boolean.

typeof boolObject è "object", ma typeof true è "boolean".

  • Simile a Number, chiamare Boolean come funzione restituisce un tipo primitivo 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()); //
  • Puoi usare Object per creare un oggetto wrapper per Symbol, ma generalmente si utilizza direttamente il tipo primitivo Symbol.

Differenze tra Tipi Primitivi e Oggetti Wrapper

  • I tipi primitivi sono leggeri ed efficienti in termini di memoria, ma non possiedono proprietà o metodi diretti. Tuttavia, in JavaScript, anche con i tipi primitivi, oggetti wrapper temporanei vengono creati automaticamente quando necessario per fornire metodi e proprietà.
1let text = "Hello";
2
3// A temporary String object is created,
4// allowing access to the length property
5console.log(text.length);
  • Gli oggetti wrapper sono oggetti generati esplicitamente che possono influire su memoria e prestazioni, quindi si consiglia generalmente di utilizzare i tipi primitivi.

Conclusione

  • Tipi Primitivi: Tipi leggeri come number, string, boolean, null, undefined e symbol che non hanno metodi diretti.
  • Oggetti Wrapper: Oggetti come Number, String e Boolean che vengono temporaneamente convertiti da tipi primitivi.

Puoi seguire l'articolo sopra utilizzando Visual Studio Code sul nostro canale YouTube. Controlla anche il nostro canale YouTube.

YouTube Video

Tipi di dati in JavaScriptOperatori in JavaScript