En aquest tutorial, veurem els aspectes de limitacions i funcions relacionades amb el hasOwnProperty() mètode en JavaScript. També coneixerem les seves implementacions i ús a les seccions.
Introducció
En JavaScript , el mètode hasOwnProperty() es defineix com una propietat per garantir si l'objecte pertany o no al projecte esmentat. Si es troba que la propietat pertany a un objecte reconegut, retornarà una sortida basada en una declaració booleana, és a dir, vertader o fals.
Sintaxi
object.hasOwnProperty(propname)
Argumentació
Gravació:
Aquí, hem de passar el símbol o el nom de la cadena perquè aquest és el lloc de l'objecte on es verifica si el símbol o la cadena pertany a l'objecte. Això es fa mitjançant el mètode que es mostra a continuació.
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 aspecte important a tenir en compte aquí és que el mètode hasOwnProperty() generalment ignora les propietats heretades. Això vol dir que el mètode retornarà el seu cert si es troba que l'objecte té una propietat no heretada i el nom s'especifica per propname. Si retorna false, vol dir que l'objecte no té cap propietat amb un nom especificat, o que ha heretat la propietat de l'objecte del 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 altre avantatge afegit d'utilitzar el mètode hasOwnProperty() és que pot inicialitzar un objecte seguint el concepte de passar una cadena com a argument predeterminat. Ha de respondre ràpidament amb true si es troba que el valor està disponible per a l'objecte. En cas contrari, tornarà false si no es troba. Es pot demostrar mitjançant el fragment de codi que es mostra a continuació.
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 Al fragment de codi donat anteriorment, la variable crea un objecte nou, Cotxe . Ara es pot afirmar que el cotxe s'inicia tenint les seves propietats i el nom definits sota el constructor. Tot i que és possible que el color no s'esmenti dins de l'objecte quan s'iniciï, sempre estarà disponible al prototípic jerarquia . Per tant, hasOwnProperty() retornarà true sempre per al nom, però per al color, tornarà false.
variables globals js
Quan es tracta de rendiment, hasOwnProperty() funciona sense problemes mentre es fa camí a través de l'objecte amb bucles. A hores d'ara, podem dir que si les propietats pertanyen específicament a l'objecte. No tenen cap correlació amb el prototip. La demostració d'això es pot mostrar utilitzant el fragment de codi que es mostra a continuació.
// 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: Quan s'utilitza el mètode hasOwnProperty(), pot resultar inútil perquè la representació de l'objecte es produeix quan es defineix una propietat anomenada hasOwnProperty. Per donar suport a això, proveu d'entendre el fragment de codi que es mostra a continuació.
var harrypotter = { hasOwnProperty: function() { return true; } }; // Outputs: true console.log(harrypotter.hasOwnProperty('ridikulus')); En el fragment de codi anterior, és evident que harrypotter ja té hasOwnProperty. Per tant, mai no farà una crida a object.prototype.hasOwnProperty. Se suposa que això podria trobar casos en què pot permetre fer una trucada, però finalment pot fallar. Per tant, sempre es recomana ser conscient de la possibilitat de trucades. El fragment de codi següent mostra la seva solució.
// Returns false Object.prototype.hasOwnProperty.call(harrypotter, 'ridikulus');
En el fragment de codi anterior, és clar que Harrypotter defineix el seu propi hasOwnProperty . Mai farà trucades a Object.prototype.hasOwnProperty perquè hi ha la possibilitat que torni false si es troba amb alguns casos en què el valor és fals i es fa difícil fer que les coses funcionin a la volta de la cantonada. Per donar suport a aquesta afirmació, consulteu el fragment de codi que es mostra a continuació.
// Returns false Obje ct.prototype.hasOwnProperty.call(harrypotter, 'ridikulus');
Similar al hasOwnProperty, hi ha un altre mètode anomenat mètode 'in'. També s'utilitza per comprovar si la clau està present per a l'objecte o no. Tanmateix, és important tenir en compte que la diferència clau entre hasOwnProperty i el mètode in rau en el fet que el mètode in no seguirà l'ordre de distinció entre les propietats que s'hereten i les que les propietats heretades es creen especialment per a l'objecte. Això es pot mostrar mitjançant el fragment de codi que es mostra a continuació.
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); En el fragment de codi anterior, és evident que el mètode 'in' segueix la propietat del constructor de Object.prototype d'on s'hereten tots els objectes.
Per afegir alguns punts, hi ha un desavantatge per als dos mètodes. Ambdós mètodes ens poden donar fàcilment la informació sobre una propietat que ja s'ha declarat, però no ens poden informar sobre la propietat que conté un valor real.
Considereu el fragment de codi següent que mostra com els dos mètodes porten aquesta solució alternativa.
// 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); Conclusió
En aquest tutorial, hem parlat sobre el mètode hasOwnProperty() a JavaScript. En general, aquest mètode és una opció fantàstica per a la majoria dels desenvolupadors per consultar i evitar problemes relacionats amb algunes claus especials com el constructor. Es recomana que si trobem algun objecte amb alguna propietat, utilitzarà hasOwnProperty() per defecte. En cas de la presència de la funció destinada a fer una trucada comprovant l'objecte per al mètode toString(), hem d'utilitzar en.