error TS2392: Multiple constructor implementations are not allowed.
Ai scris doi constructori cu corp într-o clasă, ca în Java sau C#. O clasă TypeScript are un singur constructor implementat. Folosește parametri opționali / cu valoare implicită sau supraîncărcări (semnături fără corp) urmate de o singură implementare.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
În Java sau C# poți avea mai mulți constructori cu parametri diferiți. În JavaScript, și deci în TypeScript, o clasă are un singur constructor. Dacă scrii doi constructori cu corp, compilatorul dă TS2392 pe fiecare dintre ei.
TypeScript îți oferă două variante în loc. Cea simplă: un singur constructor cu parametri opționali sau cu valori implicite (constructor(nume: string, pret: number = 0)). Cea pentru cazuri diferite: supraîncărcări, adică mai multe semnături fără corp (constructor(nume: string);), urmate de o singură implementare compatibilă cu toate.
O a treia variantă, des folosită pentru claritate, sunt metodele statice de tip fabrică: Produs.gratuit(nume), Produs.dinJson(text).
De ce apare: cauzele frecvente
1Doi constructori ca în Java
class Produs {
constructor(public nume: string) {}
constructor(public nume: string, public pret: number) {}
}class Produs {
constructor(public nume: string, public pret: number = 0) {}
}Un singur constructor cu valoare implicită acoperă ambele apeluri: new Produs('Ceai') și new Produs('Cafea', 15).
2Variante cu tipuri diferite, scrise ca implementări
class Data {
constructor(text: string) {}
constructor(an: number, luna: number) {}
}class Data {
constructor(text: string);
constructor(an: number, luna: number);
constructor(a: string | number, luna?: number) {}
}Semnăturile fără corp descriu apelurile permise, iar o singură implementare le tratează pe toate.
3Fabrici statice în loc de constructori multipli
class Bani {
constructor(lei: number) {}
constructor(lei: number, bani: number) {}
}class Bani {
constructor(public totalBani: number) {}
static dinLei(lei: number, bani = 0) {
return new Bani(lei * 100 + bani);
}
}O metodă statică cu nume clar spune ce face fiecare variantă și lasă constructorul simplu.
Repară eroarea, direct în pagină
Codul de mai jos dă eroarea TS2392: Multiple constructor implementations are not allowed. Un produs trebuie să poată fi creat cu sau fără preț (implicit 0). Repară clasa ca programul să afișeze Ceai: 0 lei și apoi Cafea: 15 lei.
class Produs {
nume: string;
pret: number;
constructor(nume: string) {
this.nume = nume;
this.pret = 0;
}
constructor(nume: string, pret: number) {
this.nume = nume;
this.pret = pret;
}
}
const a = new Produs('Ceai');
const b = new Produs('Cafea', 15);
console.log(`${a.nume}: ${a.pret} lei`);
console.log(`${b.nume}: ${b.pret} lei`);Ceai: 0 lei Cafea: 15 lei
Indiciu
Păstrează un singur constructor și fă prețul opțional cu o valoare implicită.
Reparația
class Produs {
nume: string;
pret: number;
constructor(nume: string, pret: number = 0) {
this.nume = nume;
this.pret = pret;
}
}
const a = new Produs('Ceai');
const b = new Produs('Cafea', 15);
console.log(`${a.nume}: ${a.pret} lei`);
console.log(`${b.nume}: ${b.pret} lei`);De ce merge
O clasă JavaScript are un singur constructor, așa că a doua implementare nu e permisă. Un constructor cu pret: number = 0 acceptă ambele apeluri: new Produs('Ceai') primește prețul implicit 0, iar new Produs('Cafea', 15) primește 15. Rezultatul e același ca la cei doi constructori din Java, cu un singur corp de cod.
Cum o eviți pe viitor
- Gândește constructorul ca pe o singură funcție: variantele de apel se fac cu parametri opționali, valori implicite sau un obiect de opțiuni.
- Când variantele au tipuri foarte diferite, folosește supraîncărcări (semnături fără corp) plus o implementare.
- Pentru moduri diferite de creare, preferă metode statice cu nume (
dinJson,gol). - Dacă vii din Java / C#, verifică orice clasă cu mai mulți
constructor.
Întrebări frecvente
Am scris semnături fără corp și primesc TS2390. De ce?
Supraîncărcările au nevoie și de o implementare: după semnăturile fără corp trebuie să urmeze un constructor cu corp, compatibil cu toate. Fără el primești Constructor implementation is missing.
Funcțiile obișnuite au aceeași regulă?
Da. Două funcții cu același nume și corp dau TS2393 (Duplicate function implementation). Și acolo soluția sunt parametrii opționali sau supraîncărcările.
Erori înrudite
error TS2390: Constructor implementation is missing. Ai scris semnături de constructor fără corp (supraîncărcări), dar nu și constructorul implementat. După semnături adaugă un constructor cu corp, compatibil cu toate, care face efectiv inițializarea. error TS2393: Duplicate function implementation. Ai două funcții cu același nume și corp în același domeniu (sau în două fișiere script). Șterge una, redenumește-o, sau, dacă voiai supraîncărcare, scrie semnăturile fără corp și o singură implementare. error TS2394: This overload signature is not compatible with its implementation signature. Una dintre semnăturile de supraîncărcare (overload) are parametri sau tip de retur pe care implementarea nu le acceptă. Lărgește semnătura implementării (de exemplu string | number) ca să le cuprindă pe toate. Învață TypeScript de la zero, cu exerciții la fiecare lecție
Curs TypeScript: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
