ReferenceError: Super constructor may only be called once
În constructorul unei clase derivate, super(...) a rulat de două ori: de exemplu o dată sus și încă o dată într-un if. super() inițializează obiectul o singură dată. Calculează întâi argumentele (cu if sau ternar) și apelează super o singură dată.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Într-o clasă cu extends, super(...) apelează constructorul părintelui și creează efectiv obiectul this. Asta se poate întâmpla o singură dată pe fiecare new. Dacă execuția trece a doua oară printr-un super(...), obiectul există deja și motorul aruncă ReferenceError: Super constructor may only be called once.
Eroarea apare la rulare, doar pe drumul de cod care ajunge la al doilea apel. De aceea poate trece neobservată: new Manager("Ana") merge, iar new Manager("") cade, pentru că doar atunci se intră în if.
Cauze tipice: un super „de rezervă” într-o ramură if, un super copiat de două ori la refactorizare, un super într-o buclă. Reparația e mereu aceeași: decide argumentele înainte, apoi un singur super(...). Dacă nu apelezi super deloc, primești altă eroare: Must call super constructor in derived class before accessing 'this'.
De ce apare: cauzele frecvente
1super de rezervă într-un if
constructor(nume) {
super(nume);
if (!nume) {
super("Fără nume");
}
}constructor(nume) {
super(nume || "Fără nume");
}Valoarea implicită se decide înainte, deci super rulează o singură dată.
2super în ambele ramuri plus unul la final
constructor(tip) {
if (tip === "vip") super(0.2);
else super(0);
super(0);
}constructor(tip) {
super(tip === "vip" ? 0.2 : 0);
}Cu un ternar ai un singur apel, iar argumentul se schimbă după condiție.
3super într-o buclă
constructor(...parti) {
for (const p of parti) super(p);
}constructor(...parti) {
super(parti.join(" "));
}Combină datele într-o singură valoare și dă-o o dată părintelui.
Repară eroarea, direct în pagină
Clasa Manager dă un nume implicit managerilor fără nume, dar new Manager("", ...) aruncă ReferenceError: Super constructor may only be called once. Repară constructorul ca programul să afișeze Ana conduce 2 oameni și Fără nume conduce 0 oameni.
class Angajat {
constructor(nume) {
this.nume = nume;
}
}
class Manager extends Angajat {
constructor(nume, echipa) {
super(nume);
if (!nume) {
super("Fără nume");
}
this.echipa = echipa;
}
descriere() {
return `${this.nume} conduce ${this.echipa.length} oameni`;
}
}
console.log(new Manager("Ana", ["Ion", "Maria"]).descriere());
console.log(new Manager("", []).descriere());Ana conduce 2 oameni Fără nume conduce 0 oameni
Indiciu
Alege numele înainte de apel și cheamă super o singură dată.
Reparația
class Angajat {
constructor(nume) {
this.nume = nume;
}
}
class Manager extends Angajat {
constructor(nume, echipa) {
super(nume || "Fără nume");
this.echipa = echipa;
}
descriere() {
return `${this.nume} conduce ${this.echipa.length} oameni`;
}
}
console.log(new Manager("Ana", ["Ion", "Maria"]).descriere());
console.log(new Manager("", []).descriere());De ce merge
super(...) creează obiectul this al clasei derivate și poate rula o singură dată pentru fiecare new. Pentru numele gol, execuția ajungea la al doilea super, iar motorul a oprit programul. Cu super(nume || "Fără nume") numele se alege înainte de apel: textul gol e fals, deci se folosește valoarea de rezervă, iar super rulează o dată.
Alte forme ale mesajului
ReferenceError: super() called twice in derived class constructor
Cum o eviți pe viitor
- Scrie
super(...)o singură dată, pe primele linii ale constructorului, fărăifîn jur. - Calculează argumentele înainte, în variabile locale (fără
this). - Valorile implicite le poți pune direct în parametri:
constructor(nume = "Fără nume"). - Testează constructorul și pe cazurile-limită (text gol, lipsă argument).
Întrebări frecvente
Pot folosi variabile înainte de super?
Da, poți calcula orice în variabile locale înainte de super(...). Nu poți folosi doar this, care există abia după apel.
De ce eroarea e ReferenceError și nu TypeError?
Pentru că problema e legată de legarea lui this: al doilea super ar încerca să inițializeze din nou o legătură deja inițializată, iar standardul clasifică asta ca ReferenceError.
Erori înrudite
ReferenceError: Must call super constructor in derived class before accessing 'this' or returning from derived constructor Într-o clasă care extinde alta (`extends`), constructorul folosește `this` înainte de `super(...)` sau nu apelează `super` deloc. Obiectul e creat de clasa părinte, deci `super(...)` trebuie să fie prima instrucțiune care atinge `this`. Mută `super(...)` la începutul constructorului. TypeError: Derived constructors may only return object or undefined Constructorul unei clase care extinde alta (extends) are un return cu o valoare simplă: un text, un număr, true. Constructorul nu trebuie să întoarcă nimic; new îți dă automat obiectul. Șterge return-ul sau mută valoarea într-o metodă. SyntaxError: 'super' keyword unexpected here Ai folosit `super` într-un loc unde nu are sens: `super()` într-o clasă fără `extends`, `super` într-o funcție obișnuită sau într-o funcție scrisă ca proprietate (`f: function () {}`). `super()` merge doar în constructorul unei clase derivate, iar `super.metoda()` doar în metode. Învață JavaScript de la zero, cu exerciții la fiecare lecție
Curs JavaScript: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
