Come posso verificare se un oggetto ha una proprietà specifica in JavaScript?

Come posso verificare se un oggetto ha una proprietà specifica in JavaScript?

Prendere in considerazione:

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

È questo il modo migliore per farlo?

Sono davvero confuso dalle risposte che sono state date - la maggior parte di esse sono semplicemente errate. Ovviamente puoi avere proprietà dell'oggetto che hanno valori indefiniti, nulli o falsi. Quindi semplicemente riducendo il controllo della proprietà a typeof this[property], o peggio ancora, x.keyotterrai risultati completamente fuorvianti.

Dipende da cosa stai cercando. Se vuoi sapere se un oggetto contiene fisicamente una proprietà (e non proviene da qualche parte della catena del prototipo), allora object.hasOwnPropertyè la strada da percorrere. Tutti i browser moderni lo supportano. (Mancava nelle versioni precedenti di Safari - 2.0.1 e precedenti - ma quelle versioni del browser raramente vengono più utilizzate.)

Se quello che stai cercando è se un oggetto ha una proprietà che è iterabile (quando si scorre sulle proprietà dell'oggetto, apparirà), allora facendo: prop in objectti darà l'effetto desiderato.

Poiché l'utilizzo hasOwnPropertyè probabilmente quello che desideri, e considerando che potresti voler un metodo di fallback, ti ​​presento la seguente soluzione:

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 );
    }
}

Quanto sopra è una soluzione funzionante, cross-browser, hasOwnPropertycon un avvertimento: non è in grado di distinguere tra casi in cui una proprietà identica si trova sul prototipo e sull'istanza - presuppone solo che provenga dal prototipo. Potresti spostarlo in modo che sia più indulgente o severo, in base alla tua situazione, ma almeno questo dovrebbe essere più utile.

Con Underscore.jso ( anche meglio ) lodash:

_.has(x, 'key');

Che chiama Object.prototype.hasOwnProperty, ma (a) è più breve da digitare, e (b) usa "un riferimento sicuro a hasOwnProperty" (cioè funziona anche se hasOwnPropertyviene sovrascritto).

In particolare, lodash definisce _.hascome:

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

Che dire?

var x = {'key': 1};

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

Nota : al giorno d'oggi è in gran parte obsoleto grazie alla modalità rigorosa e hasOwnProperty. La soluzione corretta è utilizzare la modalità rigorosa e verificare la presenza di una proprietà utilizzando obj.hasOwnProperty. Questa risposta precede entrambe queste cose, almeno quanto ampiamente implementate (sì, è quella vecchia). Prendi quanto segue come nota storica.

Tieni presente che, undefinedpurtroppo, non è una parola riservata in JavaScript se non stai utilizzando la modalità rigorosa. Pertanto, qualcuno (qualcun altro, ovviamente) potrebbe avere la grande idea di ridefinirlo, rompendo il codice.

Un metodo più solido è quindi il seguente:

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

D'altro canto, questo metodo è molto più dettagliato e anche più lento. : - /

Un'alternativa comune è garantire che undefinedsia effettivamente definito, ad esempio mettendo il codice in una funzione che accetta un parametro aggiuntivo, denominato undefined, che non è passato un valore. Per assicurarti che non venga passato un valore, puoi semplicemente chiamarlo tu stesso immediatamente, ad esempio:

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

if (x.key !== undefined)

Armin Ronacher sembra avermi già battuto , ma:

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!');
}

Una soluzione più sicura, ma più lenta, come sottolineato da Konrad Rudolph e Armin Ronacher sarebbe:

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

È possibile utilizzare l' inoperatore per verificare se la proprietà esiste su un oggetto:

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

Puoi anche scorrere tutte le proprietà dell'oggetto usando un for - inciclo, quindi controllare la proprietà specifica:

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

È necessario considerare se questa proprietà dell'oggetto è enumerabile o meno, poiché le proprietà non enumerabili non verranno visualizzate in un for-inciclo. Inoltre, se la proprietà enumerabile mette in ombra una proprietà non enumerabile del prototipo, non verrà visualizzata in Internet Explorer 8 e versioni precedenti.

Se desideri un elenco di tutte le proprietà dell'istanza, enumerabili o meno, puoi utilizzare

Object.getOwnPropertyNames(x);

Ciò restituirà una matrice di nomi di tutte le proprietà esistenti su un oggetto.

Infine, puoi utilizzare l'operatore typeof per verificare direttamente il tipo di dati della proprietà dell'oggetto:

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

Se la proprietà non esiste sull'oggetto, restituirà la stringa non definita. Altrimenti restituirà il tipo di proprietà appropriato. Tuttavia, tieni presente che questo non è sempre un modo valido per verificare se un oggetto ha una proprietà o meno, perché potresti avere una proprietà che è impostata su indefinita, nel qual caso l'utilizzo typeof x.keycontinuerebbe a restituire true (anche se la chiave è ancora nell'oggetto).

Aggiornamento: è possibile verificare l'esistenza di una proprietà confrontandola con la proprietà javascript non definita

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

Questo dovrebbe funzionare a meno che key non sia stato specificamente impostato undefinedsu sull'oggetto x

Facciamo un po 'di confusione qui. Innanzitutto, semplifichiamo assumendo che hasOwnPropertyesista già; questo è vero per la stragrande maggioranza degli attuali browser in uso.

hasOwnPropertyrestituisce vero se il nome dell'attributo che gli è stato passato è stato aggiunto all'oggetto. È completamente indipendente dal valore effettivo assegnato che può essere esattamente undefined.

Quindi:

var o = {}
o.x = undefined

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

Però:

var o = {}

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

Il problema è cosa succede quando un oggetto nella catena di prototipi ha un attributo con il valore di indefinito? hasOwnPropertysarà falso per questo, e così sarà !== undefined. Tuttavia, for..inlo elencherò comunque nell'elenco.

La linea di fondo è che non esiste un modo cross-browser (poiché Internet Explorer non espone __prototype__) per determinare che un identificatore specifico non sia stato collegato a un oggetto o qualcosa nella sua catena di prototipi.

Se stai cercando una proprietà, quindi "NO". Tu vuoi:

if ('prop' in obj) { }

In generale non dovresti preoccuparti se la proprietà proviene o meno dal prototipo o dall'oggetto.

Tuttavia, poiché hai usato "chiave" nel tuo codice di esempio, sembra che tu stia trattando l'oggetto come un hash, nel qual caso la tua risposta avrebbe senso. Tutte le chiavi di hash sarebbero proprietà dell'oggetto e si eviteranno le proprietà extra fornite dal prototipo.

La risposta di John Resig è stata molto esaustiva, ma ho pensato che non fosse chiaro. Soprattutto con quando usare "'prop' in obj".

Per testare oggetti semplici usare: if (obj[x] !== undefined)

Se non sai che tipo di oggetto è usare: if (obj.hasOwnProperty(x))

Tutte le altre opzioni sono più lente ..

Dettagli

Valutazione delle prestazioni di 100.000.000 di cicli con Nodejs rispetto alle 5 opzioni suggerite da altri qui:

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)); }

La valutazione ci dice che se non vogliamo specificamente verificare la catena di prototipi dell'oggetto e l'oggetto stesso, non dovremmo usare la forma comune: if (X in Obj)... è da 2 a 6 volte più lenta a seconda del caso d'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

In conclusione, se il tuo Obj non è necessariamente un oggetto semplice e desideri evitare di controllare la catena di prototipi dell'oggetto e assicurarti che x sia di proprietà di Obj direttamente, usa 'if (obj.hasOwnProperty (x)) ...'.

Altrimenti, quando si utilizza un oggetto semplice e non si è preoccupati della catena di prototipi dell'oggetto, l'uso if (typeof(obj[x]) !== 'undefined')...è il modo più sicuro e veloce.

Se usi un oggetto semplice come tabella hash e non fai mai nulla di strano, lo userei if (obj[x])...perché lo trovo molto più leggibile.

Divertiti.

Sì lo è :) Penso che puoi anche fare Object.prototype.hasOwnProperty.call(x, 'key')che dovrebbe funzionare anche se xha una proprietà chiamata hasOwnProperty:)

Ma questo verifica le proprie proprietà. Se si desidera verificare se ha una proprietà che può anche essere ereditata, è possibile utilizzare typeof x.foo != 'undefined'.

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

}

Perché

if (x.key)

fallisce se si x.keyrisolve in false(ad esempio, x.key = "").

È inoltre possibile utilizzare l' Reflectoggetto ES6 :

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

La documentazione su MDN per Reflect.hasè disponibile qui .

Il Reflect.has()metodo statico funziona come l' operatore in come funzione.

OK, sembra che io abbia avuto la risposta giusta a meno che se non vuoi proprietà ereditate:

if (x.hasOwnProperty('key'))

Ecco alcune altre opzioni per includere le proprietà ereditate:

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

if (x.key !== undefined)

Non farlo object.hasOwnProperty(key)), è davvero male perché questi metodi possono essere ombreggiati dalle proprietà sull'oggetto in questione - considera { hasOwnProperty: false }- oppure, l'oggetto potrebbe essere un oggetto null (Object.create(null)).

Il modo migliore è fare Object.prototype.hasOwnProperty.call(object, key)o:

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));

Un altro modo relativamente semplice sta usando Object.keys. Questo restituisce un arrayche significa che ottieni tutte le funzionalità di un array.

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

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

Anche se siamo in un mondo con un ottimo supporto per i browser. Poiché questa domanda è così vecchia, ho pensato di aggiungere questo: è sicuro da usare a partire da JS v1.8.5

hasOwnProperty "può essere utilizzato per determinare se un oggetto ha la proprietà specificata come proprietà diretta di quell'oggetto; a differenza dell'operatore in , questo metodo non controlla la catena di prototipi dell'oggetto."

Quindi molto probabilmente, per quello che sembra dalla tua domanda, non vuoi usare hasOwnProperty, che determina se la proprietà esiste come collegata direttamente all'oggetto stesso .

Se si desidera determinare se la proprietà esiste nella catena di prototipi in cui si desidera utilizzare, ad esempio:

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

Spero che questo possa essere d'aiuto.

Con il rischio di un downvoting massiccio, ecco un'altra opzione per un caso specifico. :)

Se vuoi testare un membro su un oggetto e vuoi sapere se è stato impostato su qualcosa di diverso da:

• ''
• falso
• nullo
• non definito
• 0 ...

allora puoi usare:

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

Soluzione ECMA Script 6 con riflessione. Crea wrapper come:

/**
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

Esiste il metodo "hasOwnProperty" sull'oggetto, ma non è consigliabile chiamare questo metodo direttamente perché potrebbe essere talvolta l'oggetto null o alcune proprietà sull'oggetto come: { hasOwnProperty: false }

Quindi il modo migliore sarebbe:

// 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"));

Puoi usare i seguenti approcci:

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

La differenza tra i seguenti approcci è la seguente-

1. Nel 1 ° e nel 3 ° approccio non stiamo solo cercando nell'oggetto ma anche nella sua catena prototipale. Se l'oggetto non ha la proprietà, ma la proprietà è presente nella sua catena di prototipi, sarà vera.

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

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

2. Il 2o approccio controllerà solo le sue proprietà. Ex -

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

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

3. La differenza tra 1 ° e 3 ° è se c'è una proprietà che ha un valore indefinito che il 3 ° approccio darà falso mentre il primo darà vero.

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

È necessario utilizzare il metodo object.hasOwnProperty(property). Restituisce vero se l'oggetto ha la proprietà e falso in caso contrario.

Se la chiave che stai controllando è memorizzata in una variabile , puoi controllarla in questo modo:

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

Perché complicare troppo le cose quando puoi fare:

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

Semplice e chiaro per la maggior parte dei casi ...