Tipi di Dati in TypeScript

Articles

Questo articolo spiega i tipi di dati in TypeScript.

YouTube Video

Tipi di Dati in TypeScript

TypeScript offre una varietà di tipi di dati. Questo permette di definire tipi rigorosi per variabili, argomenti delle funzioni e valori di ritorno. Di seguito sono riportati i principali tipi di dati e il loro utilizzo.

Tipi primitivi

Tipo number

1let age: number = 25;
2console.log(age);          // Outputs: 25
3console.log(typeof age);    // Outputs: number

number è un tipo utilizzato per gestire valori numerici, inclusi interi e numeri in virgola mobile (decimali). Gestire valori che superano determinati limiti porta a Infinity o NaN (Not-a-Number).

1// Decimal calculations
2console.log(0.1 + 0.2 === 0.3); // false
3console.log(0.1 + 0.2); // 0.30000000000000004
4
5// Calculations with large numbers
6console.log(9007199254740991 + 1); // correct value
7console.log(9007199254740991 + 2); // incorrect value

In TypeScript, i numeri sono rappresentati come numeri in virgola mobile. Questo può causare lievi imprecisioni nei risultati dei calcoli.
Quando sono richiesti calcoli precisi, come gli importi finanziari, è necessario evitare errori di arrotondamento come questo. Ad esempio, puoi utilizzare BigInt o toFixed(), oppure regolare le cifre decimali utilizzando librerie come decimal.js.

Tipo string

Il tipo string gestisce i dati testuali.

1let greeting: string = "Hello, TypeScript!";
2console.log(greeting);     // Outputs: Hello, TypeScript!
3console.log(typeof greeting);  // Outputs: string

Tipo booleano (Tipo Logico)

Il tipo boolean ha due valori: true o false.

1let isOpen: boolean = true;
2console.log(isOpen);       // Outputs: true
3console.log(typeof isOpen);    // Outputs: boolean

null e undefined

null rappresenta un 'valore inesistente', mentre undefined rappresenta un 'valore non definito'.

1let emptyValue: null = null;
2let notDefined: undefined = undefined;
3
4console.log(emptyValue);       // Outputs: null
5console.log(typeof emptyValue);    // Outputs: object (JavaScript specification)
6
7console.log(notDefined);       // Outputs: undefined
8console.log(typeof notDefined);    // Outputs: undefined

Array

In TypeScript, è possibile specificare il tipo degli elementi di un array. number[] è un array di numeri, mentre string[] è un array di stringhe.

1let numbers: number[] = [1, 2, 3, 4];
2console.log(numbers);        // Outputs: [1, 2, 3, 4]
3console.log(typeof numbers); // Outputs: object
4
5let words: string[] = ["TypeScript", "JavaScript"];
6console.log(words);          // Outputs: ["TypeScript", "JavaScript"]
7console.log(typeof words);   // Outputs: object

Tupla

Una tupla è un array con elementi di tipi diversi.

1let person: [string, number] = ["Alice", 30];
2console.log(person);         // Outputs: ["Alice", 30]
3console.log(typeof person);  // Outputs: object

Enum

enum definisce un insieme di costanti denominate.

1enum Color {
2    Red,
3    Green,
4    Blue
5}
6
7let favoriteColor: Color = Color.Green;
8console.log(favoriteColor);  // Outputs: 1 (Defaults start from 0)
9console.log(typeof favoriteColor); // Outputs: number

any

Il tipo any può contenere qualsiasi tipo di valore ed è utilizzato quando si desidera disabilitare il controllo del tipo.

1let anything: any = "Hello";
2console.log(anything);       // Outputs: Hello
3console.log(typeof anything);    // Outputs: string
4
5anything = 42;
6console.log(anything);       // Outputs: 42
7console.log(typeof anything);    // Outputs: number

Tipo Union

Utilizzando i tipi Union, è possibile definire variabili in grado di contenere uno tra più tipi.

1let identifier: number | string = "ID_12345";
2console.log(identifier);     // Outputs: ID_12345
3console.log(typeof identifier);  // Outputs: string
4
5identifier = 12345;
6console.log(identifier);     // Outputs: 12345
7console.log(typeof identifier);  // Outputs: number

Riepilogo

number, string, boolean: Tipi primitivi.
null, undefined: Valori speciali.
Array: Un array con annotazioni di tipo.
Tuple: Un array con elementi di tipi diversi.
enum: Un tipo enumerato.
any: Qualsiasi tipo.
Union: Una variabile che può assumere uno tra più tipi.

Utilizzando questi tipi di dati, TypeScript migliora la sicurezza dei tipi, rendendo più facile prevenire errori durante lo sviluppo.

Oggetti wrapper

Wrapper Objects in TypeScript sono oggetti creati automaticamente per trattare i tipi di dati primitivi come oggetti. I tipi primitivi consentono operazioni leggere e veloci, mentre i tipi di oggetto hanno metodi e proprietà, permettendo operazioni più ricche.

In JavaScript (e TypeScript), ci sono oggetti wrapper corrispondenti ai tipi primitivi come string, number e boolean. Vengono creati utilizzando funzioni costruttore chiamate rispettivamente String, Number e Boolean.

Di seguito sono riportati esempi di oggetti wrapper.

Oggetto String

L'oggetto String fornisce proprietà e metodi per le stringhe.

1let strPrimitive: string = "Hello, World!";
2let strObject: String = new String("Hello, World!");
3
4console.log(strPrimitive);         // Outputs: Hello, World!
5console.log(typeof strPrimitive);  // Outputs: string
6
7console.log(strObject);            // Outputs: [String: 'Hello, World!']
8console.log(typeof strObject);     // Outputs: object

Caratteristiche:

A differenza del tipo primitivo string, un oggetto String è trattato come object da typeof.
Gli oggetti wrapper sono utili quando si manipolano stringhe o si chiamano metodi su di esse.

Oggetto Number

L'oggetto Number fornisce proprietà e metodi per i numeri.

1let numPrimitive: number = 42;
2let numObject: Number = new Number(42);
3
4console.log(numPrimitive);         // Outputs: 42
5console.log(typeof numPrimitive);  // Outputs: number
6
7console.log(numObject);            // Outputs: [Number: 42]
8console.log(typeof numObject);     // Outputs: object

Caratteristiche:

L'oggetto Number, come wrapper per i numeri, include metodi per operazioni numeriche (es. toFixed).

Oggetto Boolean

L'oggetto Boolean fornisce proprietà e metodi per i valori booleani.

1let boolPrimitive: boolean = true;
2let boolObject: Boolean = new Boolean(true);
3
4console.log(boolPrimitive);        // Outputs: true
5console.log(typeof boolPrimitive); // Outputs: boolean
6
7console.log(boolObject);           // Outputs: [Boolean: true]
8console.log(typeof boolObject);    // Outputs: object

Caratteristiche:

L'oggetto Boolean è un wrapper per il tipo primitivo boolean ed è trattato come object.

Differenze tra Oggetti Wrapper e Tipi Primitivi

Poiché gli oggetti wrapper sono trattati come oggetti, c'è un leggero calo delle prestazioni, ma sono possibili operazioni più funzionali grazie alle proprietà e ai metodi aggiunti. Inoltre, ci sono differenze nel confronto utilizzando == e ===.

1let numPrimitive: number = 123;
2let numObject: Number = new Number(123);
3
4console.log('==  : ', numPrimitive == numObject);  // Outputs: true (Value comparison)
5console.log('=== : ', numPrimitive === numObject); // Outputs: false (Due to differing types)

Caratteristiche:

== confronta i valori, mentre === confronta in modo stretto includendo i tipi. === restituisce false quando si confrontano oggetti wrapper con tipi primitivi.

Conversione di Tipo

In TypeScript, è importante gestire correttamente le conversioni di tipo implicite e esplicite.

Conversione di Tipo Implicita

In TypeScript, le conversioni di tipo implicite dovrebbero essere evitate il più possibile per garantire la sicurezza dei tipi.

1const result: string = 5 + "5"; // "55" (the number is converted to a string)
2
3console.log(result);

In questo esempio, il numero 5 viene convertito implicitamente in una stringa, risultando nella stringa "55".

Conversione di Tipo Esplicita

In TypeScript, utilizza annotazioni di tipo o funzioni di conversione di tipo per eseguire conversioni in modo sicuro.

1const num: string = "123";
2const convertedNum: number = Number(num); // Converts "123" to the number 123
3
4console.log(typeof num);
5console.log(typeof convertedNum);

In questo esempio, la funzione Number() viene utilizzata per convertire esplicitamente la stringa "123" nel numero 123.

Controllo dei Tipi

In TypeScript, puoi utilizzare l'operatore typeof per verificare il tipo di dato di una variabile.

 1// Output: The type of 42 is: number
 2console.log('The type of 42             is:', typeof 42);
 3
 4// Output: The type of 42 is: bigint
 5console.log('The type of 42n            is:', typeof 42n);
 6
 7// Output: The type of "hello" is: string
 8console.log('The type of "hello"        is:', typeof "hello");
 9
10// Output: The type of true is: boolean
11console.log('The type of true           is:', typeof true);
12
13// Output: The type of undefined is: undefined
14console.log('The type of undefined      is:', typeof undefined);
15
16// Output: The type of null is: object
17console.log('The type of null           is:', typeof null);
18
19// Output: The type of Symbol() is: symbol
20console.log('The type of Symbol()       is:', typeof Symbol());
21
22// Output: The type of {} is: object
23console.log('The type of {}             is:', typeof {});
24
25// Output: The type of function () {} is: function
26console.log('The type of function () {} is:', typeof function () {});

In TypeScript, puoi utilizzare typeof per controllare i tipi, ma per un controllo più preciso è anche consigliato utilizzare gli operatori instanceof o is.

Riepilogo

Gli oggetti wrapper sono trattati come oggetti perché forniscono metodi e proprietà aggiuntive per i tipi primitivi.
String, Number e Boolean sono esempi rappresentativi di oggetti wrapper.
A differenza dei tipi primitivi, gli oggetti wrapper sono identificati come object da typeof.

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

YouTube Video

Fondamenti di TypeScript Operatori in TypeScript