Domanda Verificare se esiste una chiave in un oggetto JavaScript?


Come posso verificare se esiste una particolare chiave in un oggetto o array JavaScript?

Se una chiave non esiste e cerco di accedervi, restituirà false? O lanciare un errore?


2220
2017-07-08 13:21


origine


risposte:


Il controllo di undefined-ness non è un modo accurato per verificare se esiste una chiave. Cosa succede se la chiave esiste ma il valore è in realtà undefined?

var obj = { key: undefined };
obj["key"] != undefined // false, but the key exists!

Dovresti invece usare il in operatore:

"key" in obj // true, regardless of the actual value

Se vuoi verificare se una chiave non esiste, ricorda di usare la parentesi:

!("key" in obj) // true if "key" doesn't exist in object
!"key" in obj   // ERROR!  Equivalent to "false in obj"

Oppure, se si desidera testare in particolare le proprietà dell'istanza dell'oggetto (e non le proprietà ereditate), utilizzare hasOwnProperty:

obj.hasOwnProperty("key") // true

Per il confronto delle prestazioni tra i metodi che sono in, hasOwnProperty e la chiave è undefined, guarda questo segno di riferimento


3072
2017-07-08 15:51



risposta rapida

Come posso verificare se esiste una particolare chiave in un oggetto o array JavaScript?   Se una chiave non esiste e provo ad accedervi, restituirà false? O lanciare un errore?

Accedendo direttamente a una proprietà mancante usando lo stile di matrice (associativo) o lo stile dell'oggetto restituirà un non definito costante.

Il lento e affidabile in operatore e hasOwnProperty metodo

Come le persone hanno già menzionato qui, potresti avere un oggetto con una proprietà associata a una costante "non definita".

 var bizzareObj = {valid_key:  undefined};

In tal caso, dovrai usare hasOwnProperty o in operatore per sapere se la chiave è davvero lì. Ma, ma a quale prezzo?

quindi, ti dico ...

in operatore e hasOwnProperty sono "metodi" che usano il meccanismo del descrittore di proprietà in Javascript (simile alla riflessione di Java nel linguaggio Java).

http://www.ecma-international.org/ecma-262/5.1/#sec-8.10

Il tipo Descrittore proprietà viene utilizzato per spiegare la manipolazione e la reificazione degli attributi delle proprietà denominate. I valori del tipo Descrittore proprietà sono record composti da campi denominati in cui il nome di ciascun campo è un nome di attributo e il suo valore è un valore dell'attributo corrispondente specificato in 8.6.1. Inoltre, qualsiasi campo può essere presente o assente.

D'altra parte, chiamare un metodo o una chiave oggetto utilizzerà il meccanismo Javascript [[Ottieni]]. Questo è molto più veloce!

segno di riferimento

http://jsperf.com/checking-if-a-key-exists-in-a-javascript-array

Comparing key access in JS.

utilizzando in operatore
var result = "Impression" in array;

Il risultato è stato

12,931,832 ±0.21% ops/sec      92% slower 
Utilizzando hasOwnProperty
var result = array.hasOwnProperty("Impression")

Il risultato è stato

16,021,758 ±0.45% ops/sec     91% slower
Accedere direttamente agli elementi (stile parentesi)
var result = array["Impression"] === undefined

Il risultato è stato

168,270,439 ±0.13 ops/sec     0.02% slower 
Accedere direttamente agli elementi (stile oggetto)
var result = array.Impression  === undefined;

Il risultato è stato

168,303,172 ±0.20%     fastest

EDIT: Qual è la ragione per assegnare a una proprietà il undefined valore?

Questa domanda mi lascia perplesso. In Javascript, ci sono almeno due riferimenti per gli oggetti assenti per evitare problemi come questo: null e undefined.

null è il valore primitivo che rappresenta l'assenza intenzionale di qualsiasi valore dell'oggetto o, in breve, il confermato mancanza di valore. D'altra parte, undefined è un valore sconosciuto (non definito). Se c'è una proprietà che verrà utilizzata in seguito con a corretto il valore considera l'uso null riferimento invece di undefined perché nel momento iniziale la proprietà è confermato mancare un valore.

Confrontare:

var a = {1: null}; 
console.log(a[1] === undefined); // output: false. I know the value at position 1 of a[] is absent and this was by design, i.e.:  the value is defined. 
console.log(a[0] === undefined); // output: true. I cannot say anything about a[0] value. In this case, the key 0 was not in a[].

Consigliare

Evita oggetti con undefined valori. Controlla direttamente quando possibile e usa null per inizializzare i valori delle proprietà. Altrimenti, usa il lento in operatore o hasOwnProperty() metodo.

EDIT: 12/04/2018 - NON PERTINENTE IN ALMENO

Come hanno commentato le persone, le versioni moderne dei motori Javascript (con l'eccezione firefox) hanno cambiato l'approccio per le proprietà di accesso. L'implementazione attuale è più lenta di quella precedente per questo caso particolare, ma la differenza tra chiave di accesso e oggetto è trascurabile.


223
2018-02-27 16:38



Ritornerà undefined.

var aa = {hello: "world"};
alert( aa["hello"] );      // popup box with "world"
alert( aa["goodbye"] );    // popup box with "undefined"

undefined è un valore costante speciale. Quindi puoi dire, ad es.

// note the three equal signs so that null won't be equal to undefined
if( aa["goodbye"] === undefined ) {
    // do something
}

Questo è probabilmente il modo migliore per verificare la presenza di chiavi mancanti. Tuttavia, come è indicato in un commento qui sotto, è teoricamente possibile che tu voglia avere il valore reale undefined. Non ho mai avuto bisogno di farlo e non riesco a pensare a un motivo in modo inequivocabile perché lo vorrei mai, ma solo per ragioni di completezza, puoi usare il in operatore

// this works even if you have {"goodbye": undefined}
if( "goodbye" in aa ) {
    // do something
}

113
2017-07-08 13:24



Il risposta accettata si riferisce a Oggetto. Stai attento a usare il in operatore sopra schieramento per trovare dati invece di chiavi:

("true" in ["true", "false"])
// -> false (Because the keys of the above Array are actually 0 and 1)

Per verificare elementi esistenti in una matrice: Il modo migliore per trovare se un elemento si trova in un array JavaScript?


21
2017-07-01 12:45



"key" in obj

È probabile che test solo i valori degli attributi degli oggetti che sono molto diversi dalle chiavi dell'array


19
2018-04-25 15:45



Tre modi per verificare se una proprietà è presente in un oggetto javascript:

  1. !! obj.theProperty
    Converte valore in bool. restituisce VERO per tutti tranne il valore 'falso'
  2. 'theProperty' in obj
    Restituisce true se la proprietà esiste, indipendentemente dal suo valore (anche vuoto)
  3. obj.hasOwnProperty ( 'theProperty')
    Non controlla la catena del prototipo. (poiché tutti gli oggetti hanno il metodo 'toString', 1 e 2 restituiranno true su di esso, mentre 3 può restituire false su di esso.)

Riferimento:

http://book.mixu.net/node/ch5.html


19
2017-11-12 09:19



Se stai usando underscore.js la libreria quindi le operazioni su oggetti / array diventano semplici.

Nel tuo caso può essere usato il metodo _.has. Esempio:

yourArray = {age: "10"}

_.has(yourArray, "age")

ritorna vero 

Ma,

_.has(yourArray, "invalidKey")

ritorna falso


12
2018-05-29 19:37