Jak sprawdzić, czy obiekt ma jakieś właściwości w JavaScript?

Zakładając, że deklaruję

var ad = {}; 

Jak mogę sprawdzić, czy ten obiekt będzie zawierał właściwości zdefiniowane przez użytkownika?

Możesz przeglądać właściwości obiektu w następujący sposób:

for(var prop in ad) {
    if (ad.hasOwnProperty(prop)) {
        // handle prop as required
    }
}

Ważne jest, aby użyć tej hasOwnProperty()metody, aby określić, czy obiekt ma określoną właściwość jako właściwość bezpośrednią, a nie jest dziedziczony z łańcucha prototypów obiektu.

Edytować

Z komentarzy: Możesz umieścić ten kod w funkcji i sprawić, by zwracał fałsz, gdy tylko dotrze do części, w której znajduje się komentarz

Test wydajności

Test Of Object.Keys vs For..In Podczas testowania dowolnych właściwości

Możesz użyć wbudowanej Object.keysmetody, aby uzyskać listę kluczy obiektu i przetestować jego długość.

var x = {};
// some code where value of x changes and than you want to check whether it is null or some object with values

if(Object.keys(x).length > 0){
 // Your code here if x has some properties  
}

A co z prostą funkcją?

function isEmptyObject(obj) {
  for(var prop in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, prop)) {
      return false;
    }
  }
  return true;
}

isEmptyObject({}); // true
isEmptyObject({foo:'bar'});  // false

hasOwnPropertyWywołanie metody bezpośrednio po Object.prototypeto tylko, aby dodać trochę więcej bezpieczeństwa , wyobraź sobie następujące używając normalnego obj.hasOwnProperty(...)połączenia:

isEmptyObject({hasOwnProperty:'boom'});  // false

Uwaga: _{(na przyszłość)} Powyższa metoda opiera się na for...ininstrukcji, a ta instrukcja iteruje tylko po wyliczalnych właściwościach, w obecnie najszerzej zaimplementowanym standardzie ECMAScript (3. edycja) programista nie ma możliwości tworzenia niewliczalnych właściwości .

Jednak zmieniło się to teraz wraz z ECMAScript 5th Edition i jesteśmy w stanie tworzyć niewliczalne, niezapisywalne lub nieusuwalne właściwości, więc powyższa metoda może zawieść , np .:

var obj = {};
Object.defineProperty(obj, 'test', { value: 'testVal', 
  enumerable: false,
  writable: true,
  configurable: true
});
isEmptyObject(obj); // true, wrong!!
obj.hasOwnProperty('test'); // true, the property exist!!

Rozwiązaniem tego problemu w ECMAScript 5 byłoby:

function isEmptyObject(obj) {
  return Object.getOwnPropertyNames(obj).length === 0;
}

Że Object.getOwnPropertyNamesmetoda zwraca Arrayzawierający nazwy wszystkich tych własnych właściwości obiektu, przeliczalnego czy nie , metoda ta jest realizowana obecnie przez producentów przeglądarek, to już na Chrome 5 Beta oraz najnowszy WebKit Nightly buduje.

Object.defineProperty jest również dostępny w tych przeglądarkach i najnowszych wydaniach Firefoksa 3.7 Alpha.

Dzięki jQuery możesz użyć:

$.isEmptyObject(obj); // Returns: Boolean

Od jQuery 1.4 ta metoda sprawdza zarówno właściwości samego obiektu, jak i właściwości odziedziczone po prototypach (w tym sensie, że nie używa hasOwnProperty).

Z ECMAScript 5th Edition w nowoczesnych przeglądarkach (IE9 +, FF4 +, Chrome5 +, Opera12 +, Safari5 +) możesz skorzystać z wbudowanej metody Object.keys :

var obj = { blah: 1 };
var isEmpty = !Object.keys(obj).length;

Lub zwykły stary JavaScript:

var isEmpty = function(obj) {
               for(var p in obj){
                  return false;
               }
               return true;
            };

Najnowsze przeglądarki (i node.js) obsługują Object.keys (), który zwraca tablicę ze wszystkimi kluczami w literale obiektu, więc można wykonać następujące czynności:

var ad = {}; 
Object.keys(ad).length;//this will be 0 in this case

Obsługa przeglądarek: Firefox 4, Chrome 5, Internet Explorer 9, Opera 12, Safari 5

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys

Jeśli używasz underscore.js, możesz użyć funkcji _.isEmpty :

var obj = {};
var emptyObject = _.isEmpty(obj);

Jeśli chcesz użyć lodash , możesz użyć tej somemetody.

_.some(obj) // returns true or false

Zobacz ten mały przykład jsbin

for (var hasProperties in ad) break;
if (hasProperties)
    ... // ad has properties

Jeśli musisz być bezpieczny i poszukać prototypów Object (są one dodawane przez niektóre biblioteki, a nie są tam domyślnie):

var hasProperties = false;
for (var x in ad) {
    if (ad.hasOwnProperty(x)) {
        hasProperties = true;
        break;
    }
}
if (hasProperties)
    ... // ad has properties

for(var memberName in ad)
{
  //Member Name: memberName
  //Member Value: ad[memberName]
}

Składnik oznacza właściwość członka, zmienną składową, jakkolwiek chcesz to nazwać> _>

Powyższy kod zwróci WSZYSTKO, w tym toString ... Jeśli chcesz tylko sprawdzić, czy prototyp obiektu został rozszerzony:

var dummyObj = {};  
for(var memberName in ad)
{
  if(typeof(dummyObj[memberName]) == typeof(ad[memberName])) continue; //note A
  //Member Name: memberName
  //Member Value: ad[memberName]

}

Uwaga A: Sprawdzamy, czy element członkowski obiektu zastępczego ma ten sam typ, co element członkowski obiektu testowego. Jeśli jest to rozszerzenie, typ składowy obiektu dummyobject powinien być „niezdefiniowany”

var hasAnyProps = false; for (var key in obj) { hasAnyProps = true; break; }
// as of this line hasAnyProps will show Boolean whether or not any iterable props exist

Proste, działa w każdej przeglądarce i chociaż technicznie jest to pętla dla wszystkich kluczy w obiekcie, NIE przechodzi przez nie wszystkie ... albo jest 0 i pętla nie działa, albo jest kilka i zrywa się po pierwszym jeden (ponieważ sprawdzamy tylko, czy jest JAKIEKOLWIEK ... więc po co kontynuować?)

Bardzo późna odpowiedź, ale tak można sobie z tym poradzić w przypadku prototypów.

Array.prototype.Any = function(func) {
    return this.some(func || function(x) { return x });
}

Object.prototype.IsAny = function() {
    return Object.keys(this).Any();
}

Gdy upewnisz się, że obiekt jest obiektem zdefiniowanym przez użytkownika, najłatwiejszym sposobem określenia, czy UDO jest pusty, będzie następujący kod:

isEmpty=
/*b.b Troy III p.a.e*/
function(x,p){for(p in x)return!1;return!0};

Chociaż ta metoda jest (z natury) dedukcyjna, - jest najszybsza i najszybsza z możliwych.

a={};
isEmpty(a) >> true

a.b=1
isEmpty(a) >> false 

ps:! nie używaj go na obiektach zdefiniowanych w przeglądarce.

Późna odpowiedź, ale niektóre struktury traktują obiekty jako wyliczalne. Dlatego bob.js może to zrobić w następujący sposób:

var objToTest = {};
var propertyCount = bob.collections.extend(objToTest).count();

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

Podwójny huk !! wyszukiwanie właściwości

var a = !![]; // true
var a = !!null; // false

hasOwnProperty To jest coś, czego używałem:

var myObject = {
  name: 'John',
  address: null
};
if (myObject.hasOwnProperty('address')) { // true
  // do something if it exists.
}

Jednak JavaScript zdecydował się nie chronić nazwy metody, więc można było przy niej manipulować.

var myObject = {
  hasOwnProperty: 'I will populate it myself!'
};

prop w myObject

var myObject = {
  name: 'John',
  address: null,
  developer: false
};
'developer' in myObject; // true, remember it's looking for exists, not value.

typ

if (typeof myObject.name !== 'undefined') {
  // do something
}

Jednak nie sprawdza null.

Myślę, że to najlepszy sposób.

w operatorze

var myObject = {
  name: 'John',
  address: null
};

if('name' in myObject) {
  console.log("Name exists in myObject");
}else{
  console.log("Name does not exist in myObject");
}

wynik:

Nazwa istnieje w myObject

Oto link, który prowadzi do bardziej szczegółowych informacji na temat operatora in: Określanie, czy właściwość obiektu istnieje

Funkcja ES6

/**
 * Returns true if an object is empty.
 * @param  {*} obj the object to test
 * @return {boolean} returns true if object is empty, otherwise returns false
 */
const pureObjectIsEmpty = obj => obj && obj.constructor === Object && Object.keys(obj).length === 0

Przykłady:

let obj = "this is an object with String constructor"
console.log(pureObjectIsEmpty(obj)) // empty? true

obj = {}
console.log(pureObjectIsEmpty(obj)) // empty? true

obj = []
console.log(pureObjectIsEmpty(obj)) // empty? true

obj = [{prop:"value"}]
console.log(pureObjectIsEmpty(obj)) // empty? true

obj = {prop:"value"}
console.log(pureObjectIsEmpty(obj)) // empty? false

Co powiesz na to?

var obj = {},
var isEmpty = !obj;
var hasContent = !!obj