Jak sprawdzić, czy obiekt ma określoną właściwość w JavaScript?

Jak sprawdzić, czy obiekt ma określoną właściwość w JavaScript?

Rozważać:

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

Czy to najlepszy sposób, aby to zrobić?

Naprawdę jestem zdezorientowany otrzymanymi odpowiedziami - większość z nich jest po prostu błędna. Oczywiście możesz mieć właściwości obiektu, które mają niezdefiniowane, zerowe lub fałszywe wartości. Po prostu zmniejszenie kontroli własności do typeof this[property], a nawet gorzej, x.keyda całkowicie mylące wyniki.

To zależy od tego, czego szukasz. Jeśli chcesz wiedzieć, czy obiekt fizycznie zawiera właściwość (i nie pochodzi ona skądś z łańcucha prototypów), to object.hasOwnPropertyjest to właściwa droga. Wszystkie nowoczesne przeglądarki obsługują to. (Brakowało go w starszych wersjach Safari - 2.0.1 i starszych - ale te wersje przeglądarki są już rzadko używane).

Jeśli szukasz tego, czy obiekt ma właściwość iterowalną (pojawi się iteracja po właściwościach obiektu), wówczas wykonanie: prop in objectda pożądany efekt.

Ponieważ używanie hasOwnPropertyjest prawdopodobnie tym, czego chcesz, a biorąc pod uwagę, że możesz chcieć metody rezerwowej, przedstawiam ci następujące rozwiązanie:

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

Powyższe jest działającym rozwiązaniem dla różnych przeglądarek hasOwnPropertyz jednym zastrzeżeniem: nie jest w stanie rozróżnić przypadków, w których identyczna właściwość znajduje się w prototypie i instancji - po prostu zakłada, że ​​pochodzi ona z prototypu. Możesz zmienić to na łagodniejsze lub bardziej surowe, w zależności od twojej sytuacji, ale przynajmniej powinno to być bardziej pomocne.

Z Underscore.jslub ( jeszcze lepiej ) lodash:

_.has(x, 'key');

Które wywołania Object.prototype.hasOwnProperty, ale (a) jest krótszy do wpisania, a (b) używa „bezpiecznego odniesienia do hasOwnProperty” (tzn. Działa, nawet jeśli hasOwnPropertyzostanie zastąpione).

W szczególności lodash definiuje się _.hasjako:

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

Co powiesz na?

var x = {'key': 1};

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

Uwaga : poniższe opcje są obecnie w dużej mierze przestarzałe dzięki trybowi ścisłemu i hasOwnProperty. Poprawnym rozwiązaniem jest użycie trybu ścisłego i sprawdzenie obecności właściwości za pomocą obj.hasOwnProperty. Ta odpowiedź poprzedza obie te rzeczy, przynajmniej jako szeroko zaimplementowane (tak, to jest tak stare). Weź pod uwagę następujące uwagi historyczne.

Należy pamiętać, że undefinedjest (niestety) nie słowem zarezerwowanym w JavaScript, jeśli nie jesteś w trybie ścisłym. Dlatego ktoś (oczywiście ktoś inny) może mieć świetny pomysł na redefiniowanie go, złamanie kodu.

Bardziej niezawodna metoda jest zatem następująca:

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

Z drugiej strony ta metoda jest bardziej szczegółowa, a także wolniejsza. : - /

Częstą alternatywą jest upewnienie się, że undefinedjest faktycznie niezdefiniowana, np. Poprzez wstawienie kodu do funkcji, która akceptuje dodatkowy parametr, zwany undefined, który nie przekazuje wartości. Aby upewnić się, że nie przekroczyła wartości, możesz po prostu nazwać ją od razu, np .:

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

if (x.key !== undefined)

Wydaje się, że Armin Ronacher już mnie pobił , ale:

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

Bezpieczniejsze, ale wolniejsze rozwiązanie, jak wskazano przez Konrad Rudolph i Armin Ronacher będzie:

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

Za pomocą inoperatora można sprawdzić, czy właściwość istnieje na obiekcie:

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

Możesz również wykonać pętlę przez wszystkie właściwości obiektu za pomocą for - inpętli, a następnie sprawdzić określoną właściwość:

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

Należy rozważyć, czy ta właściwość obiektu jest policzalna, czy nie, ponieważ właściwości niepoliczalne nie pojawią się w for-inpętli. Ponadto, jeśli właściwość wyliczalna przesłania właściwość prototypu, której nie można wyliczyć, nie pojawi się w programie Internet Explorer 8 i wcześniejszych wersjach.

Jeśli chcesz wyświetlić listę wszystkich właściwości instancji, niezależnie od tego, czy są one wyliczalne, czy nie, możesz użyć

Object.getOwnPropertyNames(x);

Zwróci tablicę nazw wszystkich właściwości istniejących na obiekcie.

Na koniec możesz użyć operatora typeof, aby bezpośrednio sprawdzić typ danych właściwości obiektu:

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

Jeśli właściwość nie istnieje na obiekcie, zwróci ciąg niezdefiniowany. W przeciwnym razie zwróci odpowiedni typ właściwości. Należy jednak pamiętać, że nie zawsze jest to prawidłowy sposób sprawdzania, czy obiekt ma właściwość, czy nie, ponieważ można mieć właściwość ustawioną na wartość niezdefiniowaną, w którym to przypadku użycie typeof x.keynadal zwróciłoby wartość true (nawet jeśli klucz jest nadal w obiekcie).

Aktualizacja: możesz sprawdzić, czy właściwość istnieje, porównując ją z niezdefiniowaną właściwością javascript

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

Powinno to działać, chyba że klucz został specjalnie ustawiony undefinedna obiekcie x

Przejdźmy przez to zamieszanie. Po pierwsze, uprośćmy, zakładając, że hasOwnPropertyjuż istnieje; dotyczy to zdecydowanej większości obecnie używanych przeglądarek.

hasOwnPropertyzwraca true, jeśli przekazana do niego nazwa atrybutu została dodana do obiektu. Jest całkowicie niezależny od faktycznie przypisanej wartości, która może być dokładnie undefined.

W związku z tym:

var o = {}
o.x = undefined

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

Jednak:

var o = {}

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

Problem polega na tym, co dzieje się, gdy obiekt w łańcuchu prototypów ma atrybut o wartości niezdefiniowanej? hasOwnPropertybędzie dla niego fałszywa i tak też będzie !== undefined. Jednak for..innadal będzie to wymieniać w wyliczeniu.

Najważniejsze jest to, że nie ma sposobu na przeglądarkę (ponieważ Internet Explorer nie ujawnia __prototype__), aby ustalić, że określony identyfikator nie został dołączony do obiektu lub czegokolwiek w jego łańcuchu prototypów.

Jeśli szukasz nieruchomości, wybierz „NIE”. Chcesz:

if ('prop' in obj) { }

Zasadniczo nie należy się przejmować, czy właściwość pochodzi od prototypu czy obiektu.

Ponieważ jednak użyłeś „klucza” w przykładowym kodzie, wygląda na to, że traktujesz obiekt jako skrót, w którym to przypadku Twoja odpowiedź miałaby sens. Wszystkie klucze skrótu byłyby właściwościami w obiekcie, a unikasz dodatkowych właściwości prototypu.

Odpowiedź Johna Resiga była bardzo wyczerpująca, ale myślałem, że nie była jasna. Zwłaszcza kiedy należy użyć „prop” w obj.

Do testowania prostych obiektów użyj: if (obj[x] !== undefined)

Jeśli nie wiesz, jaki typ obiektu jest używany, użyj: if (obj.hasOwnProperty(x))

Wszystkie inne opcje są wolniejsze ..

Detale

Ocena wydajności 100 000 000 cykli w ramach Nodejsa do 5 opcji sugerowanych przez innych tutaj:

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

Ocena mówi nam, że jeśli nie chcemy konkretnie sprawdzić łańcucha prototypowego obiektu, a także samego obiektu, nie powinniśmy używać wspólnej formy: if (X in Obj)... jest on od 2 do 6 razy wolniejszy w zależności od przypadku użycia

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

Podsumowując, jeśli Twój Obj niekoniecznie jest prostym obiektem i chcesz uniknąć sprawdzania łańcucha prototypowego obiektu i upewnić się, że x jest własnością Obj bezpośrednio, użyj „if (obj.hasOwnProperty (x)) ...”.

W przeciwnym razie, gdy używasz prostego obiektu i nie martwisz się łańcuchem prototypowym obiektu, używanie if (typeof(obj[x]) !== 'undefined')...jest najbezpieczniejszym i najszybszym sposobem.

Jeśli użyjesz prostego obiektu jako tabeli mieszającej i nigdy nie zrobisz nic dziwnego, użyłbym tego, if (obj[x])...ponieważ uważam, że jest on dużo bardziej czytelny.

Baw się dobrze.

Tak to jest :) Myślę, że możesz też zrobić, Object.prototype.hasOwnProperty.call(x, 'key')co powinno również działać, jeśli xma właściwość o nazwie hasOwnProperty:)

Ale to sprawdza własne właściwości. Jeśli chcesz sprawdzić, czy ma właściwość, która może być powiązana, możesz użyć typeof x.foo != 'undefined'.

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

}

Ponieważ

if (x.key)

kończy się niepowodzeniem, jeśli x.keyrozwiązuje false(na przykład x.key = "").

Możesz także użyć obiektu ES6Reflect :

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

Dokumentację dotyczącą MDN dla Reflect.hasmożna znaleźć tutaj .

Metoda statyczna Reflect.has()działa jak operator in jako funkcja.

OK, wygląda na to, że mam właściwą odpowiedź, chyba że nie chcesz dziedziczonych właściwości:

if (x.hasOwnProperty('key'))

Oto kilka innych opcji dołączania odziedziczonych właściwości:

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

if (x.key !== undefined)

Nie rób tego object.hasOwnProperty(key)), to naprawdę złe, ponieważ metody te mogą być zaciemnione przez właściwości obiektu, o którym mowa - rozważ { hasOwnProperty: false }- lub obiekt może być obiektem zerowym (Object.create(null)).

Najlepszym sposobem jest zrobienie Object.prototype.hasOwnProperty.call(object, key)lub:

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

Innym stosunkowo prostym sposobem jest użycie Object.keys. Zwraca to, arrayco oznacza, że ​​masz wszystkie funkcje tablicy.

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

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

Chociaż jesteśmy w świecie z doskonałą obsługą przeglądarki. Ponieważ to pytanie jest tak stare, pomyślałem, że dodam to: Można go bezpiecznie używać od wersji JS 1.8.5

hasOwnProperty "można wykorzystać do ustalenia, czy obiekt ma określoną właściwość jako bezpośrednią właściwość tego obiektu; w przeciwieństwie do operatora in , ta metoda nie sprawdza łańcucha prototypów obiektu."

Więc najprawdopodobniej za to, co wydaje się przez swoje pytanie, nie chcesz używać hasOwnProperty, który określa, czy właściwość istnieje jako przyłączone bezpośrednio do samego obiektu ,.

Jeśli chcesz ustalić, czy właściwość istnieje w łańcuchu prototypów, w którym chcesz używać, na przykład:

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

Mam nadzieję, że to pomoże.

Z ryzykiem masowego głosowania w dół, jest inna opcja dla konkretnego przypadku. :)

Jeśli chcesz przetestować członka na obiekcie i chcesz wiedzieć, czy został ustawiony na coś innego niż:

• ''
• fałszywe
• zero
• nieokreślony
• 0 ...

wtedy możesz użyć:

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

Rozwiązanie ECMA Script 6 z odbiciem. Utwórz opakowanie takie jak:

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

Istnieje metoda „hasOwnProperty” istnieje na obiekcie, ale nie zaleca się bezpośredniego wywoływania tej metody, ponieważ czasami obiekt może mieć wartość NULL lub niektóre właściwości istnieją na obiekcie, takie jak: { hasOwnProperty: false }

Lepszym sposobem byłoby:

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

Możesz użyć następujących metod:

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

Różnice między następującymi podejściami są następujące:

1. W podejściu pierwszym i trzecim nie tylko szukamy obiektu, ale także jego łańcucha prototypowego. Jeśli obiekt nie ma właściwości, ale właściwość jest obecna w łańcuchu prototypów, da wartość true.

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

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

2. Drugie podejście sprawdzi tylko swoje właściwości. Ex -

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

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

3. Różnica między pierwszym a trzecim polega na tym, że jeśli istnieje właściwość, której wartość jest niezdefiniowana, trzecie podejście da wartość false, a pierwsze da wartość true.

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

Musisz użyć tej metody object.hasOwnProperty(property). Zwraca true, jeśli obiekt ma właściwość, i false, jeśli obiekt nie.

Jeśli sprawdzany klucz jest przechowywany w zmiennej , możesz to sprawdzić w następujący sposób:

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

Po co nadmiernie komplikować rzeczy, kiedy możesz to zrobić:

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

Prosty i przejrzysty w większości przypadków ...