wake-up-neo.com

Prüfen Sie, ob ein Wert in JavaScript ein Objekt ist

Wie prüfen Sie, ob ein Wert in JavaScript ein Objekt ist?

984
Danny Fox

Versuchen Sie es mit typeof(var) und/oder var instanceof something.

BEARBEITEN: Diese Antwort gibt eine Vorstellung davon, wie die Eigenschaften der Variablen untersucht werden können, aber es ist nicht ein kugelsicheres Rezept (immerhin gibt es überhaupt kein Rezept!), Um zu prüfen, ob es ein Objekt ist, weit davon entfernt. Da die Leute dazu neigen, von hier aus nach etwas zu suchen, das nicht kopiert werden muss, ohne Nachforschungen anzustellen, würde ich dringend empfehlen, dass sie sich an die andere, höchst positive (und korrekte!) Antwort wenden.

Bei typeof yourVariable === 'object' handelt es sich um ein Objekt oder eine Null. Wenn Sie Null ausschließen möchten, machen Sie es einfach zu typeof yourVariable === 'object' && yourVariable !== null.

1190
Chuck

Definieren wir "Objekt" in Javascript . Gemäß MDN docs ist jeder Wert entweder ein Objekt oder ein Grundelement:

primitiver, primitiver Wert

Daten, die kein Objekt sind und keine Methoden haben. JavaScript hat 5 primitive Datentypen: String, Number, Boolean, Null, undefined.

Was ist ein Primitiv?

  • 3
  • 'abc'
  • true
  • null
  • undefined

Was ist ein Objekt (d. H. Kein Primitiv)?

  • Object.prototype
  • alles abstammend von Object.prototype
    • Function.prototype
      • Object
      • Function
      • function C(){} - benutzerdefinierte Funktionen
    • C.prototype - die Prototyp-Eigenschaft einer benutzerdefinierten Funktion: Dies ist notCs Prototyp
      • new C() - "new" - eine benutzerdefinierte Funktion
    • Math
    • Array.prototype
      • arrays
    • {"a": 1, "b": 2} - Objekte, die in Literalnotation erstellt wurden
    • new Number(3) - Wrapper um Primitive
    • ... viele andere Dinge ...
  • Object.create(null)
  • alles stammte von einer Object.create(null)

So prüfen Sie, ob ein Wert ein Objekt ist

instanceof alleine funktioniert nicht, da zwei Fälle fehlen:

// oops:  isObject(Object.prototype) -> false
// oops:  isObject(Object.create(null)) -> false
function isObject(val) {
    return val instanceof Object; 
}

typeof x === 'object' Funktioniert nicht, da falsch positive (null) und falsch negative (Funktionen):

// oops: isObject(Object) -> false
function isObject(val) {
    return (typeof val === 'object');
}

Object.prototype.toString.call Funktioniert nicht, da alle Primitive falsch positiv sind:

> Object.prototype.toString.call(3)
"[object Number]"

> Object.prototype.toString.call(new Number(3))
"[object Number]"

Also benutze ich:

function isObject(val) {
    if (val === null) { return false;}
    return ( (typeof val === 'function') || (typeof val === 'object') );
}

@ Daans Antwort scheint auch zu funktionieren:

function isObject(obj) {
  return obj === Object(obj);
}

weil laut MDN docs :

Der Object-Konstruktor erstellt einen Objektwrapper für den angegebenen Wert. Wenn der Wert null oder undefiniert ist, wird ein leeres Objekt erstellt und zurückgegeben. Andernfalls wird ein Objekt eines Typs zurückgegeben, der dem angegebenen Wert entspricht. Wenn der Wert bereits ein Objekt ist, wird der Wert zurückgegeben.


Ein dritter Weg, der zu funktionieren scheint (nicht sicher, ob er 100% ist), ist die Verwendung von Object.getPrototypeOf, Das löst eine Ausnahme aus wenn sein Argument kein Objekt ist:

// these 5 examples throw exceptions
Object.getPrototypeOf(null)
Object.getPrototypeOf(undefined)
Object.getPrototypeOf(3)
Object.getPrototypeOf('abc')
Object.getPrototypeOf(true)

// these 5 examples don't throw exceptions
Object.getPrototypeOf(Object)
Object.getPrototypeOf(Object.prototype)
Object.getPrototypeOf(Object.create(null))
Object.getPrototypeOf([])
Object.getPrototypeOf({})
502
Matt Fenwick

Die offizielle underscore.js verwendet diese Prüfung, um herauszufinden, ob etwas wirklich ein Objekt ist

// Is a given variable an object?
_.isObject = function(obj) {
  return obj === Object(obj);
};

UPDATE

Die Bibliothek aktualisiert underscore.js verwendet jetzt die folgenden, aufgrund eines früheren Fehlers in V8 und einer kleineren Optimierung der Mikrogeschwindigkeit. 

// Is a given variable an object?
_.isObject = function(obj) {
  return typeof obj === 'function' || (typeof obj === 'object' && !!obj);
};
211
Daan

Object.prototype.toString.call(myVar) wird zurückkehren:

  • "[object Object]" wenn myVar ein Objekt ist
  • "[object Array]" wenn myVar ein Array ist
  • usw.

Weitere Informationen dazu und warum es eine gute Alternative zu typeof ist, lesen Sie diesen Artikel aus .

158
Christophe

Zum einfachen Prüfen auf Object oder Array ohne zusätzlichen Funktionsaufruf (Geschwindigkeit). Wie auch bekannt gegeben hier .

isArray ()

isArray = function(a) {
    return (!!a) && (a.constructor === Array);
};
console.log(isArray(        )); // false
console.log(isArray(    null)); // false
console.log(isArray(    true)); // false
console.log(isArray(       1)); // false
console.log(isArray(   'str')); // false
console.log(isArray(      {})); // false
console.log(isArray(new Date)); // false
console.log(isArray(      [])); // true

isObject () - Hinweis: Nur für Objektliterale verwenden, da bei benutzerdefinierten Objekten (z. B. neues Datum oder neues YourCustomObject) false zurückgegeben wird.

isObject = function(a) {
    return (!!a) && (a.constructor === Object);
};
console.log(isObject(        )); // false
console.log(isObject(    null)); // false
console.log(isObject(    true)); // false
console.log(isObject(       1)); // false
console.log(isObject(   'str')); // false
console.log(isObject(      [])); // false
console.log(isObject(new Date)); // false
console.log(isObject(      {})); // true
80
zupa

Ich mag einfach nur: 

function isObject (item) {
  return (typeof item === "object" && !Array.isArray(item) && item !== null);
}

Wenn das Element ein JS-Objekt und kein JS-Array ist und es sich nicht um null handelt. Wenn alle drei zutreffen, geben Sie true zurück. Wenn eine der drei Bedingungen fehlschlägt, wird der &&-Test kurzgeschlossen und false zurückgegeben. Der null-Test kann auf Wunsch weggelassen werden (abhängig davon, wie Sie null verwenden). 

DOCS: 

http://devdocs.io/javascript/operators/typeof

http://devdocs.io/javascript/global_objects/object

http://devdocs.io/javascript/global_objects/array/isarray

http://devdocs.io/javascript/global_objects/null

70
jtheletter

Mit der Funktion Array.isArray:

function isObject(o) {
  return o !== null && typeof o === 'object' && Array.isArray(o) === false;
}

Ohne Funktion Array.isArray:

Nur überrascht, wie viele Upvotes für falsche Antworten ????
Nur 1 Antwort hat meine Tests bestanden !!! Hier habe ich meine vereinfachte Version erstellt:

function isObject(o) {
  return o instanceof Object && o.constructor === Object;
}

Was mich betrifft, ist es klar und einfach und funktioniert einfach! Hier meine Tests:

console.log(isObject({}));             // Will return: true
console.log(isObject([]));             // Will return: false
console.log(isObject(null));           // Will return: false
console.log(isObject(/.*/));           // Will return: false
console.log(isObject(function () {})); // Will return: false

EINE MEHR ZEIT: Nicht alle Antworten bestehen diese Tests !!! ????


Wenn Sie sicherstellen müssen, dass das Objekt Instanz einer bestimmten Klasse ist, müssen Sie den Konstruktor mit Ihrer bestimmten Klasse überprüfen, z.

function isDate(o) {
  return o instanceof Object && o.constructor === Date;
}

einfacher Test:

var d = new Date();
console.log(isObject(d)); // Will return: false
console.log(isDate(d));   // Will return: true

Als Ergebnis erhalten Sie strengen und robusten Code!


Wenn Sie keine Funktionen wie isDate, isError, isRegExp usw. erstellen, können Sie die Option zur Verwendung dieser verallgemeinerten Funktionen in Betracht ziehen:

function isObject(o) {
  return o instanceof Object && typeof o.constructor === 'function';
}

es funktioniert nicht korrekt für alle zuvor genannten Testfälle, ist aber für alle Objekte (einfach oder konstruiert) gut genug.


isObject funktioniert nicht im Fall von Object.create(null) aufgrund der internen Implementierung von Object.create, die hier erklärt wird, aber Sie können isObject in einer komplexeren Implementierung verwenden:

function isObject(o, strict = true) {
  if (o === null || o === undefined) {
    return false;
  }
  const instanceOfObject = o instanceof Object;
  const typeOfObject = typeof o === 'object';
  const constructorUndefined = o.constructor === undefined;
  const constructorObject = o.constructor === Object;
  const typeOfConstructorObject = typeof o.constructor === 'function';
  let r;
  if (strict === true) {
    r = (instanceOfObject || typeOfObject) && (constructorUndefined || constructorObject);
  } else {
    r = (constructorUndefined || typeOfConstructorObject);
  }
  return r;
};

Basierend auf dieser Implementierung wurde bereits Paket auf npm v1 erstellt! Und es funktioniert für alle zuvor beschriebenen Testfälle! ????

63
Vladimir Kovpak

OK, lassen Sie uns dieses Konzept zuerst geben, bevor Sie Ihre Frage beantworten. In JavaScript-Funktionen sind Object, auch null, Object, Arrays und sogar Date, so wie Sie sehen, dass nicht ein einfacher Weg wie type of obj === object ', also wird alles, was oben erwähnt wurde, true zurückgeben , aber es gibt Möglichkeiten, dies zu überprüfen, indem Sie eine Funktion schreiben oder JavaScript-Frameworks verwenden, OK:

Stellen Sie sich vor, Sie haben dieses Objekt, das ein reales Objekt ist (nicht Null oder Funktion oder Array):

var obj = {obj1: 'obj1', obj2: 'obj2'};

Reines JavaScript:

//that's how it gets checked in angular framework
function isObject(obj) {
  return obj !== null && typeof obj === 'object';
}

oder 

//make sure the second object is capitalised 
function isObject(obj) {
   return Object.prototype.toString.call(obj) === '[object Object]';
}

oder

function isObject(obj) {
    return obj.constructor.toString().indexOf("Object") > -1;
}

oder

function isObject(obj) {
    return obj instanceof Object;
}

Sie können eine dieser Funktionen einfach wie oben in Ihrem Code verwenden, indem Sie sie aufrufen. Wenn es sich um ein Objekt handelt, wird true zurückgegeben:

isObject(obj);

Wenn Sie ein JavaScript-Framework verwenden, haben diese normalerweise folgende Funktionen für Sie vorbereitet. Dies sind einige davon:

jQuery: 

 //It returns 'object' if real Object;
 jQuery.type(obj);

Winkel:

angular.isObject(obj);

Unterstrich und Lodash:

//(NOTE: in Underscore and Lodash, functions, arrays return true as well but not null)
_.isObject(obj);
27
Alireza

Es hängt davon ab, was Sie mit "ist ein Objekt" meinen. Wenn Sie alles wollen, was kein primitives ist, d. H. Dinge, für die Sie neue Eigenschaften festlegen können, sollten Sie dies tun:

function isAnyObject(value) {
    return value != null && (typeof value === 'object' || typeof value === 'function');
}

Sie schließt die Primitiven (einfache Zahlen/_ [VARIABLE] NaN, einfache Zeichenfolgen, Symbole, Infinity/true, false und undefined und null aus sollte für alles andere wahr sein (einschließlich Number, Boolean und String -Objekte). Beachten Sie, dass JS nicht definiert, was "Host" -Objekte, wie window oder console, zurückgeben sollen, wenn sie mit typeof verwendet werden, so dass diese mit einer solchen Überprüfung schwer abzudecken sind.

Wenn Sie wissen möchten, ob etwas ein "einfaches" Objekt ist, d. H. Es wurde als Literal {} oder mit Object.create(null) erstellt, können Sie Folgendes tun:

function isPlainObject(value) {
    if (Object.prototype.toString.call(value) !== '[object Object]') {
        return false;
    } else {
        var prototype = Object.getPrototypeOf(value);
        return prototype === null || prototype === Object.prototype;
    }
}

_/Edit 2018: Da Symbol.toStringTag jetzt das Anpassen der Ausgabe von Object.prototype.toString.call(...) erlaubt, kann die Funktion isPlainObject in einigen Fällen false zurückgeben, selbst wenn das Objekt als Literal anfing. In der Regel ist ein Objekt mit einem benutzerdefinierten String-Tag nicht mehr eigentlich ein einfaches Objekt, aber dies hat die Definition dessen, was ein einfaches Objekt überhaupt in Javascript ist, weiter getrübt.

21
last-child

Oh mein Gott! Ich denke, das könnte kürzer sein als je zuvor.

Kurz- und Schlusscode

function isObject(obj)
{
    return obj != null && obj.constructor.name === "Object"
}

console.log(isObject({})) // returns true
console.log(isObject([])) // returns false
console.log(isObject(null)) // returns false

Erklärt

Rückgabetypen

typ von JavaScript-Objekten (einschließlich null) gibt "object" zurück

console.log(typeof null, typeof [], typeof {})

Überprüfung ihrer Konstruktoren

Wenn Sie die Eigenschaft constructor überprüfen, wird die Funktion mit ihren Namen zurückgegeben.

console.log(({}).constructor) // returns a function with name "Object"
console.log(([]).constructor) // returns a function with name "Array"
console.log((null).constructor) //throws an error because null does not actually have a property

Einführung in Function.name

Function.name Gibt einen schreibgeschützten Namen einer Funktion oder "anonymous" Für Abschlüsse zurück.

console.log(({}).constructor.name) // returns "Object"
console.log(([]).constructor.name) // returns "Array"
console.log((null).constructor.name) //throws an error because null does not actually have a property

Hinweis: Ab 2018 funktioniert Function.name möglicherweise nicht in [~ # ~] dh [~ # ~ ] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#Browser_compatibility

20
Erisan Olasheni

Mein Gott, zu viel Verwirrung in anderen Antworten.

Kurze Antwort

typeof anyVar == 'object' && anyVar instanceof Object && !(anyVar instanceof Array)

Um dies zu testen, führen Sie einfach die folgenden Anweisungen in chrome console aus.

Fall 1

var anyVar = {};
typeof anyVar == 'object' && anyVar instanceof Object && !(anyVar instanceof Array) // true

Fall 2

anyVar = [];
typeof anyVar == 'object' && anyVar instanceof Object && !(anyVar instanceof Array) // false

Fall

anyVar = null;
typeof anyVar == 'object' && anyVar instanceof Object && !(anyVar instanceof Array); // false

Erklärung

Okay. Lass es uns brechen

typeof anyVar == 'object' Wird von drei Kandidaten als wahr zurückgegeben - [], {} and null,

anyVar instanceof Object Schränkt diese Kandidaten auf zwei ein - [], {}

!(anyVar instanceof Array) verengt sich auf eins - {}

Trommelwirbel bitte!

Auf diese Weise haben Sie möglicherweise bereits gelernt, in Javascript nach Arrays zu suchen.

17
kushalvm

Der sinnvollste Weg, um den Typ eines Werts zu prüfen, ist der Operator typeof. Das einzige Problem ist, dass es schrecklich kaputt ist:

  • Es gibt "object" für null zurück, der zum Null-Typ gehört.
  • Es gibt "function" für aufrufbare Objekte zurück, die zum Objekttyp gehören.
  • Es kann (fast) alles zurückgeben, was es für nicht standardmäßige, nicht aufrufbare Objekte benötigt. Zum Beispiel schien IE "unknown" zu mögen. Die einzigen verbotenen Ergebnisse sind "function" und primitive Typen.

typeof ist nur für Nicht-null-Primitive zuverlässig. Eine Möglichkeit, zu überprüfen, ob ein Wert ein Objekt ist, würde sicherstellen, dass die von typeof zurückgegebene Zeichenfolge keinem Primitiv entspricht und dass das Objekt nicht null ist. Das Problem ist jedoch, dass ein zukünftiger Standard einen neuen primitiven Typ einführen könnte, und unser Code würde dies als Objekt betrachten. Neue Typen erscheinen nicht häufig, aber beispielsweise wurde in ECMAScript 6 der Symboltyp eingeführt.

Deshalb empfehle ich statt typeof nur Ansätze, deren Ergebnis davon abhängt, ob der Wert ein Objekt ist oder nicht. Folgendes soll ein sein 

Umfassende, aber nicht erschöpfende Liste mit geeigneten Methoden zum Testen, ob ein Wert zum Objekttyp gehört.

  • Object Konstruktor

    Der Konstruktor Object zwingt das übergebene Argument in ein Objekt. Wenn es bereits ein Objekt ist, wird dasselbe Objekt zurückgegeben.

    Daher können Sie es verwenden, um den Wert zu einem Objekt zu zwingen und dieses Objekt streng mit dem ursprünglichen Wert zu vergleichen.

    Die folgende Funktion erfordert ECMAScript 3, wodurch === eingeführt wurde:

    function isObject(value) { /* Requires ECMAScript 3 or later */
      return Object(value) === value;
    }
    

    Ich mag diesen Ansatz, weil er einfach und selbstbeschreibend ist und eine analoge Prüfung auch für Booleans, Zahlen und Strings funktioniert. Beachten Sie jedoch, dass das globale Object nicht gespiegelt oder geändert wird.

  • Konstrukteure

    Wenn Sie einen Konstruktor instanziieren, kann er einen anderen Wert als die soeben erstellte Instanz zurückgeben. Dieser Wert wird jedoch ignoriert, sofern es sich nicht um ein Objekt handelt.

    Die folgende Funktion erfordert ECMAScript 3, mit dem Konstruktoren Nicht-Objekte zurückgeben können. Vor ECMAScript 3 wurde ein Fehler ausgegeben, aber try -Anweisungen gab es damals nicht.

    function isObject(value) { /* Requires ECMAScript 3 or later */
      return new function() { return value; }() === value;
    }
    

    Dies ist zwar etwas weniger einfach als im vorigen Beispiel, aber es ist nicht auf ein globales Eigentum angewiesen und daher möglicherweise das sicherste.

  • this Wert

    Alte ECMAScript-Spezifikationen erforderten, dass der this-Wert ein Objekt ist. ECMAScript 3 führte Function.prototype.call ein, mit dem eine Funktion mit einem beliebigen this-Wert aufgerufen werden konnte, der jedoch zu einem Objekt gezwungen wurde.

    ECMAScript 5 führte einen strikten Modus ein, der dieses Verhalten beseitigte. Im schlampigen Modus können wir uns jedoch immer noch darauf verlassen (sollten es jedoch nicht).

    function isObject(value) { /* Requires ECMAScript 3 or later in sloppy mode */
      return function() { return this === value; }.call(value);
    }
    
  • [[Prototyp]]

    Alle gewöhnlichen Objekte haben einen internen Slot mit dem Namen [[Prototyp]], dessen Wert bestimmt, von welchem ​​anderen Objekt sie erbt. Der Wert kann nur ein Objekt oder null sein. Daher können Sie versuchen, ein Objekt zu erstellen, das vom gewünschten Wert erbt, und prüfen, ob es funktioniert hat.

    Sowohl Object.create als auch Object.getPrototypeOf erfordern ECMAScript 5.

    function isObject(value) { /* Requires ECMAScript 5 or later */
      try {
        Object.create(value);
        return value !== null;
      } catch(err) {
        return false;
      }
    }
    
    function isObject(value) { /* Requires ECMAScript 5 or later */
      function Constructor() {}
      Constructor.prototype = value;
      return Object.getPrototypeOf(new Constructor()) === value;
    }
    
  • Einige neue ECMAScript 6-Wege

    ECMAScript 6 führt einige neue indirekte Methoden ein, um zu prüfen, ob ein Wert ein Objekt ist. Sie verwenden den zuvor gesehenen Ansatz, um den Wert an einen Code zu übergeben, der ein Objekt erfordert, das in eine try -Anweisung eingeschlossen ist, um Fehler abzufangen. Einige versteckte Beispiele, die es nicht wert sind, kommentiert zu werden

    function isObject(value) { /* Requires ECMAScript 6 or later */
      try {
        Object.setPrototypeOf({}, value);
        return value !== null;
      } catch(err) {
        return false;
      }
    }

    function isObject(value) { /* Requires ECMAScript 6 or later */
      try {
        new WeakSet([value]);
        return true;
      } catch(err) {
        return false;
      }
    }


Hinweis: Ich habe absichtlich einige Ansätze wie Object.getPrototypeOf(value) (ES5) und Reflect-Methoden (ES6) übersprungen, da sie wesentliche interne Methoden aufrufen, die unangenehme Dinge ausführen können, z. wenn value ein Proxy ist. Aus Sicherheitsgründen beziehen sich meine Beispiele nur auf value, ohne direkt darauf zuzugreifen.

16
Oriol

Versuche dies

if (objectName instanceof Object == false) {
  alert('Not an object');
}
else {
  alert('An object');
}
14
Talha

Gebrauchsfertige Funktionen zur Überprüfung

function isObject(o) {
  return null != o && 
    typeof o === 'object' && 
    Object.prototype.toString.call(o) === '[object Object]';
}

function isDerivedObject(o) {
  return !isObject(o) && 
    null != o && 
    (typeof o === 'object' || typeof o === 'function') &&
    /^\[object /.test(Object.prototype.toString.call(o));
}

// Loose equality operator (==) is intentionally used to check
// for undefined too

// Also note that, even null is an object, within isDerivedObject
// function we skip that and always return false for null

Erläuterung

  • In Javascript sind null, Object, Array, Date und functions alle Objekte. Obwohl null etwas durchdacht ist. Daher ist es besser, zuerst nach null zu suchen, um festzustellen, dass es nicht null ist.

  • Die Prüfung auf typeof o === 'object' garantiert, dass o ein Objekt ist. Ohne diese Prüfung wäre Object.prototype.toString sinnlos, da er selbst für undefined und null ein Objekt zur weiteren Übergabe zurückgeben würde! Zum Beispiel: toString(undefined) gibt [object Undefined] zurück!

    Nach typeof o === 'object' check ist toString.call (o) eine hervorragende Methode, um zu überprüfen, ob o ein Objekt ist, ein abgeleitetes Objekt wie Array, Date oder ein function.

  • In der Funktion isDerivedObject wird geprüft, ob die Funktion o eine Funktion ist. Weil auch ein Objekt funktioniert, deshalb ist es da. Wenn dies nicht der Fall ist, wird die Funktion als falsch zurückgegeben. Beispiel: isDerivedObject(function() {}) würde false zurückgeben, jetzt wird jedoch true zurückgegeben.

  • Man kann immer die Definition dessen ändern, was ein Objekt ist. So kann man diese Funktionen entsprechend ändern.


Tests

function isObject(o) {
  return null != o && 
    typeof o === 'object' && 
    Object.prototype.toString.call(o) === '[object Object]';
}

function isDerivedObject(o) {
  return !isObject(o) && 
    null != o && 
    (typeof o === 'object' || typeof o === 'function') &&
    /^\[object /.test(Object.prototype.toString.call(o));
}

// TESTS

// is null an object?

console.log(
  'is null an object?', isObject(null)
);

console.log(
  'is null a derived object?', isDerivedObject(null)
);

// is 1234 an object?

console.log(
  'is 1234 an object?', isObject(1234)
);

console.log(
  'is 1234 a derived object?', isDerivedObject(1234)
);

// is new Number(1234) an object?

console.log(
  'is new Number(1234) an object?', isObject(new Number(1234))
);

console.log(
  'is new Number(1234) a derived object?', isDerivedObject(1234)
);

// is function object an object?

console.log(
  'is (new (function (){})) an object?', 
  isObject((new (function (){})))
);

console.log(
  'is (new (function (){})) a derived object?', 
  isObject((new (function (){})))
);

// is {} an object?

console.log(
  'is {} an object?', isObject({})
);

console.log(
  'is {} a derived object?', isDerivedObject({})
);

// is Array an object?

console.log(
  'is Array an object?',
  isObject([])
)

console.log(
  'is Array a derived object?',
  isDerivedObject([])
)

// is Date an object?

console.log(
  'is Date an object?', isObject(new Date())
);

console.log(
  'is Date a derived object?', isDerivedObject(new Date())
);

// is function an object?

console.log(
  'is function an object?', isObject(function(){})
);

console.log(
  'is function a derived object?', isDerivedObject(function(){})
);

12
Inanc Gumus
var a = [1]
typeof a //"object"
a instanceof Object //true
a instanceof Array //true

var b ={a: 1}
b instanceof Object //true
b instanceof Array //false

var c = null
c instanceof Object //false
c instanceof Array //false

Ich wurde gebeten, weitere Details anzugeben. Die sauberste und verständlichste Methode, zu überprüfen, ob unsere Variable ein Objekt ist, ist typeof myVar. Es gibt eine Zeichenfolge mit einem Typ zurück (z. B. "object", "undefined").

Leider haben auch Array und NULL einen Typ object. Um nur echte Objekte zu erfassen, müssen Sie die Vererbungskette mit dem Operator instanceof überprüfen. Es wird null beseitigen, aber Array hat Object in der Vererbungskette.

Die Lösung lautet also:

if (myVar instanceof Object && !(myVar instanceof Array)) {
  // code for objects
}
11
Kania

Etwas spät ... für "einfache Objekte" (ich meine wie {'x': 5, 'y': 7}) Ich habe diesen kleinen Ausschnitt:

function isPlainObject(o) {
   return ((o === null) || Array.isArray(o) || typeof o == 'function') ?
           false
          :(typeof o == 'object');
}

Es erzeugt die nächste Ausgabe:

console.debug(isPlainObject(isPlainObject)); //function, false
console.debug(isPlainObject({'x': 6, 'y': 16})); //literal object, true
console.debug(isPlainObject(5)); //number, false
console.debug(isPlainObject(undefined)); //undefined, false
console.debug(isPlainObject(null)); //null, false
console.debug(isPlainObject('a')); //string, false
console.debug(isPlainObject([])); //array?, false
console.debug(isPlainObject(true)); //bool, false
console.debug(isPlainObject(false)); //bool, false

Es funktioniert immer bei mir. If gibt nur dann "true" zurück, wenn der Typ von "o" "object" ist, aber keine Null oder Array oder Funktion. :)

10

lodash hat isPlainObject , nach was viele suchen, die auf diese Seite kommen. Es gibt false zurück, wenn eine Funktion oder ein Array angegeben wird.

8
Pat

Wenn alles andere fehlschlägt, verwende ich Folgendes:

var isObject = function(item) {
   return item.constructor.name === "Object";
}; 
7
Michal

Das wird funktionieren. Es ist eine Funktion, die true, false oder möglicherweise null zurückgibt.

const isObject = obj => obj && obj.constructor && obj.constructor === Object;

console.log(isObject({})); // true
console.log(isObject([])); // false
console.log(isObject(new Function)); // false
console.log(isObject(new Number(123))); // false
console.log(isObject(null)); // null

7
pizza-r0b

Die Funktionsbibliothek Ramda hat eine wunderbare Funktion zum Erkennen von JavaScript-Typen.

Umschreiben der Vollfunktion :

function type(val) {
  return val === null      ? 'Null'      :
         val === undefined ? 'Undefined' :
         Object.prototype.toString.call(val).slice(8, -1);
}

Ich musste lachen, als mir klar wurde, wie einfach und schön die Lösung war.

Anwendungsbeispiel aus Ramda Dokumentation :

R.type({}); //=> "Object"
R.type(1); //=> "Number"
R.type(false); //=> "Boolean"
R.type('s'); //=> "String"
R.type(null); //=> "Null"
R.type([]); //=> "Array"
R.type(/[A-z]/); //=> "RegExp"
R.type(() => {}); //=> "Function"
R.type(undefined); //=> "Undefined"
6
DaveGauer

Da es sehr verwirrend zu sein scheint, wie man dieses Problem richtig handhabt, lasse ich meine 2 Cent (diese Antwort ist spezifikationskonform und führt unter allen Umständen zu korrekten Ergebnissen):

Prüfung auf Grundelemente: undefinednullbooleanstringnumber

function isPrimitive(o){return typeof o!=='object'||null}

Ein Objekt ist kein Primitiv:

function isObject(o){return !isPrimitive(o)}

Oder alternativ:

function isObject(o){return o instanceof Object}
function isPrimitive(o){return !isObject(o)}

Testen für ein beliebiges Array:

const isArray=(function(){
    const arrayTypes=Object.create(null);
    arrayTypes['Array']=true;
    arrayTypes['Int8Array']=true;
    arrayTypes['Uint8Array']=true;
    arrayTypes['Uint8ClampedArray']=true;
    arrayTypes['Int16Array']=true;
    arrayTypes['Uint16Array']=true;
    arrayTypes['Int32Array']=true;
    arrayTypes['Uint32Array']=true;
    arrayTypes['Float32Array']=true;
    arrayTypes['Float64Array']=true;
    return function(o){
        if (!o) return false;
        return !isPrimitive(o)&&!!arrayTypes[o.constructor.name];
    }
}());

Prüfung auf Objekt mit Ausnahme von: DateRegExpBooleanNumberStringFunction beliebiges Array

const isObjectStrict=(function(){
    const nativeTypes=Object.create(null);
    nativeTypes['Date']=true;
    nativeTypes['RegExp']=true;
    nativeTypes['Boolean']=true;
    nativeTypes['Number']=true;
    nativeTypes['String']=true;
    nativeTypes['Function']=true;
    return function(o){
        if (!o) return false;
        return !isPrimitive(o)&&!isArray(o)&&!nativeTypes[o.constructor.name];
    }
}());
6
c7x43t
if(typeof value === 'object' && value.constructor === Object)
{
    console.log("This is an object");
}
6
Mahak Choudhary
  var isObject = function(obj) {
    var type = typeof obj;
    return type === 'function' || type === 'object' && !!obj;
  };

!!obj ist eine Abkürzung für die Überprüfung, ob das Objekt wahr ist (um Null/undefiniert herauszufiltern) 

5
Ira

Was ich gerne benutze, ist dies

function isObject (obj) {
  return typeof(obj) == "object" 
        && !Array.isArray(obj) 
        && obj != null 
        && obj != ""
        && !(obj instanceof String)  }

Ich denke, in den meisten Fällen muss ein Datum die Prüfung als Objekt bestehen, sodass ich keine Datumsangaben filtern kann

4
JohnPan

ich habe eine "neue" Methode gefunden, um genau diese Art von Typprüfung anhand dieser SO - Frage durchzuführen: Warum gibt instanceof für einige Literale false zurück?

daraus habe ich eine Funktion zur Typprüfung wie folgt erstellt:

function isVarTypeOf(_var, _type){
    try {
        return _var.constructor === _type;
    } catch(ex) {
        return false;         //fallback for null or undefined
    }
}

dann kannst du einfach:

console.log(isVarTypeOf('asdf', String));   // returns true
console.log(isVarTypeOf(new String('asdf'), String));   // returns true
console.log(isVarTypeOf(123, String));   // returns false
console.log(isVarTypeOf(123, Number));   // returns true
console.log(isVarTypeOf(new Date(), String));   // returns false
console.log(isVarTypeOf(new Date(), Number));   // returns false
console.log(isVarTypeOf(new Date(), Date));   // returns true
console.log(isVarTypeOf([], Object));   // returns false
console.log(isVarTypeOf([], Array));   // returns true
console.log(isVarTypeOf({}, Object));   // returns true
console.log(isVarTypeOf({}, Array));   // returns false
console.log(isVarTypeOf(null, Object));   // returns false
console.log(isVarTypeOf(undefined, Object));   // returns false
console.log(isVarTypeOf(false, Boolean));   // returns true

dies wird auf Chrome 56, Firefox 52, Microsoft Edge 38, Internet Explorer 11 und Opera 43 getestet

edit:
Wenn Sie auch prüfen möchten, ob eine Variable null oder undefined ist, können Sie stattdessen Folgendes verwenden:

function isVarTypeOf(_var, _type){
    try {
        return _var.constructor === _type;
    } catch(ex) {
        return _var == _type;   //null and undefined are considered the same
        // or you can use === if you want to differentiate them
    }
}

var a = undefined, b = null;
console.log(isVarTypeOf(a, undefined)) // returns true
console.log(isVarTypeOf(b, undefined)) // returns true
console.log(isVarTypeOf(a, null)) // returns true

Update von inancs Kommentar: Herausforderung angenommen: D

wenn Sie Objekte vergleichen möchten, können Sie dies folgendermaßen versuchen:

function isVarTypeOf(_var, _type, looseCompare){
    if (!looseCompare){
        try {
            return _var.constructor === _type;
        } catch(ex){
            return _var == _type;
        }
    } else {
        try{
            switch(_var.constructor){
                case Number:
                case Function:
                case Boolean:
                case Symbol:
                case Date:
                case String:
                case RegExp:
                    // add all standard objects you want to differentiate here
                    return _var.constructor === _type;
                case Error:
                case EvalError:
                case RangeError:
                case ReferenceError:
                case SyntaxError:
                case TypeError:
                case URIError:
                    // all errors are considered the same when compared to generic Error
                    return (_type === Error ? Error : _var.constructor) === _type;
                case Array:
                case Int8Array:
                case Uint8Array:
                case Uint8ClampedArray:
                case Int16Array:
                case Uint16Array:
                case Int32Array:
                case Uint32Array:
                case Float32Array:
                case Float64Array:
                    // all types of array are considered the same when compared to generic Array
                    return (_type === Array ? Array : _var.constructor) === _type;
                case Object:
                default:
                    // the remaining are considered as custom class/object, so treat it as object when compared to generic Object
                    return (_type === Object ? Object : _var.constructor) === _type;
            }
        } catch(ex){
            return _var == _type;   //null and undefined are considered the same
            // or you can use === if you want to differentiate them
        }
    }
}

auf diese Weise können Sie den Kommentar von Inanc genauso machen:

isVarTypeOf(new (function Foo(){}), Object); // returns false
isVarTypeOf(new (function Foo(){}), Object, true); // returns true

oder

Foo = function(){};
Bar = function(){};
isVarTypeOf(new Foo(), Object);   // returns false
isVarTypeOf(new Foo(), Object, true);   // returns true
isVarTypeOf(new Bar(), Foo, true);   // returns false
isVarTypeOf(new Bar(), Bar, true);   // returns true
isVarTypeOf(new Bar(), Bar);    // returns true
3
am05mhz

Betrachten Sie - typeof bar === "object", Um festzustellen, ob bar ein Objekt ist

Obwohl typeof bar === "object" Eine zuverlässige Methode ist, um zu überprüfen, ob der Balken ein Objekt ist, ist der überraschende Punkt in JavaScript, dass null auch als Objekt betrachtet wird!

Aus diesem Grund protokolliert der folgende Code zur Überraschung der meisten Entwickler "true" (nicht "false") in der Konsole:

var bar = null;console.log(typeof bar === "object"); // logs true! Solange man sich dessen bewusst ist, kann das Problem leicht vermieden werden, indem man auch überprüft, ob der Balken Null ist:

console.log((bar !== null) && (typeof bar === "object")); // logs false Um in unserer Antwort ganz genau zu sein, gibt es noch zwei andere erwähnenswerte Dinge:

Erstens gibt die obige Lösung false zurück, wenn der Balken eine Funktion ist. In den meisten Fällen ist dies das gewünschte Verhalten. In Situationen, in denen Sie auch true für Funktionen zurückgeben möchten, können Sie die obige Lösung folgendermaßen ändern:

console.log((bar !== null) && ((typeof bar === "object") || (typeof bar === "function"))); Zweitens gibt die obige Lösung true zurück, wenn bar ein Array ist (z. B. wenn var bar = [];). In den meisten Fällen ist dies das gewünschte Verhalten, da Arrays tatsächlich Objekte sind. In Situationen, in denen Sie jedoch auch für Arrays den Wert false angeben möchten, können Sie die obige Lösung folgendermaßen ändern:

console.log((bar !== null) && (typeof bar === "object") && (toString.call(bar) !== "[object Array]")); Es gibt jedoch eine andere Alternative, die für Nullen, Arrays und Funktionen false zurückgibt, für Objekte jedoch true:

console.log((bar !== null) && (bar.constructor === Object)); Oder, wenn Sie jQuery verwenden:

console.log((bar !== null) && (typeof bar === "object") && (! $.isArray(bar)));

Mit ES5 wird der Array-Fall sehr einfach, einschließlich einer eigenen Nullprüfung:

console.log(Array.isArray(bar));

2
Exception

Wenn Sie prüfen möchten, ob die prototype für eine object ausschließlich von Object stammt. Filtert String, Number, Array, Arguments usw.

function isObject(n) {
  if (n == null) return false;
  return Object.prototype.toString.call(n) === '[object Object]';
}
1
sasi

use typeof(my_obj) gibt an, um welchen Variablentyp es sich handelt. 

wenn es Objekt ist, wird 'Objekt' angezeigt.

einfache JS-Funktion,

function isObj(v) {
    return typeof(v) == "object"
}

Z.B:

function isObj(v) {
    return typeof(v) == "object"
}

var samp_obj = {
   "a" : 1,
   "b" : 2,
   "c" : 3
}

var num = 10;
var txt = "Hello World!"
var_collection = [samp_obj, num, txt]
for (var i in var_collection) {
  if(isObj(var_collection[i])) {
     console.log("yes it is object")
  }
  else {
     console.log("No it is "+ typeof(var_collection[i]))
  }
}

Wenn Sie AngularJS bereits verwenden, verfügt es über eine integrierte Methode, die prüft, ob es ein Objekt ist (ohne NULL zu akzeptieren). 

angular.isObject(...)
1
Robert

Meistens wird typeof obj[index] === 'object' verwendet, aber es werden auch function und #document zurückgegeben, die Objekte sind. Es hängt von Ihnen ab, ob es in das Ergebnis aufgenommen werden muss.

Grundsätzlich können Sie einen Testcode erstellen, der herausfiltert, ob ein bestimmtes Element ein Objekt ist, indem Sie die Ausgabe in Ihrer Konsole überprüfen. Hier können Sie einen Code nur für ein Beispiel ausführen:

function cekObject(obj, index) {  
  if (!obj.tagName) {

    //test case #1      
    if (typeof obj === 'object') {
      console.log('obj['+ index +'] is listed as an object');
    }	
    
  }
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.2.3/jquery.min.js"></script>
<script>
  function updateFilters() {
    var object = $('.j-image');
    $('.juicer-feed').empty();
    
    for(var index in object) {
      cekObject(object[index], index);
    }; 
  }
</script>

<ul class="juicer-feed" data-feed-id="chetabahana" data-after="updateFilters()"></ul>
<script src="https://assets.juicer.io/embed.js"></script>

1
Chetabahana

Es hängt vom Anwendungsfall ab. Wenn wir nicht zulassen möchten, dass Array und Funktionen ein Objekt sind, können wir die integrierten Funktionen von unterstrichen.js verwenden. 

function xyz (obj) { 
   if (_.isObject(obj) && !_.isFunction(obj) && !.isArray(obj)) {
     // now its sure that obj is an object 
   } 
}
1
ajayv

Wenn Sie explizit prüfen möchten, ob der angegebene Wert {} ist.

function isObject (value) {
 return value && typeof value === 'object' && value.constructor === Object;
}
0
Carlos

sie können einfach JSON.stringify verwenden, um Ihr Objekt wie folgt zu testen:

var test = {}
if(JSON.stringify(test)[0] === '{') {
  console.log('this is a Object')
}

0
GuaHsu