Tipi di Base

Primitivi

let name: string = "Alice";
let age: number = 25;
let active: boolean = true;
let data: null = null;
let x: undefined = undefined;

Tipi Speciali

any	Disabilita il controllo dei tipi
unknown	`any` type-safe (va ristretto prima dell'uso)
void	Nessun valore di ritorno
never	La funzione non ritorna mai (eccezione / ciclo infinito)
object	Qualsiasi tipo non primitivo

Array e Tuple

Array

let nums: number[] = [1, 2, 3];
let names: Array = ["a", "b"];
let matrix: number[][] = [[1, 2], [3, 4]];

Tuple

let pair: [string, number] = ["age", 25];
let rgb: [number, number, number] = [255, 0, 0];

// Named tuples (etichette per la leggibilità)
type Point = [x: number, y: number];

Interfacce

Definizione e Utilizzo

interface User {
  name: string;
  age: number;
  email?: string;        // opzionale
  readonly id: number;   // immutabile
}

const user: User = { name: "Alice", age: 25, id: 1 };

Estensione di Interfacce

interface Employee extends User {
  role: string;
  department: string;
}

Firme di Indice

interface StringMap {
  [key: string]: string;
}
const env: StringMap = { NODE_ENV: "prod" };

Alias di Tipo

type ID = string | number;
type Point = { x: number; y: number };
type Callback = (data: string) => void;

Interface vs Type

interface	Estendibile con `extends`, dichiarazione multipla
type	Unioni, intersezioni, tipi mappati, tuple

Unioni e Intersezioni

Tipi Unione

type Status = "loading" | "success" | "error";
type ID = string | number;

function print(val: string | number) {
  if (typeof val === "string") {
    console.log(val.toUpperCase());
  }
}

Tipi Intersezione

type Named = { name: string };
type Aged = { age: number };
type Person = Named & Aged;
// Person ha sia name che age

Unioni Discriminate

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rect"; w: number; h: number };

function area(s: Shape): number {
  switch (s.kind) {
    case "circle": return Math.PI * s.radius ** 2;
    case "rect":   return s.w * s.h;
  }
}

Funzioni

Parametri e Tipo di Ritorno

function add(a: number, b: number): number {
  return a + b;
}

// Arrow function
const greet = (name: string): string =>
  `Hello, ${name}!`;

// Parametri opzionali e predefiniti
function log(msg: string, level?: string): void {}
function log(msg: string, level = "info"): void {}

Overload di Funzioni

function parse(input: string): number;
function parse(input: number): string;
function parse(input: string | number) {
  return typeof input === "string"
    ? parseInt(input)
    : input.toString();
}

Parametri Rest

function sum(...nums: number[]): number {
  return nums.reduce((a, b) => a + b, 0);
}

Generics

Funzioni Generiche

function identity(value: T): T {
  return value;
}
identity("hello"); // esplicito
identity(42);              // inferito: number

Interfacce Generiche e Vincoli

interface Box {
  value: T;
}
const box: Box = { value: 42 };

// Vincoli
function getLen(
  item: T
): number {
  return item.length;
}

Enum

enum Direction { Up, Down, Left, Right }
let d: Direction = Direction.Up; // 0

enum Status {
  Active = "ACTIVE",
  Inactive = "INACTIVE",
}
let s: Status = Status.Active; // "ACTIVE"

// const enum (inline in fase di compilazione)
const enum Color { Red, Green, Blue }

Type Guard

Guard Predefiniti

// typeof
if (typeof x === "string") { /* x: string */ }

// instanceof
if (err instanceof Error) { /* err: Error */ }

// in
if ("name" in obj) { /* obj ha name */ }

Type Guard Personalizzato

function isString(val: unknown): val is string {
  return typeof val === "string";
}

if (isString(input)) {
  input.toUpperCase(); // ristretto a string
}

Funzioni di Asserzione

function assertDefined(
  val: T | null
): asserts val is T {
  if (val === null) throw new Error("null");
}

Tipi Utility

Partial<T>	Tutte le proprietà opzionali
Required<T>	Tutte le proprietà obbligatorie
Readonly<T>	Tutte le proprietà in sola lettura
Pick<T, K>	Seleziona le proprietà K da T
Omit<T, K>	Rimuove le proprietà K da T
Record<K, V>	Oggetto con chiavi K e valori V
Exclude<T, U>	Tipi in T non presenti in U
Extract<T, U>	Tipi in T presenti anche in U
NonNullable<T>	Esclude null e undefined da T
ReturnType<T>	Tipo di ritorno della funzione T
Parameters<T>	Tipi dei parametri della funzione T
Awaited<T>	Rimuove il wrapping di Promise

Esempi di Tipi Utility

interface User { name: string; age: number; email: string }

type UserPreview = Pick;
type UserUpdate = Partial;
type UserMap = Record;
type CreateUser = Omit;

RIFERIMENTO RAPIDO TYPESCRIPT