Z Podkreśleniem.js lub (jeszcze lepiej) Lodash :

_.has(x, 'key');

, która wywołuje Object.prototype.hasOwnProperty, ale (a) jest krótsza w typie i (b) używa "bezpiecznego odniesienia do hasOwnProperty" (tzn. działa nawet jeśli hasOwnProperty jest nadpisane).

W szczególności Lodash definiuje _.has jako:

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

Użycie:

var x = {
  'key': 1
};

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

Uwaga: poniższe elementy 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ź wyprzedza obie te rzeczy, przynajmniej tak szeroko zaimplementowane(tak, to jest tak stare). Potraktuj to jako notatkę historyczną.

Pamiętaj, że undefined jest (niestety) Nie słowem zastrzeżonym w JavaScript, jeśli nie używasz trybu ścisłego. Dlatego, ktoś (ktoś inny, oczywiście) może mieć pomysł na ponowne zdefiniowanie go, złamanie kodu.

Bardziej solidną metodą jest zatem:

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

Z drugiej strony, ta metoda jest znacznie bardziej gadatliwa, a także wolniejsza. :-/

Powszechną alternatywą jest zapewnienie, że undefined jest w rzeczywistości niezdefiniowane, np. poprzez umieszczenie kodu w funkcji, która akceptuje dodatkowy parametr, zwany undefined, który nie jest przekazywany wartości. Aby upewnić się, że nie został przekazany wartość, można po prostu nazwać ją od razu, np.:

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

if (x.key !== undefined)

Armin Ronacher wydaje się, że już mnie wyprzedził, 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!');
}

Bezpieczniejszym, ale wolniejszym rozwiązaniem, jak wskazali Konrad Rudolph i Armin Ronacher byłoby:

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

Możesz użyć operatora in, aby sprawdzić, czy właściwość istnieje na obiekcie:

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

Można również w pętli przejrzeć wszystkie właściwości obiektu za pomocą pętli for - in, a następnie sprawdzić, czy dana właściwość jest określona:

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

Należy wziąć pod uwagę, czy ta właściwość obiektu jest możliwa do wyliczenia czy nie, ponieważ właściwości nieprzeliczalne nie pojawią się w pętli for-in. Ponadto, jeśli właściwość enumerable jest cieniem nieenumerable właściwości prototypu, nie pojawi się w Internet Explorer 8 i wcześniejsze.

Jeśli chcesz wyświetlić listę wszystkich właściwości instancji, niezależnie od tego, czy można je wyliczyć, czy nie, możesz użyć

Object.getOwnPropertyNames(x);

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

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

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

Jeżeli właściwość nie istnieje w obiekcie, zwróci łańcuch undefined. W przeciwnym razie zwróci odpowiednią typ nieruchomości. Należy jednak pamiętać, że nie zawsze jest to prawidłowy sposób sprawdzania, czy obiekt ma właściwość, ponieważ można mieć właściwość ustawioną na undefined, w takim przypadku użycie typeof x.key nadal zwracałoby true (nawet jeśli klucz jest nadal w obiekcie).

Update: 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 działać, chyba że klucz został specjalnie ustawiony na {[9] } w obiekcie x

Skończmy z tym zamieszaniem. Po pierwsze, uprośćmy, zakładając, że hasOwnProperty już istnieje; dotyczy to większości obecnie używanych przeglądarek.

hasOwnProperty zwraca true, jeśli do obiektu została dodana przekazywana mu nazwa atrybutu. Jest całkowicie niezależna od rzeczywistej przypisanej mu wartości, która może być dokładnie undefined.

Stąd:

var o = {}
o.x = undefined

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

Jednakże:

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 się dzieje, gdy obiekt w prototype chain ma atrybut o wartości undefined? hasOwnProperty będzie za to fałszywa, tak samo będzie !== undefined. Jednak for..in nadal będzie go wymieniać w wyliczeniu.

Najważniejsze jest to, że nie ma sposobu między przeglądarkami (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, to " nie " . Chcesz:

if ('prop' in obj) { }

Ogólnie rzecz biorąc, nie powinieneś dbać o to, czy właściwość pochodzi z prototypu czy z obiektu.

Jednakże, ponieważ użyłeś 'key' w swoim przykładowym kodzie, wygląda na to, że traktujesz obiekt jako hash, w którym to przypadku Twoja odpowiedź miałaby sens. Wszystkie klucze hashujące byłyby właściwościami w obiekcie, a Ty unikasz dodatkowych właściwości wnoszonych przez prototyp.

John Odpowiedź resiga była bardzo wyczerpująca, ale myślałem, że nie jest jasna. Zwłaszcza, kiedy używać "'prop' w obj".

Do testowania prostych obiektów użyj:

if (obj[x] !== undefined)

Jeśli nie wiesz jaki to obiekt, użyj:

if (obj.hasOwnProperty(x))

Wszystkie inne opcje są wolniejsze...

Szczegóły

Ocena wydajności 100 000 000 cykli pod węzłem.js do pięciu 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 dokładnie sprawdzić łańcucha prototypów obiektu, jak również samego obiektu, nie powinniśmy używać wspólnego forma :

if (X in Obj)...

Jest od 2 do 6 razy wolniejszy w zależności od przypadku użycia

hasKey1 execution time: 4.51 s
hasKey2 execution time: 0.90 s
hasKey3 execution time: 0.76 s
hasKey4 execution time: 0.93 s
hasKey5 execution time: 2.15 s

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

W Przeciwnym Razie, używając prostego obiektu i nie martwiąc się o łańcuch prototypów obiektu, użycie if (typeof(obj[x]) !== 'undefined')... jest najbezpieczniejszym i najszybszym sposobem.

Jeśli używasz prostego obiektu jako tabeli hash i nigdy nie rób nic perwersyjnego, użyłbym if (obj[x])..., ponieważ uważam, że jest o wiele bardziej czytelny.

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

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

Możesz również użyć obiektu ES6 Reflect :

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

Dokumentację MDN dla Reflect.has można znaleźć proszę..

Metoda statyczna Reflect.has() działa jakw operatorze jako funkcja.

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

}

Ponieważ

if (x.key)

Nie powiedzie się, jeśli x.key zmieni się na false (na przykład, x.key = "").

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

Najlepszy sposób to zrobić 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));

OK, wygląda na to, że miałem prawidłową odpowiedź, chyba, że nie chcesz dziedziczyć właściwości:

if (x.hasOwnProperty('key'))

Oto kilka innych opcji, aby uwzględnić dziedziczone właściwości:

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

if (x.key !== undefined)

Innym stosunkowo prostym sposobem jest użycie Object.keys. Zwraca array, co oznacza, że otrzymujesz 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 wielką obsługą przeglądarki. Ponieważ to pytanie jest tak stare, pomyślałem, że dodam to: Jest to bezpieczne w użyciu od JavaScript v1.8.5.

HasOwnProperty " może być użyty do określenia, czy obiekt ma określoną właściwość jako bezpośrednią właściwość tego obiektu; w przeciwieństwie do operatora in, Metoda ta nie sprawdza łańcucha prototypów obiektu."

Więc najprawdopodobniej, na co wygląda twoje pytanie, nie chcesz używać hasOwnProperty, który określa, czy właściwość istnieje jako dołączona bezpośrednio do samego obiektu ,.

Jeśli chcesz ustalić, czy właściwość istnieje w prototype chain, możesz użyć go w następujący sposób:

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

Możesz użyć następujących podejść -

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

Różnica między następującymi podejściami jest następująca-

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

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

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

1. drugie podejście sprawdza tylko własne właściwości. Przykład -

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

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

1. różnica między pierwszą a trzecią jest taka, że jeśli istnieje właściwość, która ma wartość niezdefiniowaną, trzecie podejście da false, podczas gdy pierwsze da true.

var obj = {
    b : undefined
}

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

Oto inna opcja dla konkretnego przypadku. :)

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

• ''
• false
• null
• undefined
• 0 ...

Wtedy możesz użyć:

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

JavaScript jest teraz ewoluuje i rośnie ma teraz dobry i najlepszy nawet skuteczny sposób, aby to sprawdzić

Oto kilka prostych sposobów na sprawdzenie, czy obiekt ma określoną właściwość :

1. za pomocą hasOwnProperty()

const hero = {
  name: 'Batman'
};

hero.hasOwnProperty('name');     // => true
hero.hasOwnProperty('realName'); // => false

1. użycie słowa kluczowego/operatora in

const hero = {
  name: 'Batman'
};

'name' in hero;     // => true
'realName' in hero; // => false

1. porównując ze słowem kluczowym undefined

const hero = {
  name: 'Batman'
};

hero.name;     // => 'Batman'
hero.realName; // => undefined

// So consider this
hero.realName == undefined // => true (which means property does not exists in object)
hero.name == undefined // => false (which means that property exists in object)

Aby uzyskać więcej informacji, sprawdź tutaj .

Istnieje metoda "hasOwnProperty", która istnieje na obiekcie, ale nie zaleca się bezpośredniego wywoływania tej metody, ponieważ czasami może być tak, że obiekt ma wartość null lub istnieje jakaś właściwość na obiekcie, taka jak: { hasOwnProperty: false }

Więc 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"));

Rozwiązanie ECMAScript 6 z odbiciem. Tworzenie wrappera w stylu:

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

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

Wydajność

Dzisiaj 2020.12.17 wykonuję testy na MacOs HighSierra 10.13.6 na Chrome v87, Safari v13. 1. 2 i Firefox v83 dla wybranych rozwiązań.

Wyniki

Porównuję tylko rozwiązania A-F, ponieważ dają one poprawny wynik dla wszystkich obudów użytych w sekcji snippet in details. Dla wszystkich przeglądarek

• rozwiązanie oparte na in (A) jest szybkie lub najszybsze
• rozwiązanie (E) jest najszybsze dla chrome dla dużych obiektów i najszybsze dla Firefoksa dla małych tablic, jeśli Klawisz nie exists
• rozwiązanie (F) jest najszybsze (~ >10x niż inne rozwiązania) dla małych tablic
• rozwiązania (D,E) są dość szybkie
• rozwiązanie oparte na losash has (B) jest najwolniejsze

Szczegóły

Wykonuję 4 przypadki testów:

• gdy obiekt ma 10 pól i istnieje wyszukiwany klucz - możesz go uruchomić tutaj
• gdy obiekt ma 10 pól i wyszukiwany klucz nie istnieje - można go uruchomić tutaj
• gdy obiekt ma 10000 pól i istnieje wyszukiwany klucz - możesz go uruchomić tutaj
• gdy obiekt ma 10000 pól i istnieje wyszukiwany klucz - możesz go uruchomić tutaj

Poniżej prezentujemy różnice między rozwiązaniami A B C D E F G H I J K

// SO https://stackoverflow.com/q/135448/860099


// src: https://stackoverflow.com/a/14664748/860099
function A(x) {
  return 'key' in x
}

// src: https://stackoverflow.com/a/11315692/860099
function B(x) {
  return _.has(x, 'key')
}

// src: https://stackoverflow.com/a/40266120/860099
function C(x) {
  return Reflect.has( x, 'key')
}

// src: https://stackoverflow.com/q/135448/860099
function D(x) {
  return x.hasOwnProperty('key')
}

// src: https://stackoverflow.com/a/11315692/860099
function E(x) {
  return Object.prototype.hasOwnProperty.call(x, 'key')
}

// src: https://stackoverflow.com/a/136411/860099
function F(x) {
  function hasOwnProperty(obj, prop) {
      var proto = obj.__proto__ || obj.constructor.prototype;
      return (prop in obj) &&
          (!(prop in proto) || proto[prop] !== obj[prop]);
  }
  return hasOwnProperty(x,'key')
}

// src: https://stackoverflow.com/a/135568/860099
function G(x) {
  return typeof(x.key) !== 'undefined'
}

// src: https://stackoverflow.com/a/22740939/860099
function H(x) {
  return x.key !== undefined
}

// src: https://stackoverflow.com/a/38332171/860099
function I(x) {
  return !!x.key
}

// src: https://stackoverflow.com/a/41184688/860099
function J(x) {
  return !!x['key']
}

// src: https://stackoverflow.com/a/54196605/860099
function K(x) {
  return Boolean(x.key)
}


// --------------------
// TEST
// --------------------

let x1 = {'key': 1};
let x2 = {'key': "1"};
let x3 = {'key': true};
let x4 = {'key': []};
let x5 = {'key': {}};
let x6 = {'key': ()=>{}};
let x7 = {'key': ''};
let x8 = {'key': 0};
let x9 = {'key': false};
let x10= {'key': undefined};
let x11= {'nokey': 1};



let b= x=> x ? 1:0;

console.log('  1 2 3 4 5 6 7 8 9 10 11');

[A,B,C,D,E,F,G,H,I,J,K ].map(f=> {  
  console.log(
    `${f.name} ${b(f(x1))} ${b(f(x2))} ${b(f(x3))} ${b(f(x4))} ${b(f(x5))} ${b(f(x6))} ${b(f(x7))} ${b(f(x8))} ${b(f(x9))} ${b(f(x10))}  ${b(f(x11))} `
  )})
  
console.log('\nLegend: Columns (cases)');
console.log('1.  key = 1 ');
console.log('2.  key = "1" ');
console.log('3.  key = true ');
console.log('4.  key = [] ');
console.log('5.  key = {} ');
console.log('6.  key = ()=>{} ');
console.log('7.  key = "" ');
console.log('8.  key = 0 ');
console.log('9.  key = false ');
console.log('10. key = undefined ');
console.log('11. no-key ');

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.20/lodash.min.js" integrity="sha512-90vH1Z83AJY9DmlWa8WkjkV79yfS2n2Oxhsi2dZbIv0nC4E6m5AbH8Nh156kkM7JePmqD6tcZsfad1ueoaovww==" crossorigin="anonymous"> </script>
  
This shippet only presents functions used in performance tests - it not perform tests itself!

I tutaj są przykładowymi wynikami dla chrome

Nie komplikuj zbytnio rzeczy, kiedy możesz to zrobić:

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

Lepsze podejście do iteracji własnych właściwości obiektu:

Jeśli chcesz iterować właściwości obiektu bez użycia hasOwnProperty() Sprawdź, Metoda for(let key of Object.keys(stud)){}:

for(let key of Object.keys(stud)){
  console.log(key); // will only log object's Own properties
}

Pełny przykład i porównanie z for-in with hasOwnProperty()

function Student() {
  this.name = "nitin";
}

Student.prototype = {
  grade: 'A'
}

let stud = new Student();

// for-in approach
for(let key in stud){
  if(stud.hasOwnProperty(key)){
    console.log(key); // only outputs "name"
  }
} 

//Object.keys() approach
for(let key of Object.keys(stud)){
  console.log(key);
}

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

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