module și import/export în TypeScript

export function f() { ... }
export default class A { ... }
import A, { f, type T } from "./fisier.mjs";
import * as m from "./fisier.mjs";

Ce face module și import/export

TypeScript folosește modulele ES din JavaScript. Un fișier care conține import sau export este un modul: ce declari în el rămâne local, dacă nu exporți explicit. Poți exporta funcții, clase, constante și, specific TypeScript, interfețe și aliasuri de tip. Un modul poate avea un singur export default și oricâte exporturi cu nume.

Când compilezi pentru Node.js cu "module": "nodenext", în importurile relative scrii extensia fișierului JavaScript care va exista după compilare: un fișier note.mts se importă cu "./note.mjs", iar note.ts cu "./note.js". tsc găsește singur fișierul sursă. Extensia .mts forțează modul ES, .cts forțează CommonJS, iar .ts urmează câmpul "type" din package.json.

Tipurile se pot importa împreună cu valorile sau separat, cu import type. Modulele incluse în Node.js se importă cu prefixul node: (vezi tipuri pentru Node.js). Pentru require și CommonJS vezi opțiunile module și esModuleInterop din tsconfig.

Exemple

Exemplul 1: Două fișiere: un modul și programul care îl folosește

Fișierul note.mts exportă o constantă, o interfață, o funcție și un export implicit. main.mts le importă în ambele feluri. Comanda: tsc --strict --module nodenext main.mts && node main.mjs.

// note.mts
export const SCOALA = "Colegiul Național Iași";

export interface Elev {
    nume: string;
    note: number[];
}

export function medie(e: Elev): number {
    return e.note.reduce((s, n) => s + n, 0) / e.note.length;
}

export default function raport(elevi: Elev[]): string {
    return elevi.map((e) => `${e.nume}: ${medie(e).toFixed(2)}`).join("\n");
}

// main.mts
import raport, { SCOALA, medie, type Elev } from "./note.mjs";
import * as note from "./note.mjs";

const elevi: Elev[] = [
    { nume: "Ana", note: [10, 9, 10] },
    { nume: "Mihai", note: [7, 8] },
];

console.log(SCOALA);
console.log(raport(elevi));
console.log(medie(elevi[0]) === note.medie(elevi[0]));

Rezultat (rulat cu tsc și node)

Colegiul Național Iași
Ana: 9.67
Mihai: 7.50
true

Exemplul 2: Importuri din modulele Node.js

import { join, basename, extname } from "node:path";
import { EOL } from "node:os";

const cale = join("documente", "note", "clasa-a-X-a.csv");
console.log(cale);
console.log(basename(cale, extname(cale)), extname(cale));
console.log(JSON.stringify(EOL));

Rezultat

documente/note/clasa-a-X-a.csv
clasa-a-X-a .csv
"\n"

Exemplul 3: Erori frecvente la import

Un nume care nu este exportat și un import relativ fără extensie (cu moduleResolution nodenext).

// gresit.mts
import { medi } from "./note.mjs";

// gresit2.mts
import { medie } from "./note";

Eroarea afișată de tsc

gresit.mts(1,10): error TS2724: '"./note.mjs"' has no exported member named 'medi'. Did you mean 'medie'?
gresit2.mts(1,23): error TS2835: Relative import paths need explicit file extensions in ECMAScript imports when '--moduleResolution' is 'node16' or 'nodenext'. Did you mean './note.mjs'?

Greșeli frecvente

• Scrii import ... from "./note.ts". Fără opțiunea allowImportingTsExtensions nu este permis; scrie extensia fișierului generat (.js/.mjs).
• Amesteci export default cu multe exporturi cu nume fără regulă. Exporturile cu nume sunt mai ușor de găsit și de redenumit în editor.
• Faci importuri circulare (A importă B, B importă A). Pot apărea valori undefined la rulare; mută codul comun într-un al treilea modul.

Comenzi înrudite

• import type: Importă doar tipuri; importul dispare complet din JavaScript-ul generat.
• export type: Exportă tipuri dintr-un modul; forma export type { … } re-exportă doar tipuri, fără cod la rulare.
• fișiere .d.ts: Fișiere care conțin doar tipuri: descriu codul JavaScript ca să poată fi folosit din TypeScript cu verificare.
• namespace: Grupează cod sub un nume comun; este forma veche de organizare, înlocuită azi de module ES.
• module: Alege formatul de module din JavaScript-ul generat (ES modules, CommonJS) și regulile de import pe care le verifică tsc.
• moduleResolution: Alege regulile după care tsc găsește fișierul din spatele unui import („./calcul.js”, „react”, „@/utile”).