Che cos'è la proprietà in hasOwnProperty in JavaScript?


97

Prendere in considerazione:

if (someVar.hasOwnProperty('someProperty') ) {
 // Do something();
} else {
 // Do somethingElse();
}

Qual è il giusto uso / spiegazione di hasOwnProperty('someProperty')?

Perché non possiamo semplicemente usare someVar.somePropertyper verificare se un oggetto someVarcontiene una proprietà con nome someProperty?

Cos'è una proprietà in questo caso?

Quale proprietà controlla questo JavaScript?



Quando ho posto questa domanda ho pensato che fosse una funzione che controllava alcuni html. Ora lo vedo controllare un oggetto o un metodo javascript per una "variabile" all'interno di quell'oggetto o metodo. grazie!
VOLO

Risposte:


165

hasOwnPropertyrestituisce un valore booleano che indica se l'oggetto su cui lo stai chiamando ha una proprietà con il nome dell'argomento. Per esempio:

var x = {
    y: 10
};
console.log(x.hasOwnProperty("y")); //true
console.log(x.hasOwnProperty("z")); //false

Tuttavia, non guarda la catena del prototipo dell'oggetto.

È utile usarlo quando si enumerano le proprietà di un oggetto con il for...incostrutto.

Se vuoi vedere tutti i dettagli, la specifica ES5 è, come sempre, un buon posto dove guardare.


6
Punti bonus per la catena di prototipi. window
Sto

@KristofferSHansen - Mi stavo chiedendo anche questo, ma la domanda è stata modificata, quindi ora viene chiamata su un oggetto. Quando non lo è, viene generato un errore.
James Allardice

Suppongo che cambi le cose. Nessun errore quando viene eseguito dalla console in Chrome però.
Kristoffer Sall-Storgaard

@KristofferSHansen - Penso che sia dovuto al modo in cui la console esegue il codice (viene eseguito come evalcodice anziché come codice globale o funzione). L'ho provato in una pagina HTML vuota e ho ricevuto un errore "Impossibile convertire da null a oggetto".
James Allardice

@KristofferSHansen vede la risposta di Kunal Vashist quando viene chiamato su un metodo di classe
FLY

25

Ecco una risposta breve e precisa:

In JavaScript, ogni oggetto ha un gruppo di coppie chiave-valore incorporate che contengono meta informazioni sull'oggetto. Quando esegui il ciclo attraverso tutte le coppie chiave-valore utilizzando for...incostrutto / ciclo per un oggetto, stai eseguendo il ciclo anche attraverso queste coppie chiave-valore di meta-informazione (cosa che sicuramente non vuoi).

Inserisci qui la descrizione dell'immagine

L'utilizzo di hasOwnPropery(property) filtri elimina questi cicli non necessari attraverso le meta informazioni e controlla direttamente che il parametro propertysia una proprietà data dall'utente nell'oggetto o meno. Per filtri di uscita , intendo, questo hasOwnProperty(property)non sembra propertyesistere nella catena di prototipi di Object, ovvero le meta informazioni.

Restituisce un valore booleano true/falsebasato su quello.

Ecco un esempio:

var fruitObject = {"name": "Apple", "shape": "round", "taste": "sweet"};
console.log(fruitObject.hasOwnProperty("name"));  //true
console.log(Object.prototype.hasOwnProperty("toString");) //true because in above snapshot you can see, that there is a function toString in meta-information

Spero sia chiaro!


l'ultima riga del tuo esempio che scrivi console.log(Object.prototype....; intendevi console.log(fruitObject.? fruttoOggetto o oggetto?
Hamid Araghi

> "stai scorrendo anche attraverso queste coppie chiave-valore di meta-informazione" Ma quando for (var key in fruitObject) { ... }eseguo comunque js cicli attraverso chiavi non prototipo, mi manca qualcosa o il runtime JS ha cambiato il modo in cui gestiscono per la chiave nell'oggetto loop?
ChickenFeet

13

Controlla:

Restituisce un valore booleano che indica se un oggetto ha una proprietà con il nome specificato

Il metodo hasOwnProperty restituisce true se l'oggetto ha una proprietà del nome specificato, false in caso contrario. Questo metodo non controlla se la proprietà esiste nella catena di prototipi dell'oggetto; la proprietà deve essere un membro dell'oggetto stesso.

Esempio:

var s = new String("Sample");
document.write(s.hasOwnProperty("split"));                        //false
document.write(String.prototype.hasOwnProperty("split"));         //true

2
Ho dato -1 perché la tua risposta iniziale era una frase breve e del tutto incoerente, che è stata poi aggiornata a una frase leggermente più lunga, leggermente più coerente, ma del tutto imprecisa.

@ amnotiam- ma penso che sia molto chiaro ora ... è perché il mio problema con Internet non riesco a postare altro ..........
Pranay Rana

12

Sommario:

hasOwnProperty()è una funzione che può essere chiamata su qualsiasi oggetto e accetta una stringa come input. Restituisce un booleano che è truese la proprietà si trova sull'oggetto, altrimenti restituisce false. hasOwnProperty()si trova su Object.prototypee quindi disponibile per qualsiasi oggetto.

Esempio:

function Person(name) {
  this.name = name;
}

Person.prototype.age = 25;

const willem = new Person('willem');

console.log(willem.name); // Property found on object
console.log(willem.age); // Property found on prototype

console.log(willem.hasOwnProperty('name')); // 'name' is on the object itself
console.log(willem.hasOwnProperty('age')); // 'age' is not on the object itself

In questo esempio viene creato un nuovo oggetto Person. Ogni persona ha il proprio nome che viene inizializzato nel costruttore. Tuttavia, l'età non si trova sull'oggetto ma sul prototipo dell'oggetto. Quindi hasOwnProperty()ritorna trueper nome e falseper età.

Applicazioni pratiche:

hasOwnProperty()può essere molto utile quando si esegue il loop su un oggetto utilizzando un for inloop. Puoi controllare con esso se le proprietà provengono dall'oggetto stesso e non dal prototipo. Per esempio:

function Person(name, city) {
  this.name = name;
  this.city = city;
}

Person.prototype.age = 25;

const willem = new Person('Willem', 'Groningen');

for (let trait in willem) {
  console.log(trait, willem[trait]); // This loops through all properties, including the prototype
}

console.log('\n');

for (let trait in willem) {
  if (willem.hasOwnProperty(trait)) { // This loops only through 'own' properties of the object
    console.log(trait, willem[trait]);
  }
}


3

Si utilizza object.hasOwnProperty ( p ) per determinare se un oggetto ha una proprietà enumerabile p -

Un oggetto può avere il proprio prototipo, in cui i metodi e gli attributi "predefiniti" vengono assegnati a ogni istanza dell'oggetto. hasOwnProperty restituisce true solo per le proprietà specificatamente impostate nel costruttore o aggiunte all'istanza in un secondo momento.

Per determinare se p è definito affatto, ovunque, per l'oggetto, utilizzare if ( p instanceof object), dove p restituisce una stringa del nome della proprietà.

Ad esempio, per impostazione predefinita tutti gli oggetti hanno un metodo "toString", ma non verrà visualizzato in hasOwnProperty.


2

hasOwnProperty è una normale funzione JavaScript che accetta un argomento stringa.

Nel tuo caso, somevar.hasOwnProperty('someProperty')controlla che la somevarfunzione abbia someproperyo meno - restituisce vero e falso.

Dire

function somevar() {
    this.someProperty = "Generic";
}

function welcomeMessage()
{
    var somevar1 = new somevar();
    if(somevar1.hasOwnProperty("name"))
    {
        alert(somevar1.hasOwnProperty("name")); // It will return true
    }
}

2

hasOwnPropertyè un modo corretto per verificare che un oggetto abbia o meno una proprietà . someVar.somePropertynon può essere utilizzato come alternativa a questa situazione. La seguente condizione mostrerà una buona differenza:

const someVar = { isFirst: false };


// The condition is true, because 'someVar' has property 'isFirst'
if (someVar.hasOwnProperty('isFirst')) {
  // Code runs
}


// The condition is false, because 'isFirst' is false.
if (someVar.isFirst) {
  // Code does not runs here
}

Quindi someVar.isFirstnon può essere utilizzato in alternativa a someVar.hasOwnProperty('isFirst').


-1

Scena A:

const objA = { a: 1, b: 2 }
for (const key in objA) {
  if (objA.hasOwnProperty(key)) {
    console.log(objA[key])
  }
}

    Output

    1
    2

Scena B:

const objB = {
  a: 1,
  b: 2,
  hasOwnProperty() {
    return false
  }
}

for (const key in objB) {
  if (objB.hasOwnProperty(key)) {
    console.log(objB[key])
  }
}

    Outputs nothing

Perché JavaScript non protegge la proprietà di hasOwnProperty. Quindi puoi usarlo in questo modo:

for (const key in objB) {
  if (Object.prototype.hasOwnProperty.call(obj, key)) {
    console.log(objB[key])
  }
}

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.