Tipi di Dati in JavaScript

Introduzione ai Tipi di Dati in JavaScript

JavaScript è un linguaggio a tipizzazione dinamica: non si dichiara mai il tipo di una variabile, e una variabile può contenere un valore di qualsiasi tipo — persino di un tipo diverso in seguito. Poiché è il motore, non il programmatore, a tracciare i tipi in fase di esecuzione, conoscere esattamente il comportamento di ciascun tipo è ciò che distingue il codice prevedibile dai bug sconcertanti.

let x = 42;        // x is now a number
x = "forty-two";   // the same variable now holds a string — perfectly legal

Il linguaggio definisce otto tipi di dati: sette primitivi e uno non primitivo (object). La pagina seguente illustra ciascuno di essi, come verificarli con typeof, e le regole di coercizione che mettono in difficoltà la maggior parte dei principianti.

Tipi di Dati Primitivi

Un primitivo è un valore che non è un object e non ha metodi propri. I primitivi sono immutabili — non è possibile modificare un valore primitivo, ma solo sostituire la variabile che lo contiene.

• Number: Valori interi o in virgola mobile, più i valori speciali Infinity, -Infinity e NaN (Not a Number). Vedi Numbers.
• String: Dati testuali, racchiusi tra virgolette doppie, singole o backtick. Vedi Strings.
• Boolean: Uno dei due valori logici, true o false.
• Undefined: Una variabile che è stata dichiarata ma a cui non è stato assegnato un valore.
• Null: L'assenza intenzionale di qualsiasi valore object.
• BigInt: Interi oltre il limite sicuro del tipo Number. Vedi BigInt.
• Symbol: Un identificatore garantito come unico, usato principalmente come chiave di object. Vedi Symbol type.

Tipo di Dati Non Primitivo

• Object: Una raccolta di proprietà chiave/valore utilizzata per modellare dati complessi. Array, funzioni, date e la maggior parte dei built-in sono tutti object sotto il cofano. Vedi Objects.

Verificare un Tipo con typeof

Per scoprire il tipo di un valore, JavaScript mette a disposizione l'operatore typeof. Restituisce una string come "number", "string" o "boolean".

Due risultati sorprendono i neofiti:

• typeof null restituisce "object". Si tratta di un bug della primissima versione di JavaScript che non può essere mai corretto senza rompere il web — è sufficiente memorizzarlo.
• typeof applicato a una funzione restituisce "function". Le funzioni sono in realtà object, ma typeof le tratta in modo speciale per consentire di rilevare i callable.

Lavorare con i Tipi di Dati Primitivi

Di seguito, ogni primitivo è mostrato con un esempio minimo eseguibile.

Number: La Base delle Operazioni Matematiche

let age = 25;       // Integer
let price = 99.99;  // Floating-point
console.log(typeof age);   // "number"
console.log(0.1 + 0.2);    // 0.30000000000000004  (floating-point rounding)

Un unico tipo number copre sia gli interi che i decimali. Poiché i numeri usano la virgola mobile a 64 bit, la matematica frazionaria non è sempre esatta — 0.1 + 0.2 è l'esempio classico. I numeri includono anche Infinity e NaN; NaN è notoriamente non uguale a se stesso, quindi si usa Number.isNaN(x) per verificarlo.

String: Molto Più che Semplice Testo

let greeting = "Hello, world!";
let name = 'Ada';
let response = `Hi, ${name}!`; // template literal with interpolation
console.log(typeof greeting); // "string"
console.log(response);        // "Hi, Ada!"

Le string sono immutabili: metodi come toUpperCase() restituiscono una nuova string anziché modificare quella originale. Le string con backtick (template literal) permettono di incorporare ${espressioni} e di estendersi su più righe. Esplora il toolkit completo in Strings.

Boolean: Il Selettore Binario di Decisioni

let isAvailable = true;
let age = 25;
let isAdult = age >= 18; // comparisons produce booleans
console.log(typeof isAvailable); // "boolean"
console.log(isAdult);            // true

I boolean guidano ogni condizionale e ciclo. Qualsiasi valore può anche essere coercizzato in un boolean — vedi la tabella truthy/falsy qui sotto.

Undefined e Null: L'Assenza di Valore

let notAssigned;          // declared but never given a value
let emptyOnPurpose = null; // deliberately "nothing"
console.log(typeof notAssigned);  // "undefined"
console.log(typeof emptyOnPurpose); // "object" (the typeof null quirk)
console.log(null == undefined);   // true  (loose equality)
console.log(null === undefined);  // false (strict equality — different types)

Usa undefined per "nessun valore ancora" (è quello che JavaScript assegna automaticamente) e null per "intenzionalmente vuoto". Sono uguali con l'uguaglianza lasca (==) ma non con quella stretta (===).

BigInt: Gestire Numeri Grandi

const big = 9007199254740991n; // note the trailing n
console.log(typeof big);     // "bigint"
console.log(big + 1n);       // 9007199254740992n

Number può rappresentare in modo sicuro solo interi fino a Number.MAX_SAFE_INTEGER (circa 9 quadrilioni). Per valori più grandi — crittografia, ID ad alta precisione — si usa BigInt, scritto con una n finale. Non è possibile mescolare BigInt e Number nella stessa operazione aritmetica senza una conversione esplicita. Ulteriori dettagli in BigInt.

Symbol: Garantire l'Unicità

Ogni chiamata a Symbol() restituisce un valore nuovo e unico, anche se il testo descrittivo è identico. I Symbol vengono usati come chiavi di object a prova di collisione, ad esempio per allegare metadati senza entrare in conflitto con le normali chiavi string. Vedi Symbol type.

Object: I Mattoni delle Strutture Complesse

In JavaScript, gli object memorizzano raccolte di dati correlati come coppie chiave/valore e costituiscono la base per array, funzioni e la maggior parte dei built-in.

let person = {
  name: "John",
  age: 30,
  isStudent: false
};
console.log(typeof person);     // "object"
console.log(typeof [1, 2, 3]);  // "object"  (arrays are objects)
console.log(Array.isArray([1])); // true — the reliable way to detect arrays

Gli object sono mutabili — a differenza dei primitivi, è possibile aggiungere, modificare ed eliminare le loro proprietà. Vengono confrontati per riferimento, non per valore: due object con contenuto identico non sono uguali con ===.

Coercizione e Conversione di Tipo

Poiché JavaScript è tipizzato dinamicamente, spesso coercizza un valore da un tipo a un altro durante un'operazione. Questo è comodo ma è una fonte comune di sorprese.

In caso di dubbio, converti esplicitamente con Number(), String() o Boolean() invece di affidarti alla coercizione automatica.

Valori Truthy e Falsy

Quando un valore viene usato dove ci si aspetta un boolean (in un if, &&, ||), viene coercizzato. Esattamente sei valori sono falsy; tutto il resto è truthy:

// falsy: false, 0, "", null, undefined, NaN
if ("") console.log("won't run");      // "" is falsy
if ("0") console.log("this runs");     // non-empty string is truthy
if ([]) console.log("this runs too");  // empty array is truthy!

Un errore frequente: un array vuoto [] e un object vuoto {} sono truthy, anche se "" e 0 sono falsy.

Riepilogo

JavaScript ha otto tipi di dati — sette primitivi (number, string, boolean, undefined, null, bigint, symbol) e l'object. typeof riporta il tipo, con le ben note stranezze per cui typeof null è "object" e le funzioni restituiscono "function". I primitivi sono immutabili e confrontati per valore; gli object sono mutabili e confrontati per riferimento. Padroneggia la coercizione e le regole truthy/falsy e la maggior parte del "JavaScript strano" scomparirà. Successivamente, scopri come i valori vengono memorizzati nelle Variabili.

Pratica