În acest tutorial, vom vedea aspectele limitărilor și funcțiilor legate de hasOwnProperty() metoda în JavaScript. Vom afla, de asemenea, despre implementările și utilizarea acestuia în secțiuni.

arbore binar vs bst

Introducere

În JavaScript , metoda hasOwnProperty() este definită ca o proprietate pentru a asigura dacă obiectul aparține sau nu proiectului menționat. Dacă se constată că proprietatea aparține unui obiect recunoscut, atunci va returna o ieșire bazată pe instrucțiuni booleene, adică adevărat sau fals.

Sintaxă

 object.hasOwnProperty(propname) 

Argument

Înregistrare:

Aici, trebuie să transmitem simbolul sau numele șirului, deoarece acesta este locul recuzirii unde se verifică dacă simbolul sau șirul aparține obiectului. Acest lucru se face folosind metoda prezentată mai jos.

 var movie = { name: 'iron man', genre: 'super hit', } var song = { name: 'cardigan', } movie.hasOwnProperty('name'); // returns true movie.hasOwnProperty('type'); // returns false song.hasOwnProperty('name'); // returns true song.hasOwnProperty('status'); // returns false 

Un aspect important de remarcat aici este că metoda hasOwnProperty() ignoră în general proprietățile moștenite. Aceasta înseamnă că metoda va returna adevăratul său dacă se găsește că obiectul are o proprietate nemoștenită și numele este specificat de propname. Dacă returnează false, atunci înseamnă că obiectul nu are nicio proprietate cu un nume specificat sau că a moștenit proprietatea de la obiectul proptype.

 // Create an object var o = new Object(); // Define a noninherited local property o.x = 3.14; o.hasOwnProperty('x'); // Returns true: x is a local property of o o.hasOwnProperty('y'); // Returns false: o doesn't have a property y o.hasOwnProperty('toString'); // Returns false: toString property is inherited hasOwnProperty() will return true even if you define the undefined or null value. let a = new Object(); a.propertyOne = null; a.hasOwnProperty('propertyOne') // output: true a.propertyTwo = undefined; a.hasOwnProperty('propertyTwo') //Output: true 

Un alt avantaj suplimentar al utilizării metodei hasOwnProperty() este că poate inițializa un obiect prin urmarea conceptului de a trece un șir ca argument implicit. Acesta va răspunde rapid cu true dacă se constată că valoarea este disponibilă pentru obiect. În caz contrar, va returna false dacă nu este găsit. Poate fi demonstrat folosind fragmentul de cod prezentat mai jos.

 function Car(name) { this.name = name; } Car.prototype.color = 'red'; const bmw = new Car('x1'); console.log(bmw.name); // property found on object console.log(bmw.color); // color property found on prototype console.log(bmw.hasOwnProperty('name')); // name is found on the object itself console.log(bmw.hasOwnProperty('color')); // color property is not found on the object itself 

În fragmentul de cod dat mai sus, variabila creează un nou obiect, Mașină . Acum se poate afirma că mașina este inițiată având proprietățile și numele definite în constructor. Deși culoarea ar putea să nu fie menționată în obiect atunci când este inițiată, va fi întotdeauna disponibilă pe prototip ierarhie . Prin urmare, hasOwnProperty() va returna întotdeauna adevărat pentru nume, dar pentru culoare, va returna fals.

Când vine vorba de performanță, hasOwnProperty() funcționează fără probleme în timp ce își face drum prin obiect cu bucle. Până acum, putem spune că dacă proprietățile aparțin în mod specific obiectului. Nu au nicio corelare cu prototipul. Demonstrarea acestui lucru poate fi afișată folosind fragmentul de cod prezentat mai jos.

 // declaring a Car function function Car(name) { this.name = name; } // setting up new prop with prototype Car.prototype.color = 'red'; // creating a new Car object const BMW = new Car('x1'); // looping through every car prop including prototype as well for (let car in BMW) { car + ':', BMW[car]; } /* output: name: x1 output: color: red */ /**************************************/ /*will loop through only self properties of the object, excludes property generated through prototype method */ for (let car in BMW) { if (BMW.hasOwnProperty(car)) { console.log(car + ':', BMW[car]); } } // output: name: 

În timp ce utilizați metoda hasOwnProperty(), aceasta poate deveni inutilă deoarece redarea obiectului are loc atunci când definiți o proprietate numită hasOwnProperty. Pentru a susține acest lucru, încercați să înțelegeți fragmentul de cod prezentat mai jos.

 var harrypotter = { hasOwnProperty: function() { return true; } }; // Outputs: true console.log(harrypotter.hasOwnProperty('ridikulus')); 

În fragmentul de cod de mai sus, este evident că harrypotter are deja hasOwnProperty. Astfel, nu va efectua niciodată un apel către object.prototype.hasOwnProperty. Se presupune că acest lucru ar putea întâlni cazuri în care poate permite efectuarea unui apel, dar poate eșua în cele din urmă. Deci, este întotdeauna recomandat să fii conștient de posibilitatea de apeluri. Fragmentul de cod de mai jos arată soluția sa.

 // Returns false Object.prototype.hasOwnProperty.call(harrypotter, 'ridikulus'); 

În fragmentul de cod de mai sus, este clar că harrypotter își definește propriul areOwnProperty . Nu va efectua niciodată apeluri către Object.prototype.hasOwnProperty deoarece există posibilitatea ca acesta să revină false dacă întâlnește unele cazuri în care valoarea este falsă și devine dificil să faci lucrurile să funcționeze după colț. Pentru a susține această afirmație, consultați fragmentul de cod de mai jos.

programare struct array c

 // Returns false Obje ct.prototype.hasOwnProperty.call(harrypotter, 'ridikulus'); 

Similar cu hasOwnProperty, există o altă metodă numită metoda „în”. De asemenea, este folosit pentru a verifica dacă cheia este prezentă pentru obiect sau nu. Cu toate acestea, este important de reținut că diferența cheie dintre metoda hasOwnProperty și in constă în faptul că metoda in nu va urma ordinea de diferențiere între proprietățile care sunt moștenite și proprietățile care sunt moștenite special create pentru obiect. Acest lucru poate fi afișat folosind fragmentul de cod prezentat mai jos.

 var fantasyLit = { tolkien: 'The Lord of the Rings', lewis: 'The Chronicles of Narnia' }; // Outputs: true console.log('tolkien' in fantasyLit); // Outputs: false console.log('asimov' in fantasyLit); // Outputs: true console.log('constructor' in fantasyLit); 

În fragmentul de cod de mai sus, este evident că metoda „in” urmează proprietatea constructorului Object.prototype de unde sunt moștenite toate obiectele.

Pentru a adăuga câteva puncte, există un dezavantaj pentru ambele metode. Ambele metode ne pot oferi cu ușurință informații despre o proprietate care a fost deja declarată, dar nu ne pot spune despre proprietatea care conține o valoare reală.

Luați în considerare următorul fragment de cod care arată modul în care ambele metode au această soluție.

 // Puts a 'declared' property on the global object // (window in browsers) var declared; // Outputs: true console.log('declared' in window); // Outputs: true console.log(window.hasOwnProperty('declared')); // Outputs: undefined console.log(declared); var obj = { myUndefined: undefined }; // Outputs: true console.log('myUndefined' in obj); // Outputs: true console.log(obj.hasOwnProperty('myUndefined')); // Outputs: undefined console.log(obj.myUndefined); 

Concluzie

În acest tutorial, am discutat despre metoda hasOwnProperty() în JavaScript. În general, această metodă este o alegere excelentă pentru majoritatea dezvoltatorilor pentru a se întreba și a evita problemele legate de unele chei speciale, cum ar fi constructorul. Se recomandă ca, dacă găsim orice obiect care are vreo proprietate, acesta va folosi în mod implicit hasOwnProperty(). În cazul prezenței unei funcții destinate să efectueze un apel prin verificarea obiectului pentru metoda toString(), trebuie să folosim în.