TypeError: Cyclic __proto__ value
Ai încercat să faci un obiect să moștenească (direct sau indirect) din el însuși: A are prototipul B, iar acum vrei ca B să aibă prototipul A. Lanțul de prototipuri nu are voie să facă buclă. De obicei argumentele lui Object.setPrototypeOf sunt inversate sau moștenirea e setată de două ori.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Fiecare obiect are un prototip, de unde moștenește metode, iar prototipul are la rândul lui un prototip, până la null. Când citești obj.metoda, JavaScript urcă pe acest lanț. Dacă lanțul ar face o buclă (A → B → A), căutarea nu s-ar mai termina, așa că motorul refuză operația: Cyclic __proto__ value.
Eroarea apare la Object.setPrototypeOf(a, b), la a.__proto__ = b sau la Reflect.setPrototypeOf (care întoarce false în loc să arunce). Cauzele tipice: o funcție de tip mosteneste(copil, parinte) apelată cu argumentele inversate, o moștenire setată în ambele sensuri „ca să fie sigur”, o structură de date în care cineva a folosit prototipul ca legătură părinte-copil, deși trebuia o proprietate obișnuită.
Stiva de apeluri îți arată apelul care închide bucla. Desenează lanțul (copil → parinte → Object.prototype) și verifică ordinea argumentelor: primul e obiectul care moștenește, al doilea e cel din care moștenește.
De ce apare: cauzele frecvente
1Moștenire setată în ambele sensuri
Object.setPrototypeOf(caine, animal);
Object.setPrototypeOf(animal, caine);Object.setPrototypeOf(caine, animal);Moștenirea merge într-un singur sens: caine moștenește din animal, nu și invers.
2Argumente inversate într-o funcție ajutătoare
function mosteneste(copil, parinte) {
Object.setPrototypeOf(copil, parinte);
}
mosteneste(baza, extinsa); // extinsa moștenea deja din bazafunction mosteneste(copil, parinte) {
Object.setPrototypeOf(copil, parinte);
}
mosteneste(extinsa, baza);Primul argument e mereu obiectul care primește metodele.
3Prototipul folosit ca legătură părinte-copil
categorie.__proto__ = subcategorie;
subcategorie.__proto__ = categorie;subcategorie.parinte = categorie;
categorie.copii = [subcategorie];Pentru relații între date (arbori, categorii), folosește proprietăți obișnuite, nu prototipuri.
Repară eroarea, direct în pagină
Codul leagă obiectele animal și caine prin prototipuri, dar apelează mosteneste de două ori, a doua oară cu argumentele inversate, și primește TypeError: Cyclic __proto__ value. Repară legăturile astfel încât doar caine să moștenească din animal și programul să afișeze propoziția.
const animal = {
respira() {
return "respiră";
},
};
const caine = {
latra() {
return "latră";
},
};
function mosteneste(copil, parinte) {
Object.setPrototypeOf(copil, parinte);
}
mosteneste(caine, animal);
mosteneste(animal, caine);
console.log(`Câinele ${caine.respira()} și ${caine.latra()}`);Câinele respiră și latră
Indiciu
Moștenirea merge într-un singur sens: primul argument e obiectul care moștenește.
Reparația
const animal = {
respira() {
return "respiră";
},
};
const caine = {
latra() {
return "latră";
},
};
function mosteneste(copil, parinte) {
Object.setPrototypeOf(copil, parinte);
}
mosteneste(caine, animal);
console.log(`Câinele ${caine.respira()} și ${caine.latra()}`);De ce merge
După primul apel, lanțul este caine → animal → Object.prototype. Al doilea apel ar fi făcut din animal un copil al lui caine, deci lanțul ar fi devenit o buclă, iar JavaScript refuză asta. Fără al doilea apel, caine își găsește metoda proprie latra și moștenește respira de la animal, exact cum voiam.
Alte forme ale mesajului
TypeError: can't set prototype: it would cause a prototype chain cycleTypeError: Cyclic __proto__ value at Function.setPrototypeOfTypeError: cyclic __proto__ value
Cum o eviți pe viitor
- Folosește
classșiextendspentru moștenire: sintaxa nu îți permite să creezi o buclă. - Evită
__proto__șiObject.setPrototypeOfîn codul obișnuit; preferăObject.create(parinte)la creare. - Pentru legături între date, folosește proprietăți (
parinte,copii), nu prototipul. - Verifică lanțul cu
Object.getPrototypeOf(obj)sauparinte.isPrototypeOf(copil)când depanezi.
Întrebări frecvente
De ce nu e voie, dacă obiectele sunt diferite?
Pentru că la căutarea unei proprietăți care nu există, JavaScript ar urca la nesfârșit pe lanțul A → B → A → B. Regula garantează că lanțul se termină mereu cu null.
Reflect.setPrototypeOf dă aceeași eroare?
Nu aruncă: întoarce false când operația ar crea o buclă. Verifică rezultatul dacă folosești varianta Reflect.
Erori înrudite
TypeError: Object prototype may only be an Object or null: undefined Object.create(x) sau Object.setPrototypeOf(obj, x) a primit ca prototip ceva ce nu e obiect și nici null: de obicei undefined, dintr-un nume greșit sau dintr-o variabilă încă neîncărcată. Verifică valoarea dată ca prototip; pentru un obiect fără prototip, folosește explicit null. RangeError: Maximum call stack size exceeded O funcție se apelează pe ea însăși (direct sau prin altele) de prea multe ori, de obicei la nesfârșit: lipsește cazul de bază al recursivității, condiția de oprire nu e atinsă niciodată sau un getter/setter se apelează singur. Adaugă sau corectează condiția de oprire. TypeError: Class extends value undefined is not a constructor or null Clasa părinte din `class Copil extends Parinte` nu există încă (e `undefined`) sau nu e o clasă. Cel mai des: import greșit (default vs named), import circular între fișiere sau ordinea definițiilor. Verifică importul și ca părintele să fie definit înainte de clasa copil. Î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.
