In questo tutorial vedremo gli aspetti relativi alle limitazioni e alle funzioni legate al haProprietà() metodo in JavaScript. Impareremo anche le sue implementazioni e il suo utilizzo nelle sezioni.
introduzione
In JavaScript , il metodo hasOwnProperty() è definito come proprietà per garantire se l'oggetto appartiene o meno al progetto menzionato. Se si scopre che la proprietà appartiene a un oggetto riconosciuto, restituirà un output basato su un'istruzione booleana, ovvero vero o falso.
Sintassi
object.hasOwnProperty(propname)
Discussione
Registrazione:
Qui, dobbiamo passare il simbolo o il nome della stringa perché questo è il luogo di prop in cui viene controllato se il simbolo o la stringa appartiene all'oggetto. Questo viene fatto utilizzando il metodo indicato di seguito.
albero binario vs bst
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 aspetto importante da notare qui è che il metodo hasOwnProperty() generalmente ignora le proprietà ereditate. Ciò significa che il metodo restituirà true se si scopre che l'oggetto ha una proprietà non ereditata e il nome è specificato da propname. Se restituisce false, significa che l'oggetto non ha alcuna proprietà con un nome specificato, oppure ha ereditato la proprietà dall'oggetto 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 altro vantaggio aggiuntivo derivante dall'utilizzo del metodo hasOwnProperty() è che può inizializzare un oggetto proseguendo con il concetto di passaggio di una stringa come argomento predefinito. Risponderà rapidamente con true se il valore risulta essere disponibile per l'oggetto. Altrimenti, restituirà false se non trovato. Può essere dimostrato utilizzando lo snippet di codice fornito di seguito.
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 Nello snippet di codice riportato sopra, la variabile crea un nuovo oggetto, Auto . Si può ora affermare che l'auto viene avviata con le sue proprietà e il nome definiti dal costruttore. Anche se il colore potrebbe non essere menzionato nell'oggetto al momento dell'avvio, sarà sempre disponibile sul prototipo gerarchia . Pertanto, hasOwnProperty() restituirà sempre true per il nome, ma per il colore restituirà false.
Quando si tratta di prestazioni, hasOwnProperty() funziona senza problemi mentre si fa strada attraverso l'oggetto con i loop. A questo punto possiamo dire che se le proprietà appartengono specificatamente all'oggetto. Non hanno alcuna correlazione con il prototipo. La dimostrazione di ciò può essere mostrata utilizzando lo snippet di codice fornito di seguito.
// 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: Durante l'utilizzo del metodo hasOwnProperty(), potrebbe diventare inutile perché il rendering dell'oggetto avviene quando si definisce una proprietà denominata hasOwnProperty. Per supportare ciò, prova a comprendere lo snippet di codice fornito di seguito.
Java localdatetime
var harrypotter = { hasOwnProperty: function() { return true; } }; // Outputs: true console.log(harrypotter.hasOwnProperty('ridikulus')); Nel frammento di codice sopra, è evidente che Harry Potter ha già hasOwnProperty. Pertanto, non effettuerà mai una chiamata a object.prototype.hasOwnProperty. Si presume che ciò possa verificarsi in casi in cui potrebbe consentire di effettuare una chiamata, ma alla fine potrebbe fallire. Pertanto, è sempre consigliabile essere consapevoli della possibilità di chiamate. Il frammento di codice seguente mostra la soluzione alternativa.
// Returns false Object.prototype.hasOwnProperty.call(harrypotter, 'ridikulus');
Nel frammento di codice sopra, è chiaro che Harry Potter definisce il proprio hasOwnProperty . Non effettuerà mai chiamate a Object.prototype.hasOwnProperty perché esiste la possibilità che possa restituire false se incontra alcuni casi in cui il valore è false e diventa difficile far funzionare le cose dietro l'angolo. Per supportare questa affermazione, vedere lo snippet di codice fornito di seguito.
// Returns false Obje ct.prototype.hasOwnProperty.call(harrypotter, 'ridikulus');
Simile a hasOwnProperty, esiste un altro metodo chiamato metodo 'in'. Viene utilizzato anche per verificare se la chiave è presente o meno per l'oggetto. Tuttavia, è importante notare che la differenza fondamentale tra hasOwnProperty e il metodo in risiede nel fatto che il metodo in non seguirà l'ordine di distinzione tra le proprietà che vengono ereditate e quelle che le proprietà ereditate vengono create appositamente per l'oggetto. Questo può essere mostrato utilizzando lo snippet di codice fornito di seguito.
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); Nel frammento di codice sopra, è evidente che il metodo 'in' segue la proprietà del costruttore di Object.prototype da cui tutti gli oggetti vengono ereditati.
Per aggiungere alcuni punti, entrambi i metodi presentano uno svantaggio. Entrambi i metodi possono facilmente darci informazioni su una proprietà che è già stata dichiarata ma non possono dirci se la proprietà contiene un valore reale.
database Java jdbc
Considera il seguente frammento di codice che mostra come entrambi i metodi implementano questa soluzione 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); Conclusione
In questo tutorial, abbiamo discusso del metodo hasOwnProperty() in JavaScript. In generale, questo metodo è un'ottima scelta per la maggior parte degli sviluppatori per informarsi ed evitare problemi relativi ad alcuni tasti speciali come il costruttore. Si consiglia, se troviamo un oggetto con una proprietà, di utilizzare hasOwnProperty() per impostazione predefinita. In caso di presenza di una funzione destinata a effettuare una chiamata controllando l'oggetto per il metodo toString(), dobbiamo utilizzare in.