Tipi in TypeScript: string, number, boolean e altri

I tipi di TypeScript descrivono che tipo di valore può contenere una variabile. Scrivi un tipo dopo i due punti, let name: string, e il compilatore rifiuta qualsiasi codice che ci metta un valore del tipo sbagliato. I tipi di base sono i sette primitivi di JavaScript più i tipi oggetto per array e oggetti.

let title: string = "TypeScript";
let version: number = 7;
let isStrict: boolean = true;
let big: bigint = 9007199254740993n;
let id: symbol = Symbol("id");
let nothing: null = null;
let notSet: undefined = undefined;

let scores: number[] = [90, 72, 85];
let user: { name: string; age: number } = { name: "Ada", age: 36 };

console.log(title, version, isStrict, big, id);
console.log(nothing, notSet);
console.log(scores, user);

Le annotazioni vengono controllate in compilazione e poi rimosse. Il programma che viene eseguito è JavaScript semplice.

I tipi primitivi

I nomi dei tipi sono minuscoli. typeof a runtime restituisce le stesse parole per la maggior parte di essi, quindi typeof x === "number" è il modo per controllare il tipo primitivo di un valore mentre il programma è in esecuzione.

Annotazioni di tipo

Un'annotazione è : Type dopo una variabile, un parametro o l'elenco dei parametri di una funzione. I parametri sono il punto in cui le annotazioni contano di più, perché TypeScript non può indovinare cosa passerà chi chiama.

function describe(name: string, age: number, admin: boolean): string {
    return `${name} (${age})${admin ? " [admin]" : ""}`;
}

let label: string = describe("Ada", 36, true);
console.log(label); // Ada (36) [admin]

// Without an annotation, TypeScript infers the type from the value:
let count = 10; // count: number
count = count + 1;
console.log(count); // 11

Quando una variabile viene inizializzata sulla stessa riga, l'annotazione di solito è superflua: let count = 10 ha già il tipo number. Le regole per omettere i tipi sono nella pagina sull'inferenza dei tipi.

Un tipo sbagliato è un errore di compilazione

Assegna un valore del tipo sbagliato e il compilatore si ferma prima che venga eseguito qualsiasi cosa:

// This does not compile: a string is not a number.
let port: number = 8080;
port = "3000";
console.log(port);

Il compilatore stampa:

index.ts(3,1): error TS2322: Type 'string' is not assignable to type 'number'.

La soluzione è convertire il valore, port = Number("3000"), o cambiare l'annotazione se la variabile deve davvero contenere testo.

number: non esiste un tipo intero

JavaScript memorizza ogni numero come valore in virgola mobile a 64 bit, quindi TypeScript ha un solo tipo number. Gli interi sono esatti fino a Number.MAX_SAFE_INTEGER (2 ** 53 - 1). Oltre quel limite, usa bigint.

let price: number = 19.99;
let quantity: number = 3; // also number: no int type

console.log(Number.isInteger(quantity)); // true
console.log(Number.isInteger(price));    // false
console.log(Math.trunc(7 / 2));          // 3 (integer division)
console.log(0.1 + 0.2);                  // 0.30000000000000004

console.log(Number.MAX_SAFE_INTEGER);     // 9007199254740991
console.log(Number.MAX_SAFE_INTEGER + 2); // 9007199254740992 (wrong)

let exact: bigint = 9007199254740991n + 2n;
console.log(exact); // 9007199254740993n

// @ts-expect-error: bigint and number cannot be mixed
const mixed = () => exact + 1;
console.log(exact + BigInt(1), Number(exact)); // 9007199254740994n 9007199254740992

bigint e number non si mescolano: exact + 1 è un errore di compilazione (TS2365: Operator '+' cannot be applied to types 'bigint' and '1'., dove '1' è il tipo letterale di 1) e, se mai venisse eseguito, anche un TypeError a runtime. Converti esplicitamente uno dei due lati con BigInt(1) o Number(exact), sapendo che Number arrotonda i valori oltre l'intervallo sicuro.

Se vuoi un tipo che accetti solo numeri interi, TypeScript non può esprimerlo per valori arbitrari. Valida con Number.isInteger nel punto in cui il valore entra nel programma.

boolean

boolean ha esattamente due valori, true e false. I valori che sono solo truthy (1, "yes") non sono booleani, quindi trasformali in uno con Boolean(x) o x !== 0.

let loggedIn: boolean = false;
const items: string[] = ["a", "b"];

const hasItems: boolean = items.length > 0;
const hasName: boolean = Boolean("Ada");

console.log(loggedIn, hasItems, hasName); // false true true

null e undefined

Con strict attivo (il predefinito da TypeScript 6.0), null e undefined sono tipi separati e non fanno parte di string, number o di qualsiasi altro tipo. Una variabile che può essere vuota lo dichiara con una union:

let nickname: string | undefined;
console.log(nickname); // undefined

nickname = "Ace";
console.log(nickname.toUpperCase()); // ACE

let middleName: string | null = null;
console.log(middleName ?? "(none)"); // (none)

Leggere una proprietà di un valore che potrebbe essere undefined è un errore di compilazione finché non lo controlli. La pagina su null e undefined tratta i controlli, ?. e ??.

Array e oggetti in breve

Tutto ciò che non è un primitivo è un tipo oggetto. Le tre forme che incontri per prime:

let tags: string[] = ["ts", "js"];               // array of strings
let point: { x: number; y: number } = { x: 1, y: 2 }; // object with two number properties
let greet: (name: string) => string = (n) => `hi ${n}`; // function type

Ognuna ha la sua pagina: array, tuple (array a lunghezza fissa), tipi oggetto e tipi funzione.

string, number, boolean vs String, Number, Boolean

I nomi con la maiuscola sono i tipi degli oggetti wrapper di JavaScript (new String("x")), non dei valori normali. Annota con i nomi minuscoli.

// This does not compile: String (the wrapper) is not string (the primitive).
const wrapped: String = "text";
const plain: string = wrapped;
console.log(plain);

index.ts(3,7): error TS2322: Type 'String' is not assignable to type 'string'.
  'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.

Cambia String in string sulla prima riga e il blocco viene eseguito. Lo stesso vale per Number, Boolean, Symbol e BigInt. (Object è un caso a parte: accetta quasi qualsiasi valore, primitivi inclusi; vedi i tipi oggetto.)

Altri tipi predefiniti

Alcuni altri tipi compaiono presto. Ognuno ha la sua pagina.