0Pricing
TypeScript Academy · Lezione

Modificatori public, private e protected

Controlli l'accesso ai membri delle classi con i modificatori.

Modificatori public, private e protected è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 2 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 TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 4 lezioni in totale.

Benvenuto

I modificatori di accesso di TypeScript controllano la visibilità dei membri di una classe. Aiutano a imporre l'incapsulamento e a impedire utilizzi indesiderati.

public: accessibile ovunque

public è il valore predefinito. I membri public sono accessibili da qualsiasi contesto: all'interno della classe, nelle sottoclassi e dal codice esterno.
class Car {
  public brand: string;
  constructor(brand: string) { this.brand = brand; }
}
const c = new Car('Toyota');
console.log(c.brand); // OK

private: accesso riservato alla classe

I membri private sono accessibili solo all'interno della classe in cui vengono dichiarati. Le sottoclassi e il codice esterno non possono accedervi.
class BankAccount {
  private balance: number = 0;
  deposit(n: number) { this.balance += n; }
}
const a = new BankAccount();
// a.balance; // Error!

protected: accesso alla classe e alle sottoclassi

I membri protected sono accessibili all'interno della classe in cui vengono dichiarati e in qualsiasi sottoclasse, ma non dal codice esterno.
class Animal {
  protected name: string;
  constructor(name: string) { this.name = name; }
}
class Dog extends Animal {
  bark() { console.log(this.name + ' says woof!'); } // OK
}

Controllo solo in fase di compilazione

I modificatori di accesso di TypeScript vengono controllati solo in fase di compilazione. L'output JavaScript mantiene comunque proprietà public: non viene applicato alcun controllo a runtime.

Privato JavaScript con #

JavaScript dispone di campi privati nativi con `#`, il cui accesso viene controllato a runtime. TypeScript supporta questa sintassi insieme alla propria parola chiave `private`.
class Counter {
  #count = 0; // runtime private (JavaScript)
  increment() { this.#count++; }
  get value() { return this.#count; }
}

Modificatore readonly

Le proprietà readonly possono essere impostate solo durante la costruzione. Non possono essere modificate dopo l'inizializzazione.
class User {
  readonly id: number;
  constructor(id: number) { this.id = id; }
}
const u = new User(1);
// u.id = 2; // Error!

Combinazione dei modificatori

È possibile combinare i modificatori di accesso con readonly nella stessa proprietà.
class Config {
  constructor(
    public readonly host: string,
    private readonly port: number
  ) {}
}

private nel costruttore

Rendere privato un costruttore impedisce l'istanziazione dall'esterno. Utilizzi invece metodi factory statici.
class Singleton {
  private static instance: Singleton;
  private constructor() {}
  static getInstance(): Singleton {
    return this.instance ??= new Singleton();
  }
}

Costruttore protected

Un costruttore protected impedisce l'istanziazione diretta, ma consente alle sottoclassi di chiamarlo tramite super().
class Base {
  protected constructor(public id: number) {}
}
class Derived extends Base {
  constructor(id: number) { super(id); }
}

I modificatori di accesso non aggiungono overhead a runtime

Poiché TypeScript rimuove tutte le informazioni sui tipi, i modificatori di accesso non hanno alcun impatto sulle dimensioni o sulle prestazioni dell'output JavaScript compilato.

Verifica rapida

Quale modificatore di accesso rende un membro della classe accessibile nella classe E nelle sue sottoclassi, ma NON dal codice esterno?

Riepilogo

Utilizzi public (il valore predefinito) per i membri accessibili, private per gli elementi interni incapsulati e protected per i membri destinati alle sottoclassi. Aggiunga readonly per impedire modifiche dopo la costruzione.

Domande Frequenti

La lezione «Modificatori public, private e protected» è gratuita?

Sì — il testo completo di «Modificatori public, private e protected» è 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 TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 4 lezioni in totale.

Cosa imparerò in «Modificatori public, private e protected»?

Controlli l'accesso ai membri delle classi con i modificatori. Eserciti TypeScript 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 TypeScript Academy?

Non è richiesta alcuna esperienza precedente. TypeScript 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 2 di 4.

Quanto tempo richiede la lezione «Modificatori public, private e protected»?

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 TypeScript Academy?

Sì. Ogni lezione TypeScript 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. Classi e costruttori in TypeScript
  2. Modificatori public, private e protected
  3. Proprietà readonly e proprietà dei parametri
  4. Implementazione delle interfacce con le classi
← Torna a TypeScript Academy