Vérifier si une valeur est un objet en JavaScript

Question

Comment vérifier si une valeur est un objet en JavaScript?

Answer 1

Essayez d’utiliser typeof(var) et/ou var instanceof something.

EDIT: Cette réponse donne une idée de la façon d’examiner les propriétés de la variable, mais c’est pas une recette à toute épreuve (après tout, il n’ya pas de recette!) Pour vérifier si c’est un objet, loin de là. Puisque les gens ont tendance à chercher quelque chose à copier à partir d’ici sans faire aucune recherche, je leur recommande vivement de se tourner vers l’autre réponse, la plus votée (et la bonne!).

Answer 2

Si typeof yourVariable === 'object', c'est un objet ou null. Si vous souhaitez exclure null, indiquez-le simplement typeof yourVariable === 'object' && yourVariable !== null.

Answer 3

L'officiel underscore.js utilise ce contrôle pour savoir si quelque chose est vraiment un objet

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

METTRE À JOUR

La bibliothèque mise à jour underscore.js utilise maintenant les éléments suivants, en raison d’un bogue précédent dans V8 et d’une optimisation mineure de la vitesse micro. 

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

Answer 4

Object.prototype.toString.call(myVar) retournera:

• "[object Object]" si myVar est un objet
• "[object Array]" si myVar est un tableau
• etc.

Pour plus d'informations à ce sujet et pourquoi c'est une bonne alternative à typeof, consultez cet article .

Answer 5

Pour vérifier simplement avec Object ou Array sans appel de fonction supplémentaire (vitesse). Comme aussi posté ici .

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 () - Remarque: utilisez cette option uniquement pour les littéraux d'objet, car elle renvoie false pour les objets personnalisés, tels que la nouvelle date ou le nouvel objet YourCustomObject.

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

Answer 6

J'aime tout simplement: 

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

Si l'élément est un objet JS et qu'il ne s'agit pas d'un tableau JS, et que ce n'est pas null… si les trois s'avèrent vrais, renvoyez true. Si l’une des trois conditions échoue, le test && sera court-circuité et false sera renvoyé. Le test null peut être omis si vous le souhaitez (en fonction de la manière dont vous utilisez null). 

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

Answer 7

Avec la fonction Array.isArray:

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

Sans fonction Array.isArray:

Juste surpris de voir combien de votes positifs pour les mauvaises réponses ????
Seulement 1 réponse réussi mes tests !!! Ici j'ai créé ma version simplifiée:

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

Pour moi, c'est clair et simple, et ça marche! Voici mes 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

UNE FOIS DE PLUS: toutes les réponses ne passent pas ce test !!! ????

---

Si vous devez vérifier que cet objet est instance d'une classe particulière, vous devez vérifier le constructeur avec votre classe particulière, comme suit:

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

test simple:

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

En conséquence, vous aurez un code strict et robuste!

---

Si vous ne créez pas de fonctions telles que isDate, isError, isRegExp, etc., vous pouvez envisager d’utiliser cette fonction généralisée:

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

cela ne fonctionnera pas correctement pour tous les cas de test mentionnés plus haut, mais c'est suffisant pour tous les objets (simples ou construits).

---

isObject ne fonctionnera pas dans le cas de Object.create(null) en raison de l'implémentation interne de Object.create qui est expliquée ici mais vous pouvez utiliser isObject dans une implémentation plus sophistiquée:

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

Il y a déjà créé package sur npm v1 basé sur cette implémentation! Et cela fonctionne pour tous les cas de test décrits précédemment! ????

Answer 8

OK, voyons d'abord ce concept avant de répondre à votre question. Dans JavaScript, les fonctions sont Object, null, Object, Arrays et même Date, de sorte que, comme vous le voyez, il existe non une manière simple, comme typeof obj === ' object ', donc tout ce qui est mentionné ci-dessus retournera retournera vrai , mais il existe des moyens de le vérifier en écrivant une fonction ou en utilisant des frameworks JavaScript, OK:

Imaginons maintenant que cet objet est un objet réel (et non null, ni fonction, ni tableau):

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

Pure JavaScript:

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

ou 

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

ou

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

ou

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

Vous pouvez simplement utiliser l'une de ces fonctions comme ci-dessus dans votre code en les appelant et il retournera true s'il s'agit d'un objet:

isObject(obj);

Si vous utilisez un framework JavaScript, ils ont généralement préparé ce type de fonctions pour vous, en voici quelques unes:

jQuery: 

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

Angulaire:

angular.isObject(obj);

Underscore et Lodash:

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

Answer 9

Cela dépend de ce que vous voulez dire par "est un objet". Si vous voulez tout ce qui n’est pas un primitif, c’est-à-dire des éléments sur lesquels vous pouvez définir de nouvelles propriétés, faites l’essentiel:

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

Il exclut les primitives (nombres simples/NaNInfinity, chaînes simples, symboles, true/false, undefined et null), mais doit retourner la valeur true pour tout le reste (y compris les objets Number, Boolean et String). Notez que JS ne définit pas les objets "hôte", tels que window ou console, doivent être renvoyés lorsqu'ils sont utilisés avec typeof. Il est donc difficile de les couvrir avec un chèque comme celui-ci.

Si vous voulez savoir si quelque chose est un objet "simple", c’est-à-dire qu’il a été créé comme un {} littéral ou avec Object.create(null), vous pouvez le faire:

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: Etant donné que Symbol.toStringTag permet maintenant de personnaliser la sortie de Object.prototype.toString.call(...), la fonction isPlainObject ci-dessus peut renvoyer false dans certains cas, même lorsque l'objet a commencé sa vie en tant que littéral. On peut soutenir que, par convention, un objet avec une balise string personnalisée n'est plus un objet simple, mais cela a encore brouillé la définition d'un objet simple en Javascript.

Answer 10

Le moyen le plus raisonnable de vérifier le type d'une valeur semble être l'opérateur typeof. Le seul problème est que c'est horriblement cassé:

• Il retourne "object" pour null, qui appartient au type Null.
• Il renvoie "function" pour les objets appelables, qui appartiennent au type d'objet.
• Il peut renvoyer (presque) tout ce qu'il veut pour des objets non standard non appelables. Par exemple, IE semblait aimer "unknown". Les seuls résultats interdits sont "function" et les types primitifs.

typeof n'est fiable que pour les primitives non -null. Ainsi, un moyen de vérifier si une valeur est un objet serait de s'assurer que la chaîne renvoyée par typeof ne correspond pas à une primitive et que l'objet n'est pas null. Cependant, le problème est qu’une future norme pourrait introduire un nouveau type de primitive, et notre code considérerait qu’il s’agit d’un objet. Les nouveaux types n'apparaissent pas souvent, mais par exemple, ECMAScript 6 a introduit le type de symbole.

Par conséquent, au lieu de typeof, je ne recommande que les approches dont le résultat varie selon que la valeur est un objet ou non. Ce qui suit veut être un 

Liste complète mais non exhaustive des méthodes appropriées pour vérifier si une valeur appartient au type d'objet.

• Object constructeur

  Le constructeur Object contraint l'argument passé à un objet. S'il s'agit déjà d'un objet, le même objet est renvoyé.

  Par conséquent, vous pouvez l'utiliser pour contraindre la valeur à un objet et comparer strictement cet objet à la valeur d'origine.

  La fonction suivante nécessite ECMAScript 3, qui a introduit ===:

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

  J'aime cette approche car elle est simple et auto-descriptive, et une vérification analogue fonctionnera également pour les booléens, les nombres et les chaînes. Cependant, sachez qu’il faut que la variable globale Object ne soit ni ombrée ni modifiée.

• Constructeurs

  Lorsque vous instanciez un constructeur, il peut renvoyer une valeur différente de l'instance que vous venez de créer. Mais cette valeur sera ignorée sauf s'il s'agit d'un objet.

  La fonction suivante nécessite ECMAScript 3, qui permettait aux constructeurs de renvoyer des non-objets. Avant ECMAScript 3, une erreur était générée, mais les instructions try n'existaient pas à l'époque.

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

  Un peu moins simple que l'exemple précédent, celui-ci ne s'appuie sur aucune propriété globale et pourrait donc être le plus sûr.

• this value

  Les anciennes spécifications ECMAScript exigeaient que la valeur this soit un objet. ECMAScript 3 a introduit Function.prototype.call, qui permet d’appeler une fonction avec une valeur this arbitraire, mais contrainte à un objet.

  ECMAScript 5 a introduit un mode strict qui supprime ce comportement, mais en mode bâclé, nous pouvons toujours (mais sans doute ne pas le faire) compter dessus.

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

• [[Prototype]]

  Tous les objets ordinaires ont un emplacement interne appelé [[Prototype]], dont la valeur détermine de quel autre objet il hérite. La valeur ne peut être qu'un objet ou null. Par conséquent, vous pouvez essayer de créer un objet qui hérite de la valeur souhaitée et vérifier si cela a fonctionné.

  Object.create et Object.getPrototypeOf requièrent tous deux 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;
  }
  

• Quelques nouvelles méthodes ECMAScript 6

  ECMAScript 6 introduit de nouvelles méthodes indirectes pour vérifier si une valeur est un objet. Ils utilisent l'approche précédemment vue pour transmettre la valeur à un code nécessitant un objet, encapsulé dans une instruction try pour intercepter les erreurs. Quelques exemples cachés, qui ne valent pas la peine d'être commentés

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

---

Remarque: j'ai volontairement ignoré certaines approches telles que les méthodes Object.getPrototypeOf(value) (ES5) et Reflect (ES6), car elles appellent des méthodes internes essentielles pouvant faire des choses désagréables, par exemple si value est un proxy. Pour des raisons de sécurité, mes exemples ne font référence qu'à value sans y accéder directement.

Answer 11

Essaye ça

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

Answer 12

Fonctions prêtes à l'emploi pour la vérification

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

---

Explication

• En Javascript, null, Object, Array, Date et functions sont tous des objets. Bien que null soit un peu artificiel. Donc, il est préférable de vérifier d'abord la null, pour détecter qu'elle n'est pas nulle.

• Vérifier typeof o === 'object' garantit que o est un objet. Sans cette vérification, Object.prototype.toString n'aurait aucun sens, car il renverrait un objet pour tout, même pour undefined et null! Par exemple: toString(undefined) renvoie [object Undefined]!

  Après typeof o === 'object' check, toString.call (o) est une excellente méthode pour vérifier si o est un objet, un objet dérivé tel que Array, Date ou function.

• Dans la fonction isDerivedObject, il vérifie que la o est une fonction. Parce que fonctionner aussi un objet, c'est pourquoi il est là. Si cela n'a pas été fait, la fonction retournera comme false. Exemple: isDerivedObject(function() {}) renverrait false, mais maintenant, il retournera true.

• On peut toujours changer la définition de ce qu'est un objet. Donc, on peut changer ces fonctions en conséquence.

---

Des 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(){})
);

Answer 13

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

On m'a demandé de fournir plus de détails. Le moyen le plus propre et le plus compréhensible de vérifier si notre variable est un objet est typeof myVar. Il renvoie une chaîne avec un type (par exemple, "object", "undefined").

Malheureusement, Array et null ont également un type object. Pour ne prendre que des objets réels, il est nécessaire de vérifier la chaîne d'héritage à l'aide de l'opérateur instanceof. Cela éliminera null, mais Array a Object dans la chaîne d'héritage.

La solution est donc:

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

Answer 14

Petit retard ... pour les "objets simples" (je veux dire, comme {'x': 5, 'y': 7}), j'ai ce petit extrait:

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

Il génère la sortie suivante:

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

Ça marche toujours pour moi. If retournera "true" uniquement si le type de "o" est "objet", mais pas de null, ni de tableau, ni de fonction. :)

Answer 15

lodash a isPlainObject , ce qui pourrait être ce que recherchent de nombreux visiteurs de cette page. Il retourne false quand donne une fonction ou un tableau.

Answer 16

Quand tout le reste échoue, j'utilise ceci:

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

Answer 17

Cela fonctionnera. C'est une fonction qui renvoie true, false ou éventuellement null.

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

Answer 18

La bibliothèque fonctionnelle Ramda a une fonction merveilleuse pour détecter les types JavaScript.

Paraphrasant la fonction full :

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

J'ai dû rire quand j'ai réalisé à quel point la solution était simple et belle.

Exemple d'utilisation de Ramda documentation :

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"

Answer 19

Puisqu'il semble y avoir beaucoup de confusion sur la façon de traiter correctement ce problème, je vais laisser mes 2 centimes (cette réponse est conforme aux spécifications et produit des résultats corrects dans toutes les circonstances):

Test des primitives: undefinednullbooleanstringnumber

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

Un objet n'est pas une primitive:

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

Ou bien:

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

Test pour tout tableau:

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

Test d'objet excluant: DateRegExpBooleanNumberStringFunction any 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];
    }
}());

Answer 20

if(typeof value === 'object' && value.constructor === Object)
{
    console.log("This is an object");
}

Answer 21

  var isObject = function(obj) {
    var type = typeof obj;
    return type === 'function' || type === 'object' && !!obj;
  };

!!obj est un raccourci pour vérifier si l'objet est véridique (pour filtrer les valeurs null/indéfini) 

Answer 22

Ce que j'aime utiliser est-ce

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

Je pense que dans la plupart des cas, une date doit réussir le contrôle en tant qu'objet, aussi je ne filtre pas les dates

Answer 23

j'ai trouvé une "nouvelle" façon de faire ce type de vérification de type à partir de cette question SO: Pourquoi instanceof renvoie false pour certains littéraux?

à partir de cela, j'ai créé une fonction pour la vérification de type comme suit:

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

alors vous pouvez juste faire:

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

ceci est testé sur Chrome 56, Firefox 52, Microsoft Edge 38, Internet Explorer 11, Opera 43

modifier:
si vous voulez également vérifier si une variable est nulle ou non définie, vous pouvez utiliser ceci à la place:

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

mise à jour du commentaire d'inanc: défi accepté: D

si vous voulez perdre des objets à comparer, vous pouvez essayer ceci:

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

de cette façon, vous pouvez faire comme le commentaire d'inanc:

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

ou

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

Answer 24

Si vous souhaitez vérifier si la prototype pour une object provient uniquement de Object. Filtre sur String, Number, Array, Arguments, etc.

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

Answer 25

use typeof(my_obj) will indique de quel type de variable il s’agit. 

si c'est objet montrera 'objet'

fonction JS simple,

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

Par exemple:

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

Answer 26

Si vous utilisez déjà AngularJS, il dispose d'une méthode intégrée qui vérifie si c'est un objet (sans accepter null). 

angular.isObject(...)

Answer 27

La plupart du temps, typeof obj[index] === 'object' est utilisé, mais il retournera également function et #document qui sont des objets. Cela dépend de vous si cela doit être inclus dans le résultat.

En gros, vous pouvez créer un code de test qui filtre si un élément particulier est un objet en vérifiant la sortie dans votre console. Ici, vous pouvez exécuter un code juste pour un exemple:

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>

Answer 28

Cela dépend du cas d'utilisation. Si nous ne voulons pas autoriser le tableau et les fonctions à être un objet, nous pouvons utiliser les fonctions intégrées underscore.js. 

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

Answer 29

Si explicitement veut vérifier si la valeur donnée est {}.

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

Answer 30

vous pouvez simplement utiliser JSON.stringify pour tester votre objet, comme ceci:

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