javascript - node - if(key in object) o if(object.hasOwnProperty(clave)

object key javascript

Question

¿Las siguientes dos declaraciones producen el mismo resultado? ¿Hay alguna razón para preferir un camino a otro?

 if (key in object)

 if (object.hasOwnProperty(key))

Answer 1

La otra forma (llamada en) enumera los nombres de propiedad (o claves) de un objeto. En cada iteración, se asigna otra cadena de nombre de propiedad del objeto a la variable. Por lo general, es necesario probar object.hasOwnProperty (variable) para determinar si el nombre de la propiedad es realmente un miembro del objeto o se encontró en su lugar en la cadena del prototipo.

 for (myvar in obj) {
     if (obj.hasOwnProperty(myvar)) { ... } }

(de Crockford''s Javascript: The Good Parts )

Answer 2

La primera versión es más corta (especialmente en código minificado donde las variables se renombran)

a in b

vs

b.hasOwnProperty(a)

De todos modos, como dijo @AndreMeinhold, no siempre producen el mismo resultado.

Answer 3

Tenga cuidado: no producirán el mismo resultado.

in también devolverá true si se encuentra key en algún lugar de la cadena de prototipos , mientras que Object.hasOwnProperty (como el nombre ya nos dice), solo devolverá true si la key está disponible en ese objeto directamente (es "propietaria" de la propiedad).

Answer 4

Tienes algunas realmente buenas respuestas. Solo quiero ofrecer algo que le ahorrará la necesidad de verificar "hasOwnProperty" mientras itera un objeto.

Al crear un objeto, generalmente las personas lo crearán de esta manera:

const someMap = {}
// equivalent to: Object.create(Object.prototype)
// someMap.constructor will yield -> function Object() { [native code] }

Ahora, si quiere iterar a través de "someMap" tendrá que hacerlo de esta manera:

const key
for(key in someMap ){
 if (someMap.hasOwnProperty(key)) { 
   // Do something
 }
}

Lo estamos haciendo para evitar iterar sobre propiedades heredadas.

Si tiene la intención de crear un objeto simple que solo se utilizará como un "mapa" (es decir, pares clave-valor), puede hacerlo así:

const newMap = Object.create(null);
// Now, newMap won''t have prototype at all.
// newMap.constructor will yield -> undefined

Entonces ahora será seguro repetir de esta manera:

for(key in cleanMap){
 console.log(key + " -> " + newMap [key]);
 // No need to add extra checks, as the object will always be clean
}

Aprendí este consejo increíble here

Answer 5

Trataré de explicarlo con otro ejemplo. Digamos que tenemos el siguiente objeto con dos propiedades:

function TestObj(){
    this.name = ''Dragon'';
}
TestObj.prototype.gender = ''male'';

Vamos a crear una instancia de TestObj:

var o = new TestObj();

Examinemos la instancia del objeto:

console.log(o.hasOwnProperty(''name'')); // true
console.log(''name'' in o); // true

console.log(o.hasOwnProperty(''gender'')); // false
console.log(''gender'' in o); // true

Conclusión:

• in operator devuelve true siempre, si el objeto puede acceder a la propiedad directamente o desde el prototipo

• hasOwnProperty () devuelve verdadero solo si la propiedad existe en la instancia, pero no en su prototipo

Si queremos verificar que existan algunas propiedades en el prototipo, lógicamente, diríamos:

console.log((''name'' in o) && !o.hasOwnProperty(''name'')); //false
console.log((''gender'' in o) && !o.hasOwnProperty(''gender'')); //true - it''s in prototype

Finalmente:

Entonces, con respecto a la afirmación de que estas dos condiciones ...

if (key in object)
if (object.hasOwnProperty(key))

... produce el mismo resultado, la respuesta es obvia, depende.

Answer 6

in también comprobará las propiedades heredadas, que no es el caso de hasOwnProperty .

Answer 7

En resumen, hasOwnProperty() no se ve en el prototipo mientras se encuentra en el prototipo.

Tomado de O''Reilly High Performance Javascript :

Puede determinar si un objeto tiene un miembro de instancia con un nombre dado utilizando el método hasOwnProperty () y pasando el nombre del miembro. Para determinar si un objeto tiene acceso a una propiedad con un nombre dado, puede usar el operador in. Por ejemplo:

var book = {
    title: "High Performance JavaScript",
    publisher: "Yahoo! Press" 
};

alert(book.hasOwnProperty("title"));  //true
alert(book.hasOwnProperty("toString"));  //false
alert("title" in book); //true 
alert("toString" in book); //true

En este código, hasOwnProperty () devuelve verdadero cuando se pasa "title" porque title es una instancia de objeto; el método devuelve falso cuando se pasa "toString" porque no existe en la instancia. Cuando cada nombre de propiedad se utiliza con el operador in, el resultado es verdadero ambas veces porque busca la instancia y el prototipo.