`target` în TypeScript

tsconfig: limbaj și mediu TypeScript 1.0

Versiunea de JavaScript generată: sintaxa mai nouă decât ținta este transformată în cod echivalent mai vechi.

Sintaxă

"compilerOptions": { "target": "es2022" }

tsc --target es2022
tsc -t es2022

Ce face `target`

target spune ce versiune de JavaScript trebuie să înțeleagă mediul în care rulează codul. Sintaxa mai nouă decât ținta este rescrisă: cu es2015, ?? devine o verificare cu !== null, iar câmpurile private #nume devin un WeakMap. Cu o țintă suficient de nouă, codul rămâne aproape identic cu sursa, doar fără tipuri.

target schimbă și biblioteca implicită de tipuri (lib): cu es2015, note.at(-1) sau Object.hasOwn nu există (TS2550). Atenție: target transformă doar sintaxa; funcțiile noi (Array.prototype.at) nu sunt adăugate. Pentru ele ai nevoie de polyfill-uri.

Fără target, valoarea este es5 (cel mai vechi suportat; es3 a fost scos). module: nodenext fixează implicit esnext, iar tsc --init din 5.9 scrie esnext. Pentru Node.js 20+ sau browsere actuale, es2022 sau mai nou este o alegere sigură.

Parametri

Parametru	Descriere
`es5`	Valoarea implicită. JavaScript fără `let`, săgeți, clase native.
`es2015 (es6) … es2024`	Versiunea anuală a standardului.
`esnext`	Cea mai nouă versiune cunoscută de tsc-ul folosit; se schimbă la fiecare actualizare.

Exemple

Exemplul 1: Același cod, două ținte

Cu es2022, codul generat este sursa fără tipuri. Cu es2015, ?? și #nume sunt rescrise. Ambele variante afișează 20 Sunt Ana.

// tsconfig.json
{
  "compilerOptions": {
    "target": "es2015",
    "lib": ["es2022", "dom"]
  }
}

// index.ts
const note = [9, 7, 10];
const ultima = note.at(-1) ?? 0;
const dublu = (x: number) => x * 2;
class Elev {
  #nume = "Ana";
  salut() { return `Sunt ${this.#nume}`; }
}
console.log(dublu(ultima), new Elev().salut());

Rezultat (tsc 5.9)

$ npx tsc && cat index.js
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _a;
var _Elev_nume;
const note = [9, 7, 10];
const ultima = (_a = note.at(-1)) !== null && _a !== void 0 ? _a : 0;
const dublu = (x) => x * 2;
class Elev {
    constructor() {
        _Elev_nume.set(this, "Ana");
    }
    salut() { return `Sunt ${__classPrivateFieldGet(this, _Elev_nume, "f")}`; }
}
_Elev_nume = new WeakMap();
console.log(dublu(ultima), new Elev().salut());

$ npx tsc --target es2022 && cat index.js
const note = [9, 7, 10];
const ultima = note.at(-1) ?? 0;
const dublu = (x) => x * 2;
class Elev {
    #nume = "Ana";
    salut() { return `Sunt ${this.#nume}`; }
}
console.log(dublu(ultima), new Elev().salut());

Exemplul 2: Funcții care nu există în biblioteca țintei

Fără lib scris, target: es2015 aduce doar tipurile din ES2015. tsc sugerează schimbarea lui lib.

// tsconfig.json
{
  "compilerOptions": {
    "target": "es2015"
  }
}

// index.ts
const note = [9, 7, 10];
console.log(note.at(-1), Object.hasOwn({ a: 1 }, "a"));