`strictPropertyInitialization` în TypeScript

tsconfig: verificarea tipurilor TypeScript 2.7

Dă eroare pentru proprietățile de clasă declarate, dar care nu primesc valoare nici la declarare, nici în constructor.

Sintaxă

"compilerOptions": { "strictPropertyInitialization": true }

tsc --strictPropertyInitialization

Ce face `strictPropertyInitialization`

O proprietate declarată ca total: number promite că va avea mereu un număr. Dacă nu primește valoare la declarare sau în constructor, la rulare este undefined. Cu strictPropertyInitialization, TypeScript dă eroarea TS2564 pentru astfel de proprietăți.

Ai patru variante corecte: valoare la declarare (livrare = "curier"), atribuire în constructor, proprietate opțională (observatii?: string) sau, când valoarea este pusă de altcineva (un framework, o metodă init), semnul !: oras!: string. Ultima variantă oprește verificarea doar pentru acea proprietate.

Implicit este false, dar devine true când strict este true. Opțiunea are nevoie de strictNullChecks; fără ea, tsc dă eroarea TS5052.

Parametri

Parametru	Descriere
`true`	Activează verificarea.
`false`	Dezactivează verificarea, chiar dacă `"strict": true`.
`(lipsă)`	Ia valoarea lui `strict`: activă dacă `strict` este `true`, altfel inactivă.

Exemple

Exemplul 1: Proprietate fără valoare

Doar total dă eroare. client primește valoare în constructor, observatii este opțională, livrare are valoare la declarare, iar oras este marcată cu !.

// tsconfig.json
{
  "compilerOptions": {
    "strict": true
  }
}

// index.ts
class Comanda {
  client: string;
  total: number;
  observatii?: string;
  livrare: string = "curier";
  oras!: string;

  constructor(client: string) {
    this.client = client;
  }
}
console.log(new Comanda("Ana"));

Rezultat (tsc 5.9)

$ npx tsc --noEmit
index.ts(3,3): error TS2564: Property 'total' has no initializer and is not definitely assigned in the constructor.

Exemplul 2: Fără strictNullChecks

Opțiunea are sens doar când undefined este verificat separat, așa că tsc refuză configurația.

// tsconfig.json
{
  "compilerOptions": {
    "strictPropertyInitialization": true
  }
}

Rezultat (tsc 5.9)

$ npx tsc --noEmit
tsconfig.json(3,5): error TS5052: Option 'strictPropertyInitialization' cannot be specified without specifying option 'strictNullChecks'.

Exemplul 3: Clasa corectată

total primește valoare la declarare, iar adauga o modifică. Codul rulează cu --strict.

class Comanda {
  total = 0;
  observatii?: string;

  constructor(public client: string) {}

  adauga(pret: number): this {
    this.total += pret;
    return this;
  }
}

const c = new Comanda("Ana").adauga(12.5).adauga(30);
console.log(`${c.client}: ${c.total} lei`, c.observatii ?? "(fără observații)");

Rezultat

Ana: 42.5 lei (fără observații)

Greșeli frecvente

Să pui ! pe toate proprietățile. Semnul spune „am grijă eu”; dacă nu ai, valoarea rămâne undefined la rulare.
Să inițializezi proprietatea într-o metodă apelată din constructor (this.init()). TypeScript nu urmărește atribuirile din alte metode și dă tot eroare.

Comenzi înrudite

strictNullChecks: Face din null și undefined tipuri separate: o valoare care poate lipsi trebuie verificată înainte de folosire.
strict: Pornește dintr-o singură mișcare toate verificările stricte de tipuri (strictNullChecks, noImplicitAny și celelalte).
useDefineForClassFields: Câmpurile de clasă se comportă ca în standardul JavaScript (definite cu Object.defineProperty), nu ca atribuiri în constructor.
noImplicitOverride: Obligă scrierea cuvântului override pe metodele din clasele derivate care înlocuiesc o metodă din clasa de bază.

Ce face strictPropertyInitialization