Šajā apmācībā mēs redzēsim ierobežojumu un funkciju aspektus, kas saistīti ar hasOwnProperty() metode JavaScript. Sadaļās uzzināsim arī par tā ieviešanu un lietošanu.

fibonači secība java

Ievads

In JavaScript , metode hasOwnProperty() tiek definēta kā rekvizīts, kas nodrošina objekta piederību minētajam projektam vai nē. Ja tiek konstatēts, ka rekvizīts pieder atpazītam objektam, tas atgriež Būla paziņojumu balstītu izvadi, t.i., patiesu vai nepatiesu.

Sintakse

 object.hasOwnProperty(propname) 

Arguments

Ieraksts:

Šeit mums ir jānodod simbols vai virknes nosaukums, jo šī ir atbalsta vieta, kur tiek pārbaudīts, vai simbols vai virkne pieder objektam. Tas tiek darīts, izmantojot tālāk norādīto metodi.

 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 

Viens svarīgs aspekts, kas jāņem vērā, ir tas, ka metode hasOwnProperty() parasti ignorē mantotās īpašības. Tas nozīmē, ka metode atgriež savu patieso vērtību, ja tiek konstatēts, ka objektam ir nemantota īpašība un nosaukums ir norādīts ar propname. Ja tas atgriež false, tas nozīmē, ka objektam nav rekvizītu ar noteiktu nosaukumu vai tas ir mantojis īpašumu no proptype objekta.

 // 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 

Vēl viena metodes hasOwnProperty() izmantošanas priekšrocība ir tā, ka tā var inicializēt objektu, ievērojot jēdzienu par virknes nodošanu kā noklusējuma argumentu. Ja tiek konstatēts, ka vērtība objektam ir pieejama, tā ātri reaģē ar patiesu. Pretējā gadījumā tas atgriezīsies nepatiess, ja netiks atrasts. To var demonstrēt, izmantojot tālāk norādīto koda fragmentu.

 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 

Iepriekš norādītajā koda fragmentā mainīgais izveido jaunu objektu, Automašīna . Tagad var teikt, ka Automašīna ir iniciēta ar tās īpašībām un nosaukumu, kas definēts zem konstruktora. Lai gan krāsa var nebūt norādīta objektā, uzsākot to, tā vienmēr būs pieejama prototipā hierarhija . Tāpēc hasOwnProperty() nosaukumam vienmēr atgriezīs patieso vērtību, bet krāsai — false.

Runājot par veiktspēju, hasOwnProperty() darbojas nevainojami, vienlaikus izkļūstot objektā ar cilpām. Līdz šim mēs varam teikt, ka, ja īpašumi īpaši pieder objektam. Viņiem nav nekādas korelācijas ar prototipu. To var parādīt, izmantojot tālāk norādīto koda fragmentu.

 // 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: 

Izmantojot metodi hasOwnProperty(), tā var izrādīties bezjēdzīga, jo objekta renderēšana notiek, definējot rekvizītu hasOwnProperty. Lai to atbalstītu, mēģiniet izprast tālāk norādīto koda fragmentu.

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

Iepriekš minētajā koda fragmentā ir redzams, ka harrypotter jau ir hasOwnProperty. Tādējādi tas nekad neizsauks objektu object.prototype.hasOwnProperty. Tiek pieņemts, ka tas var rasties gadījumos, kad tas var ļaut veikt zvanu, bet galu galā tas var neizdoties. Tāpēc vienmēr ieteicams apzināties zvanu iespējamību. Tālāk redzamais koda fragments parāda tā risinājumu.

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

Iepriekš minētajā koda fragmentā ir skaidrs, ka harrypotter definē savu hasOwnProperty . Tas nekad neizsauks objektu Object.prototype.hasOwnProperty, jo pastāv iespēja, ka tas var atgriezt vērtību false, ja tiek konstatēti gadījumi, kad vērtība ir nepatiesa un kļūst grūti panākt, lai lietas darbotos aiz stūra. Lai atbalstītu šo apgalvojumu, skatiet tālāk norādīto koda fragmentu.

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

Līdzīgi kā hasOwnProperty, ir vēl viena metode, ko sauc par “in” metodi. To izmanto arī, lai pārbaudītu, vai objekta atslēga ir vai nav. Tomēr ir svarīgi atzīmēt, ka galvenā atšķirība starp hasOwnProperty un in metodi slēpjas faktā, ka in metode netiks ievērota secībā, kurā tiek atšķirti rekvizīti, kas tiek mantoti, un mantotie rekvizīti, kas ir īpaši izveidoti objektam. To var parādīt, izmantojot tālāk norādīto koda fragmentu.

 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); 

Iepriekš minētajā koda fragmentā ir skaidrs, ka metode “in” seko objekta Object.prototype konstruktora rekvizītam, no kurienes tiek mantoti visi objekti.

Lai pievienotu dažus punktus, abām metodēm ir trūkums. Abas metodes var viegli sniegt mums informāciju par īpašumu, kas jau ir deklarēts, taču tās nevar mums pastāstīt par īpašumu, kurā ir reāla vērtība.

Apsveriet šo koda fragmentu, kas parāda, kā abas metodes nodrošina šo risinājumu.

 // 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); 

Secinājums

Šajā apmācībā mēs apspriedām hasOwnProperty() metodi JavaScript. Kopumā šī metode ir lieliska izvēle lielākajai daļai izstrādātāju, lai uzzinātu un izvairītos no problēmām, kas saistītas ar dažām īpašām atslēgām, piemēram, konstruktoru. Ja mēs atrodam kādu objektu, kuram ir kāds rekvizīts, ieteicams pēc noklusējuma izmantot hasOwnProperty(). Ja ir funkcija, kas paredzēta izsaukšanai, pārbaudot objektu toString() metodei, mums ir jāizmanto in.