node - JavaScript: ¿Se ha definido un miembro?

object.keys javascript

Question

Me parece que hay cuatro maneras diferentes en que puedo determinar si un objeto dado (por ejemplo, foo ) tiene una propiedad determinada (por ejemplo, una bar ) definida:

1. if (foo.hasOwnProperty(bar)) {
2. if (''bar'' in foo) {
3. if (typeof foo.bar !== ''undefined'') {
4. if (foo.bar === undefined) {

Para determinar si hay una propiedad llamada " bar " en el objeto foo , ¿son las tres declaraciones equivalentes? ¿Hay alguna semántica de sublte que no conozca que haga que alguna de estas tres afirmaciones sea diferente?

Answer 1

De hecho, hay algunas diferencias sutiles entre los distintos métodos / palabras clave.

1. foo.hasOwnProperty(''bar'') devuelve true solo si la propiedad ''bar'' está definida en el propio objeto foo. Sin embargo, otras propiedades, como ''toString'' devolverán false, ya que están definidas en la cadena del prototipo.

2. El operador de palabra clave in devuelve true si la propiedad especificada está en el objeto especificado. Tanto ''bar'' in foo como ''toString'' in foo volverían verdaderos.

3. Ya que está verificando el estado de la propiedad, el resultado será verdadero cuando la barra no esté definida en foo y cuando la barra esté definida pero el valor esté configurado como undefined .

Answer 2

Estos son todos diferentes:

1. foo.hasOwnProperty(''bar'') le dice si foo tiene la propiedad y no realiza búsquedas a lo largo de la cadena de prototipos.

2. ''bar'' in foo verifica la cadena del prototipo y devuelve true cuando encuentra la bar propiedades en cualquier objeto a lo largo de la cadena.

3. typeof foo.bar != ''undefined'' devuelve true si foo o cualquier objeto a lo largo de su cadena de prototipos tiene una bar propiedades y su valor no está undefined .

Aquí hay un ejemplo que demuestra estas diferencias:

var foo1 = { ''bar1'': 10, ''bar2'': undefined };
function ctor() {}
ctor.prototype = foo1;
var foo2 = new ctor();
foo2.bar3 = 20;

console.log(foo2.hasOwnProperty(''bar1'')); // false
console.log(foo2.hasOwnProperty(''bar2'')); // false
console.log(foo2.hasOwnProperty(''bar3'')); // true
console.log(foo2.hasOwnProperty(''bar4'')); // false

console.log(''bar1'' in foo2); // true
console.log(''bar2'' in foo2); // true
console.log(''bar3'' in foo2); // true
console.log(''bar4'' in foo2); // false

console.log(typeof foo2.bar1 != ''undefined''); // true
console.log(typeof foo2.bar2 != ''undefined''); // false
console.log(typeof foo2.bar3 != ''undefined''); // true
console.log(typeof foo2.bar4 != ''undefined''); // false

Answer 3

No son totalmente diferentes. Ejemplo:

foo = {bar: undefined};
Object.prototype.baz = undefined;
Object.prototype.bing = "hello";

Entonces:

(typeof foo.bar != "undefined")  === false
(''bar'' in foo)                   === true
(foo.hasOwnProperty(''bar''))      === true


(typeof foo.baz != "undefined")  === false
(''baz'' in foo)                   === true
(foo.hasOwnProperty(''baz''))      === false


(typeof foo.bing != "undefined") === true
(''bing'' in foo)                  === true
(foo.hasOwnProperty(''bing''))     === false

En cuanto a la lógica:

• foo.hasOwnProperty(''bar'') implica ''bar'' in foo
• typeof foo.bar != "undefined" implica ''bar'' in foo
• Pero esas son las únicas inferencias que puedes sacar; ninguna otra implicación es universalmente cierta, como muestran los ejemplos anteriores.

Answer 4

Para agregar a lo que otros han dicho, si solo quiere saber si una propiedad existe y tiene un valor no falso (no undefined , null , false , 0 , "" , NaN , etc ...), simplemente puede hacer esta:

if (foo.bar) {
     // code here
}

Mientras los valores falsey no sean interesantes para su circunstancia particular, este atajo le dirá si la variable se ha configurado como algo útil para usted o no.

Si quiere saber si la propiedad existe en el objeto de alguna manera, considero que es la más útil, breve y legible:

if (''bar'' in foo) {
    // code here
}

También se puede usar algo similar en los argumentos de la función (de nuevo, siempre y cuando un valor falsey no sea algo que le importe):

function foo(bar) {
    if (bar) {
        // bar was passed and has some non-falsey value
    }
}

Answer 5

una diferencia es que, el método 1 solo verificará el objeto foo para la barra de propiedades, mientras que los dos últimos métodos también verificarán el prototipo de la propiedad heredada.

Answer 6

''bar'' in foo 

Buscará en cualquier lugar la cadena del prototipo. La prueba para ver si foo.bar ! == undefined también devolverá verdadero si la bar está en foo lugar en la cadena de prototipos de foo , pero recuerde que si la barra está definida en foo, y configurada como indefinida, esto devolverá falso.

hasOwnProperty es más selectivo: solo devolverá true si bar se define como una propiedad directa de foo .

Por MDN

Cada objeto que desciende de Object hereda el método hasOwnProperty. Este método se puede usar para determinar si un objeto tiene la propiedad especificada como una propiedad directa de ese objeto; a diferencia del operador in, este método no comprueba la cadena del prototipo del objeto.