0Pricing
TypeScript Academy · Lezione

Namespace o moduli: uso moderno

Comprenda perché i moduli sono preferiti ai namespace.

Namespace o moduli: uso moderno è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 4 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

In origine, TypeScript aveva i namespace (precedentemente chiamati «internal modules») per organizzare il codice. Il TypeScript moderno usa invece i moduli ES. Questa lezione spiega quando è appropriato usare ciascuno dei due approcci.

Che cos'è un namespace

Un namespace è un modo specifico di TypeScript per raggruppare codice correlato in uno scope denominato usando la parola chiave `namespace`.
namespace Geometry {
  export interface Point { x: number; y: number; }
  export function distance(a: Point, b: Point): number {
    return Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2);
  }
}

Accesso ai membri di un namespace

Acceda ai membri di un namespace tramite il nome del namespace e la notazione con il punto.
const p1: Geometry.Point = { x: 0, y: 0 };
const p2: Geometry.Point = { x: 3, y: 4 };
const d = Geometry.distance(p1, p2); // 5

Namespace annidati

I namespace possono essere annidati.
namespace App {
  export namespace Models {
    export interface User { name: string; }
  }
}
const u: App.Models.User = { name: 'Alice' };

Fusione dei namespace

I namespace supportano la fusione delle dichiarazioni: due dichiarazioni di namespace con lo stesso nome vengono unite.
namespace Validation {
  export function validate(s: string): boolean { return s.length > 0; }
}
namespace Validation {
  export function sanitize(s: string): string { return s.trim(); }
}

Perché si preferiscono i moduli

I moduli ES sono lo standard JavaScript. Sono supportati da tutti i bundler, sono sottoposti efficacemente al tree shaking e funzionano nativamente nei browser moderni e in Node.js.

L'equivalente modulare di un namespace

Nel TypeScript moderno, un namespace diventa semplicemente un file. Esporti ciò che vuole rendere pubblico e mantenga privato il resto.
// geometry.ts
export interface Point { x: number; y: number; }
export function distance(a: Point, b: Point): number {
  return Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2);
}

I namespace sono ancora usati nei file di dichiarazione

I namespace sono ancora ampiamente usati nei file di dichiarazione .d.ts per le librerie globali (come i tipi DOM e i tipi Node.js), perché estendono lo scope globale.
// node.d.ts
declare namespace NodeJS {
  interface ProcessEnv { NODE_ENV?: 'development' | 'production'; }
}

Riferimenti triple-slash (legacy)

Prima dei moduli ES, le direttive triple-slash facevano riferimento ad altri file. Oggi vengono sostituite da includes in tsconfig e import dei moduli.
/// <reference types="node" />
/// <reference path="./other.d.ts" />

Quando usare ancora i namespace

Usi i namespace: (1) nei file di dichiarazione per i tipi globali ambient, (2) quando estende namespace globali esistenti forniti dalle librerie.

Migrazione dai namespace ai moduli

Sostituisca `namespace Foo {}` con un file di modulo. Sostituisca `/// ` con gli import. Il team di TypeScript ha documentato questo percorso di migrazione.

Verifica rapida

Nel TypeScript moderno, qual è il sostituto consigliato dei namespace?

Riepilogo

I namespace organizzano il codice in uno scope denominato, ma nel TypeScript moderno sono considerati legacy. Usi i moduli ES (import/export) per il codice dell'applicazione. I namespace restano utili nei file di dichiarazione per l'estensione dei tipi globali.

Domande Frequenti

La lezione «Namespace o moduli: uso moderno» è gratuita?

Sì — il testo completo di «Namespace o moduli: uso moderno» è 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 «Namespace o moduli: uso moderno»?

Comprenda perché i moduli sono preferiti ai namespace. 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 4 di 4.

Quanto tempo richiede la lezione «Namespace o moduli: uso moderno»?

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. Sintassi dei moduli ES: import ed export
  2. Riesportazioni e file barrel
  3. Import ed export di soli tipi
  4. Namespace o moduli: uso moderno
← Torna a TypeScript Academy