0Pricing
Frontend Academy · Lezione

Interfacce e tipi di oggetto

Descrivere la struttura degli oggetti con interface e type, estendere le interfacce, usare proprietà opzionali con ? e readonly per l’immutabilità.

Interfacce e tipi di oggetto è una lezione Frontend Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Frontend Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Frontend Academy include 4 lezioni in totale.

interface vs type

Sia interface sia type descrivono la forma degli oggetti. La differenza principale è che le interfacce possono essere unite tramite la fusione delle dichiarazioni e sono generalmente preferite per definire la forma delle API pubbliche. Gli alias di tipo sono più flessibili per i tipi complessi.

// interface:
interface User {
  id: number;
  name: string;
}

// type alias (equivalent for objects):
type User = {
  id: number;
  name: string;
};

Definizione di un'interfaccia

Utilizzi interface per definire la forma di un oggetto. Per impostazione predefinita, tutte le proprietà sono obbligatorie. Separi le proprietà con i punti e virgola.

interface Product {
  id: number;
  name: string;
  price: number;
  description: string;
  inStock: boolean;
  category: string;
}

Proprietà facoltative e di sola lettura

Contrassegni le proprietà come facoltative con ?. Utilizzi readonly per impedire le modifiche. readonly impone l'immutabilità in fase di compilazione.

interface Config {
  host: string;
  port?: number;          // optional: number | undefined
  readonly apiKey: string; // can't change after assignment
}

const config: Config = { host: 'localhost', apiKey: 'abc' };
config.port = 8080;       // OK
config.apiKey = 'new';    // Error: readonly

Estensione delle interfacce

Utilizzi extends per creare una nuova interfaccia che includa tutte le proprietà di un'altra. È supportata l'ereditarietà multipla.

interface Animal {
  name: string;
  sound(): string;
}

interface Dog extends Animal {
  breed: string;
  fetch(): void;
}

interface ServiceDog extends Dog {
  task: string;
}

Firme di indice — chiavi dinamiche

Quando non conosce in anticipo i nomi delle proprietà, ma ne conosce i tipi dei valori, utilizzi una firma di indice.

interface StringMap {
  [key: string]: string;
}

const headers: StringMap = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer token123'
};

// Also for translating:
interface Translations {
  [locale: string]: { [key: string]: string };
}

Tipi funzione nelle interfacce

Definisca le firme dei metodi all'interno di un'interfaccia: sono valide sia la sintassi abbreviata sia quella completa delle proprietà.

interface Logger {
  log(message: string): void;
  warn(message: string): void;
  error(message: string, err?: Error): void;
}

// Also valid:
interface Logger2 {
  log: (message: string) => void;
}

Implementazione delle interfacce nelle classi

Una classe può implement una o più interfacce. TypeScript verifica che la classe fornisca tutti i membri obbligatori.

interface Serialisable {
  serialise(): string;
  deserialise(data: string): this;
}

class User implements Serialisable {
  constructor(public name: string) {}
  serialise() { return JSON.stringify({ name: this.name }); }
  deserialise(data: string) {
    const obj = JSON.parse(data);
    return new User(obj.name) as this;
  }
}

Fusione delle dichiarazioni

Più dichiarazioni interface con lo stesso nome vengono unite in una sola. È utile per estendere i tipi di terze parti. Gli alias di tipo non supportano questa funzionalità.

interface Window {
  myPlugin: { version: string };
}
// Now window.myPlugin is typed everywhere

Tipi oggetto annidati

Le proprietà di un'interfaccia possono avere a loro volta tipi oggetto, definiti inline oppure tramite un riferimento a un'altra interfaccia.

interface Order {
  id: string;
  customer: {
    name: string;
    email: string;
  };
  items: Array<{
    productId: string;
    quantity: number;
    price: number;
  }>;
  total: number;
}

Tipizzazione strutturale — Duck typing

TypeScript utilizza la tipizzazione strutturale: un valore soddisfa un tipo se possiede almeno le proprietà richieste. Non è necessario un implements esplicito. Qualsiasi oggetto con la forma corretta è compatibile.

interface Named {
  name: string;
}

function greet(obj: Named) {
  console.log(`Hello, ${obj.name}!`);
}

// No 'implements Named' needed:
greet({ name: 'Alice', age: 30 }); // OK — has the name property

Unioni discriminate con le interfacce

Aggiunga una proprietà discriminante di tipo letterale per distinguere le varianti di un'unione. TypeScript restringe il tipo in switch/if in base al discriminante.

interface Circle { kind: 'circle'; radius: number; }
interface Square { kind: 'square'; side: number; }
type Shape = Circle | Square;

function area(shape: Shape): number {
  switch (shape.kind) {
    case 'circle': return Math.PI * shape.radius ** 2;
    case 'square': return shape.side ** 2;
  }
}

Verifica rapida

Qual è la differenza principale tra interface e type in TypeScript?

Riepilogo: interfacce

interface descrive la forma degli oggetti con proprietà obbligatorie, facoltative e readonly. Estenda le interfacce con extends. Utilizzi le firme di indice per le chiavi dinamiche. Le classi implementano le interfacce. La fusione delle dichiarazioni è una funzionalità esclusiva delle interfacce. TypeScript utilizza la tipizzazione strutturale: conta la forma, non la dichiarazione esplicita.

Domande Frequenti

La lezione «Interfacce e tipi di oggetto» è gratuita?

Sì — il testo completo di «Interfacce e tipi di oggetto» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Frontend Academy, passa a CoddyKit PRO. Il corso Frontend Academy include 4 lezioni in totale.

Cosa imparerò in «Interfacce e tipi di oggetto»?

Descrivere la struttura degli oggetti con interface e type, estendere le interfacce, usare proprietà opzionali con ? e readonly per l’immutabilità. Eserciti Frontend Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Frontend Academy?

Non è richiesta alcuna esperienza precedente. Frontend Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Interfacce e tipi di oggetto»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Frontend Academy?

Sì. Ogni lezione Frontend Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Perché TypeScript: i tipi rilevano gli errori in fase di compilazione
  2. Tipi primitivi, union e alias di tipo
  3. Interfacce e tipi di oggetto
  4. Compilare TS e tsconfig.json
← Torna a Frontend Academy