Tipi primitivi di dati in TypeScript

Nella lezione precedente abbiamo visto che TypeScript può determinare automaticamente il tipo di una variabile attraverso la Type Inference, oppure che possiamo specificarlo esplicitamente attraverso una Type Annotation.

Ora possiamo approfondire i principali tipi primitivi di dati disponibili in TypeScript.

I tipi primitivi rappresentano i valori più semplici disponibili in TypeScript. Tra quelli più utilizzati troviamo:

Vediamoli in dettaglio di seguito.

Il tipo string

Il tipo string rappresenta una stringa di testo.

Possiamo specificarlo con una Type Annotation:

let nome: string = "Andrea";
let messaggio: string = "Ciao!";

Sono valide le stringhe racchiuse tra apici singoli, doppi o backtick:

let nome: string = "Andrea";
let cognome: string = 'Rossi';
let frase: string = `Ciao ${nome}`;

Una variabile di tipo string non può contenere un numero:

let nome: string = "Andrea";

nome = 10;

TypeScript segnala un errore perché 10 è un number, non una string.

Nella maggior parte dei casi, però, non è necessario specificare il tipo manualmente:

const nome = "Andrea";

Il tipo number

Il tipo number rappresenta i numeri.

In TypeScript, sia gli interi sia i numeri decimali utilizzano il tipo number:

let eta: number = 30;
let prezzo: number = 19.99;
let temperatura: number = -5;

Non esistono quindi tipi separati come int e float per i normali numeri JavaScript (che abbiamo approfondito nella lezione sulle tipologie di dati in JavaScript).

Possiamo utilizzare anche espressioni matematiche:

const prezzo: number = 50;
const iva: number = 10;

const totale: number = prezzo + iva;

Anche in questo caso TypeScript può dedurre automaticamente il tipo:

const totale = prezzo + iva;

Il tipo boolean

Il tipo boolean rappresenta un valore che può essere soltanto true o false. Ad esempio:

let maggiorenne: boolean = true;
let online: boolean = false;

Anche boolean viene normalmente identificato automaticamente:

const attivo = true;

TypeScript sa che attivo è un valore booleano.

Possiamo quindi utilizzarlo nelle condizioni:

const maggiorenne = true;

if (maggiorenne) {
    console.log("Accesso consentito");
}

I tipi null e undefined

JavaScript utilizza null e undefined per rappresentare, in situazioni diverse, l'assenza di un valore. In TypeScript questi valori hanno un ruolo particolare perché possono essere utilizzati anche come tipi.

Il tipo undefined

Il tipo undefined indica generalmente che un valore non è stato assegnato.

Per esempio:

let nome: string | undefined;

La sintassi dell'esempio significa che la variabile può contenere una stringa oppure undefined. Il simbolo | indica che la variabile può avere uno dei tipi specificati. Approfondiremo l'argomento sugli operatori di unione nelle prossime lezioni.

Possiamo successivamente assegnarle un valore:

nome = "Andrea";

Oppure undefined:

nome = undefined;

Il tipo null

Il tipo null rappresenta invece un valore esplicitamente impostato come assente.

Ad esempio:

let risultato: string | null = null;

In questo caso risultato può contenere una stringa oppure null.

Successivamente possiamo assegnare una stringa:

risultato = "Operazione completata";

Il tipo null viene utilizzato specialmente quando vogliamo indicare esplicitamente che un valore non è disponibile.

Opzioni in tsconfig.json

Il comportamento di null e undefined dipende in particolare dall'opzione strictNullChecks del file tsconfig.json (il file di configurazione del progetto TypeScript, che abbiamo visto nella lezione sulla configurazione del primo progetto in TypeScript).

Potremmo trovare in tsconfig.json:

{
    "compilerOptions": {
        "strictNullChecks": true
    }
}

Quando questa opzione è attiva, null e undefined vengono trattati come tipi distinti dagli altri tipi. Per esempio, non possiamo assegnare il valore null ad una variabile di tipo string:

let nome: string = "Andrea";

nome = null; // Errore

Per permetterlo dobbiamo dichiararlo esplicitamente:

let nome: string | null = null;

Il tipo bigint

Il tipo bigint permette di rappresentare numeri interi molto grandi, oltre il limite di valori normalmente disponibile per il tipo number.

Un valore bigint può essere creato aggiungendo n alla fine di un numero intero:

const numero: bigint = 9007199254740991n;

Possiamo eseguire operazioni tra valori bigint:

const a = 100n;
const b = 200n;

const risultato = a + b;

Il risultato dell'operazione nell'esempio è 300n.

I tipi bigint e number sono però valori distinti e non possono essere combinati direttamente nelle normali operazioni:

const numero = 10;
const grandeNumero = 20n;

const risultato = numero + grandeNumero; // Errore

Se abbiamo bisogno di utilizzare entrambi, dobbiamo prima effettuare una conversione appropriata.

Il tipo symbol

Il tipo symbol rappresenta un valore identificativo univoco. Possiamo creare un symbol attraverso la funzione Symbol():

const id = Symbol();

Anche se creiamo due Symbol apparentemente identici, i valori ottenuti sono differenti:

const id1 = Symbol("id");
const id2 = Symbol("id");

console.log(id1 === id2); // False

Questo perché ogni Symbol rappresenta un identificatore univoco.

I symbol vengono utilizzati soprattutto in situazioni specifiche, per esempio quando è necessario creare proprietà univoche negli oggetti. Nello sviluppo quotidiano sono molto meno comuni rispetto a string, number e boolean.