Corso TypeScript

Cheatsheet

Un riferimento veloce — la sintassi essenziale di TypeScript moderno su una pagina sola. Usa Ctrl/Cmd + P per stamparla.

Torna al corso Playground

Annotazioni e Tipi Primitivi

Annotazione esplicita

const username: string = "Alice";
const score: number = 100;
const isActive: boolean = true;

Aggiungi i due punti (:) seguiti dal tipo dopo il nome della variabile.

Inferenza di tipo

const inferredName = "Bob"; // Rilevato come string
let inferredNum = 42;       // Rilevato come number

TypeScript deduce automaticamente il tipo in base al valore iniziale.

Array e Tuple

Array (omogenei)

const numbers: number[] = [1, 2, 3];
const strings: Array<string> = ["a", "b", "c"];

Due sintassi equivalenti per definire collezioni dello stesso tipo.

Tuple (dimensione fissa)

const response: [number, string] = [200, "OK"];
const point: [number, number, number] = [10, 20, 30];

Elementi a posizione fissa con tipi specifici.

Type Alias e Interfacce

Interfacce (interface)

interface User {
  id: number;
  username: string;
  email?: string; // Proprietà opzionale
}

Ideali per definire oggetti espandibili tramite ereditarietà (extends).

Alias di Tipo (type)

type Point2D = {
  x: number;
  y: number;
};

type ID = string | number; // Unione

Permettono di rinominare qualsiasi tipo o definire unioni/intersezioni.

Unioni e Narrowing

Tipi Unione (Union)
```
let id: string | number;
id = "ABC"; // OK
id = 123;   // OK
```
Consente a una variabile di accettare più tipi alternativi.

Restringimento (Narrowing)

function printId(id: string | number) {
  if (typeof id === "string") {
    console.log(id.toUpperCase()); // id è stringa
  } else {
    console.log(id.toFixed());     // id è numero
  }
}

Permette di eseguire metodi specifici isolando il tipo a runtime.

Funzioni Tipizzate

Annotazioni parametri e ritorno

function greet(name: string, prefix?: string): string {
  return prefix ? `Hello, ${prefix} ${name}` : `Hello, ${name}`;
}

Usa il punto interrogativo (?) per contrassegnare un parametro come opzionale.

Firma di tipo (Function Type)

type MathOp = (a: number, b: number) => number;
const add: MathOp = (x, y) => x + y;

Estrae la firma di una funzione in un tipo riutilizzabile.

Generics

Funzione Generica

function identity<T>(arg: T): T {
  return arg;
}

const val = identity<number>(42);

Rende la funzione flessibile preservando l'informazione di tipo dinamica.

Interfaccia Generica

interface Box<T> {
  content: T;
}

const stringBox: Box<string> = { content: "Libro" };

Consente alla proprietà interna di adattarsi al tipo specificato.

Classi e Modificatori

Modificatori costruttore (parameter properties)
```
class User {
  constructor(public username: string, private role: string) {}
}
```
Dichiarazione concisa: crea e inizializza automaticamente i campi della classe.

Classi Astratte

abstract class Shape {
  abstract getArea(): number;
}
class Circle extends Shape {
  constructor(public radius: number) { super(); }
  getArea() { return Math.PI * this.radius ** 2; }
}

Non istanziabili direttamente, servono come modelli per le sottoclassi.

Tipi di Utility

Partial e Readonly

interface Task { id: number; title: string; }
type PartialTask = Partial<Task>; // Rende tutti i campi opzionali
type ReadonlyTask = Readonly<Task>; // Impedisce modifiche a runtime

Utility integrate per trasformare rapidamente le proprietà di un tipo.

Pick e Omit

interface User { id: number; name: string; email: string; }
type UserInfo = Pick<User, "name" | "email">; // Estrae campi
type NewUser = Omit<User, "id">;            // Esclude campi

Permettono di selezionare o escludere proprietà specifiche.

Tipi Avanzati e Guardie

Guardie di Tipo personalizzate
```
function isString(val: unknown): val is string {
  return typeof val === "string";
}
```
Usa il predicato 'x is Type' per forzare il narrowing nel codice chiamante.

Tipi Letterali e Const

type Direction = "up" | "down";
const config = {
  host: "localhost",
  port: 8080
} as const; // Rende l'intero oggetto readonly

Unioni di valori esatti e modificatore as const per costanti immutabili.

Template Literal Types

type Status = "success" | "error";
type Action = "click" | "hover";
type Event = \`\${Status}-\${Action}\`;

Costruisce nuovi tipi stringa combinando tipi letterali tramite interpolazione.

TypeScript · Cheatsheet — eLearner.app