Como verifico se um objeto tem uma propriedade específica em JavaScript?

Como verifico se um objeto tem uma propriedade específica em JavaScript?

Considerar:

x = {'key': 1};
if ( x.hasOwnProperty('key') ) {
    //Do this
}

Essa é a melhor maneira de fazer isso?

Estou realmente confuso com as respostas que foram dadas - a maioria delas é totalmente incorreta. Obviamente, você pode ter propriedades de objetos que tenham valores indefinidos, nulos ou falsos. Portanto, basta reduzir a verificação da propriedade para typeof this[property], ou pior ainda, x.keyfornecer resultados completamente enganosos.

Depende do que você está procurando. Se você deseja saber se um objeto contém fisicamente uma propriedade (e não vem de algum lugar na cadeia de protótipos), então object.hasOwnPropertyé o caminho a seguir. Todos os navegadores modernos são compatíveis. (Faltava nas versões mais antigas do Safari - 2.0.1 e mais antigas - mas essas versões do navegador raramente são mais usadas.)

Se o que você está procurando é se um objeto tem uma propriedade iterável (quando você iterar sobre as propriedades do objeto, ele aparecerá), então o procedimento: prop in objectdará o efeito desejado.

Como usar hasOwnPropertyé provavelmente o que você deseja, e considerando que você pode querer um método de fallback, apresento a você a seguinte solução:

var obj = {
    a: undefined,
    b: null,
    c: false
};

// a, b, c all found
for ( var prop in obj ) {
    document.writeln( "Object1: " + prop );
}

function Class(){
    this.a = undefined;
    this.b = null;
    this.c = false;
}

Class.prototype = {
    a: undefined,
    b: true,
    c: true,
    d: true,
    e: true
};

var obj2 = new Class();

// a, b, c, d, e found
for ( var prop in obj2 ) {
    document.writeln( "Object2: " + prop );
}

function hasOwnProperty(obj, prop) {
    var proto = obj.__proto__ || obj.constructor.prototype;
    return (prop in obj) &&
        (!(prop in proto) || proto[prop] !== obj[prop]);
}

if ( Object.prototype.hasOwnProperty ) {
    var hasOwnProperty = function(obj, prop) {
        return obj.hasOwnProperty(prop);
    }
}

// a, b, c found in modern browsers
// b, c found in Safari 2.0.1 and older
for ( var prop in obj2 ) {
    if ( hasOwnProperty(obj2, prop) ) {
        document.writeln( "Object2 w/ hasOwn: " + prop );
    }
}

A descrição acima é uma solução funcional, em vários navegadores, hasOwnPropertycom uma ressalva: não é possível distinguir entre os casos em que uma propriedade idêntica está no protótipo e na instância - apenas assume que é proveniente do protótipo. Você pode mudar para ser mais branda ou estrita, com base na sua situação, mas, no mínimo, isso deve ser mais útil.

Com Underscore.jsou ( melhor ainda ) lodash:

_.has(x, 'key');

Que chama Object.prototype.hasOwnProperty, mas (a) é mais curto para digitar e (b) usa "uma referência segura para hasOwnProperty" (ou seja, funciona mesmo se hasOwnPropertyfor sobrescrito).

Em particular, lodash define _.hascomo:

   function has(object, key) {
      return object ? hasOwnProperty.call(object, key) : false;
   }
   // hasOwnProperty = Object.prototype.hasOwnProperty

A respeito?

var x = {'key': 1};

if ('key' in x) {
    console.log('has');
}

Nota : hoje em dia é amplamente obsoleto graças ao modo estrito, e hasOwnProperty. A solução correta é usar o modo estrito e verificar a presença de uma propriedade usando obj.hasOwnProperty. Essa resposta é anterior a essas duas coisas, pelo menos como amplamente implementada (sim, é tão antiga). Tome o seguinte como uma nota histórica.

Lembre-se de que undefined(infelizmente) não é uma palavra reservada em JavaScript se você não estiver usando o modo estrito. Portanto, alguém (obviamente alguém) poderia ter a grande idéia de redefini-lo, quebrando seu código.

Um método mais robusto é, portanto, o seguinte:

if (typeof(x.attribute) !== 'undefined')

Por outro lado, esse método é muito mais detalhado e também mais lento. : - /

Uma alternativa comum é garantir que isso undefinedseja realmente indefinido, por exemplo, colocando o código em uma função que aceita um parâmetro adicional, chamado undefined, que não recebe um valor. Para garantir que não seja passado um valor, você mesmo pode chamá-lo imediatamente, por exemplo:

(function (undefined) {
    … your code …
    if (x.attribute !== undefined)
        … mode code …
})();

if (x.key !== undefined)

Armin Ronacher parece já ter me vencido , mas:

Object.prototype.hasOwnProperty = function(property) {
    return this[property] !== undefined;
};

x = {'key': 1};

if (x.hasOwnProperty('key')) {
    alert('have key!');
}

if (!x.hasOwnProperty('bar')) {
    alert('no bar!');
}

Uma solução mais segura, mas mais lenta, como apontado por Konrad Rudolph e Armin Ronacher, seria:

Object.prototype.hasOwnProperty = function(property) {
    return typeof this[property] !== 'undefined';
};

Você pode usar o inoperador para verificar se a propriedade existe em um objeto:

x = {'key': 1};
alert("key" in x);

Você também pode percorrer todas as propriedades do objeto usando um for - inloop e, em seguida, verificar a propriedade específica:

for (prop in x) {
    if (prop == "key") {
        //Do something
    }
}

Você deve considerar se essa propriedade de objeto é enumerável ou não, porque propriedades não enumeráveis ​​não serão exibidas em um for-inloop. Além disso, se a propriedade enumerável estiver sombreando uma propriedade não enumerável do protótipo, ela não será exibida no Internet Explorer 8 e versões anteriores.

Se você desejar uma lista de todas as propriedades da instância, sejam enumeráveis ​​ou não, poderá usar

Object.getOwnPropertyNames(x);

Isso retornará uma matriz de nomes de todas as propriedades que existem em um objeto.

Por fim, você pode usar o operador typeof para verificar diretamente o tipo de dados da propriedade do objeto:

if (typeof x.key == "undefined") {
    alert("undefined");
}

Se a propriedade não existir no objeto, ela retornará a string indefinida. Caso contrário, ele retornará o tipo de propriedade apropriado. No entanto, observe que essa nem sempre é uma maneira válida de verificar se um objeto tem uma propriedade ou não, porque você pode ter uma propriedade definida como indefinida; nesse caso, o uso typeof x.keyainda retornará true (mesmo que a chave ainda esteja no objeto).

Atualização: você pode verificar se existe uma propriedade comparando com a propriedade javascript indefinida

if (x.key === undefined) {
    alert("undefined");
}

Isso deve funcionar, a menos que a chave tenha sido definida especificamente undefinedno objeto x

Vamos cortar alguma confusão aqui. Primeiro, vamos simplificar assumindo que hasOwnPropertyjá existe; isso se aplica à grande maioria dos navegadores atuais em uso.

hasOwnPropertyretorna true se o nome do atributo que é passado para ele tiver sido adicionado ao objeto. É totalmente independente do valor real atribuído a ele, que pode ser exatamente undefined.

Conseqüentemente:

var o = {}
o.x = undefined

var a = o.hasOwnProperty('x')  // a is true
var b = o.x === undefined // b is also true

Contudo:

var o = {}

var a = o.hasOwnProperty('x')  // a is now false
var b = o.x === undefined // b is still true

O problema é o que acontece quando um objeto na cadeia de protótipos tem um atributo com o valor de indefinido? hasOwnPropertyserá falso por isso, e assim será !== undefined. No entanto, for..inainda o listará na enumeração.

A conclusão é que não existe uma maneira entre navegadores (já que o Internet Explorer não expõe __prototype__) para determinar que um identificador específico não foi anexado a um objeto ou qualquer coisa em sua cadeia de protótipos.

Se você estiver procurando por uma propriedade, então "NÃO". Você quer:

if ('prop' in obj) { }

Em geral, você não deve se importar se a propriedade vem ou não do protótipo ou do objeto.

No entanto, como você usou 'key' em seu código de exemplo, parece que você está tratando o objeto como um hash. Nesse caso, sua resposta faria sentido. Todas as chaves de hashes seriam propriedades no objeto e você evita as propriedades extras contribuídas pelo protótipo.

A resposta de John Resig foi muito abrangente, mas achei que não estava claro. Especialmente com quando usar "'prop' em obj".

Para testar objetos simples, use: if (obj[x] !== undefined)

Se você não souber que tipo de objeto é usado: if (obj.hasOwnProperty(x))

Todas as outras opções são mais lentas.

Detalhes

Avaliação de desempenho de 100.000.000 ciclos no Nodejs para as 5 opções sugeridas por outras pessoas aqui:

function hasKey1(k,o) { return (x in obj); }
function hasKey2(k,o) { return (obj[x]); }
function hasKey3(k,o) { return (obj[x] !== undefined); }
function hasKey4(k,o) { return (typeof(obj[x]) !== 'undefined'); }
function hasKey5(k,o) { return (obj.hasOwnProperty(x)); }

A avaliação nos diz que, a menos que desejemos especificamente verificar a cadeia de protótipos do objeto e o próprio objeto, não devemos usar a forma comum: if (X in Obj)... é entre 2 a 6 vezes mais lenta, dependendo do caso de uso

hasKey1 execution time: 4s 510.427785ms
hasKey2 execution time: 0s 904.374806ms
hasKey3 execution time: 0s 760.336193ms
hasKey4 execution time: 0s 935.19901ms
hasKey5 execution time: 2s 148.189608ms

Resumindo, se seu Obj não é necessariamente um objeto simples e você deseja evitar verificar a cadeia de protótipos do objeto e garantir que x seja de propriedade de Obj diretamente, use 'if (obj.hasOwnProperty (x)) ...'.

Caso contrário, ao usar um objeto simples e não se preocupar com a cadeia de protótipos do objeto, usar if (typeof(obj[x]) !== 'undefined')...é a maneira mais segura e rápida.

Se você usa um objeto simples como uma tabela de hash e nunca faz nada excêntrico, eu usaria o if (obj[x])...que eu acho muito mais legível.

Diverta-se.

Sim, é :) Eu acho que você também pode fazer o Object.prototype.hasOwnProperty.call(x, 'key')que também deve funcionar se xtiver uma propriedade chamada hasOwnProperty:)

Mas isso testa propriedades próprias. Se você deseja verificar se ele possui uma propriedade que também pode ser herdada, você pode usá-lo typeof x.foo != 'undefined'.

if (typeof x.key != "undefined") {

}

Porque

if (x.key)

falha se x.keyresolver para false(por exemplo, x.key = "").

Você também pode usar o Reflectobjeto ES6 :

x = {'key': 1};
Reflect.has( x, 'key'); // returns true

A documentação no MDN para Reflect.haspode ser encontrada aqui .

O Reflect.has()método estático funciona como o operador in como uma função.

OK, parece que eu tive a resposta certa, a menos que você não queira propriedades herdadas:

if (x.hasOwnProperty('key'))

Aqui estão algumas outras opções para incluir propriedades herdadas:

if (x.key) // Quick and dirty, but it does the same thing as below.

if (x.key !== undefined)

Não faça isso object.hasOwnProperty(key)), é muito ruim, porque esses métodos podem estar sombreados por propriedades no objeto em questão - considere { hasOwnProperty: false }- ou, o objeto pode ser um objeto nulo (Object.create(null)).

A melhor maneira é fazer Object.prototype.hasOwnProperty.call(object, key)ou:

const has = Object.prototype.hasOwnProperty; // cache the lookup once, in module scope.
/* or */
import has from 'has'; // https://www.npmjs.com/package/has
// ...
console.log(has.call(object, key));

Outra maneira relativamente simples é usar Object.keys. Isso retorna um, o arrayque significa que você obtém todos os recursos de uma matriz.

var noInfo = {};
var info = {something: 'data'};

Object.keys(noInfo).length //returns 0 or false
Object.keys(info).length //returns 1 or true

Embora estejamos em um mundo com ótimo suporte ao navegador. Como essa pergunta é tão antiga, pensei em adicionar: Isso é seguro para uso a partir do JS v1.8.5

hasOwnProperty "pode ​​ser usado para determinar se um objeto tem a propriedade especificada como uma propriedade direta desse objeto; diferente do operador in , esse método não verifica a cadeia de protótipos do objeto".

Portanto, provavelmente, para o que parece ser sua pergunta, você não deseja usar o hasOwnProperty, que determina se a propriedade existe como anexada diretamente ao próprio objeto ,.

Se você deseja determinar se a propriedade existe na cadeia de protótipos em que você deseja usar, como:

if( prop in object ){ // do something }

Eu espero que isso ajude.

Com risco de redução de votos massiva, aqui está outra opção para um caso específico. :)

Se você deseja testar um membro em um objeto e deseja saber se ele foi definido como algo diferente de:

• ''
• falso
• nulo
• Indefinido
• 0 ...

então você pode usar:

var foo = {};
foo.bar = "Yes, this is a proper value!";
if (!!foo.bar) {
        // member is set, do something
}

Solução ECMA Script 6 com reflect. Crie um invólucro como:

/**
Gets an argument from array or object.
The possible outcome:
- If the key exists the value is returned.
- If no key exists the default value is returned.
- If no default value is specified an empty string is returned.
@param obj    The object or array to be searched.
@param key    The name of the property or key.
@param defVal Optional default version of the command-line parameter [default ""]
@return The default value in case of an error else the found parameter.
*/
function getSafeReflectArg( obj, key, defVal) {
   "use strict";
   var retVal = (typeof defVal === 'undefined' ? "" : defVal);
   if ( Reflect.has( obj, key) ) {
       return Reflect.get( obj, key);
   }
   return retVal;
}  // getSafeReflectArg

Existe o método "hasOwnProperty" existente no objeto, mas não é recomendável chamar esse método diretamente, porque às vezes o objeto é nulo ou alguma propriedade existe no objeto, como: { hasOwnProperty: false }

Então, a melhor maneira seria:

// good
var obj = {"bar": "here bar desc"}
console.log(Object.prototype.hasOwnProperty.call(obj, "bar"));

// best
const has = Object.prototype.hasOwnProperty; // cache the lookup once, in module scope.
console.log(has.call(obj, "bar"));

Você pode usar as seguintes abordagens:

var obj = {a:1}
console.log('a' in obj)               //1
console.log(obj.hasOwnProperty('a'))  //2
console.log(Boolean(obj.a))         //3

A diferença entre as seguintes abordagens são as seguintes:

1. Na 1ª e na 3ª abordagem, não estamos apenas pesquisando no objeto, mas também na sua cadeia de protótipos. Se o objeto não tiver a propriedade, mas a propriedade estiver presente em sua cadeia de protótipos, ela será verdadeira.

 var obj = {
      a:2,
      __proto__ :{b:2}
    }

    console.log('b' in obj)
    console.log(Boolean(obj.b))

2. A segunda abordagem verificará apenas suas próprias propriedades. Ex -

var obj = {
      a:2,
      __proto__ :{b:2}
    }

    console.log(obj.hasOwnProperty('b'))

3. A diferença entre o primeiro e o terceiro é que, se houver uma propriedade com valor indefinido, a terceira abordagem fornecerá false, enquanto a primeira fornecerá true.

var obj = {
      b : undefined
    }
    console.log(Boolean(obj.b))
    console.log('b' in obj);

Você precisa usar o método object.hasOwnProperty(property). Retorna true se o objeto possui a propriedade e false se o objeto não possui.

Se a chave que você está verificando estiver armazenada em uma variável , você pode verificá-la assim:

x = {'key': 1};
y = 'key';
x[y];

Por que complicar demais as coisas quando você pode fazer:

var isProperty =  (objectname.keyname || "") ? true : false;

Simples e claro para a maioria dos casos ...