Comment vérifiez-vous si une valeur est un objet en JavaScript?

MISE À JOUR :

Cette réponse est incomplète et donne des résultats trompeurs . Par exemple, nullest également considéré de type objecten JavaScript, sans parler de plusieurs autres cas de bord. Suivez la recommandation ci-dessous et passez à l'autre "réponse la plus positive (et correcte!)" .

Réponse originale :

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 des variables, mais ce n'est pas une recette à l'épreuve des balles (après tout, il n'y a pas de recette du tout!) Pour vérifier si c'est un objet, loin de là. Étant donné que les gens ont tendance à chercher quelque chose à copier à partir d'ici sans faire de recherche, je leur recommande fortement de se tourner vers l'autre réponse la plus appréciée (et correcte!).

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

Définissons "objet" en Javascript . Selon les documents MDN , chaque valeur est soit un objet soit une primitive:

primitive, valeur primitive

Une donnée qui n'est pas un objet et qui n'a aucune méthode. JavaScript a 5 types de données primitifs: chaîne, nombre, booléen, null, non défini.

Qu'est-ce qu'une primitive?

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

Qu'est-ce qu'un objet (c'est-à-dire pas une primitive)?

• Object.prototype
• tout descend de Object.prototype
  • Function.prototype
    • Object
    • Function
    • function C(){} - fonctions définies par l'utilisateur
  • C.prototype- la propriété prototype d'une fonction définie par l'utilisateur: ce n'est pas C le prototype
    • new C() - "nouveau" -ing une fonction définie par l'utilisateur
  • Math
  • Array.prototype
    • tableaux
  • {"a": 1, "b": 2} - objets créés en utilisant la notation littérale
  • new Number(3) - enveloppements autour des primitives
  • ... beaucoup d'autres choses ...
• Object.create(null)
• tout est descendu d'un Object.create(null)

Comment vérifier si une valeur est un objet

instanceof en soi ne fonctionnera pas, car il manque deux cas:

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

typeof x === 'object'ne fonctionnera pas, à cause des faux positifs ( null) et des faux négatifs (fonctions):

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

Object.prototype.toString.call ne fonctionnera pas, en raison de faux positifs pour toutes les primitives:

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

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

J'utilise donc:

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

La réponse de @ Daan semble également fonctionner:

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

car, selon les documents MDN :

Le constructeur d'objet crée un wrapper d'objet pour la valeur donnée. Si la valeur est nulle ou non définie, elle créera et renverra un objet vide, sinon, elle renverra un objet d'un type correspondant à la valeur donnée. Si la valeur est déjà un objet, elle renverra la valeur.

Une troisième façon qui semble fonctionner (pas sûr que ce soit 100%) est d'utiliser Object.getPrototypeOfce qui lève une exception si son argument n'est pas un objet:

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

underscore.js fournit la méthode suivante pour savoir si quelque chose est vraiment un objet:

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

MISE À JOUR

En raison d'un bogue précédent dans la V8 et d'une optimisation de micro vitesse mineure, la méthode se présente comme suit depuis underscore.js 1.7.0 (août 2014):

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

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 .

Pour une simple vérification par rapport à Object ou Array sans appel de fonction supplémentaire (vitesse). Comme également affiché 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 uniquement pour les littéraux d'objet, car il renvoie false pour les objets personnalisés, comme new Date ou new 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

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 ce n'est pas un tableau JS, et ce n'est pas null... si les trois s'avèrent vrais, revenez true. Si l'une des trois conditions échoue, le &&test sera court-circuité et falsesera renvoyé. Le nulltest peut être omis si vous le souhaitez (selon la façon dont vous l'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

Avec fonction Array.isArray:

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

Sans fonction Array.isArray:

Juste surpris du nombre de votes positifs pour les mauvaises réponses 😮
Une seule réponse a réussi mes tests !!! Ici, j'ai créé ma version simplifiée:

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

Quant à 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 réussissent pas ces tests !!! 🙈

Dans le cas où vous devez vérifier que l'objet est une instance d'une classe particulière, vous devez vérifier le constructeur avec votre classe particulière, comme:

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éerez pas des fonctions comme isDate, isError, isRegExp, etc vous pouvez envisager l' option d'utiliser ces fonctions généralisées:

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

il ne fonctionnera pas correctement pour tous les cas de test mentionnés précédemment, mais il est assez bon pour tous les objets (simples ou construits).

isObjectne fonctionnera pas en cas de Object.create(null)cause de l'implémentation interne Object.createqui est expliquée ici mais vous pouvez l'utiliser isObjectdans 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 existe déjà un package créé sur npm v1 basé sur cette implémentation! Et cela fonctionne pour tous les cas de test décrits précédemment! 🙂

Oh mon Dieu! Je pense que cela pourrait être plus court que jamais, voyons ceci:

Code court et final

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

Expliqué

Types de retour

typeof JavaScript (y compris null) renvoie"object"

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

Vérifier leurs constructeurs

La vérification de leur constructorpropriété renvoie la fonction avec leurs noms.

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

Présentation de Function.name

Function.namerenvoie un nom en lecture seule d'une fonction ou "anonymous"pour les fermetures.

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

Remarque: à partir de 2018, Function.name peut ne pas fonctionner dans IE https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#Browser_compatibility

OK, donnons-nous ce concept avant de répondre à votre question, dans les fonctions JavaScript sont Object, également null, Object, Arrays et même Date, donc comme vous le voyez, il n'y a pas de moyen simple comme typeof obj === 'object', donc tout ce qui est mentionné ci-dessus retournera vrai , mais il existe des moyens de le vérifier en écrivant une fonction ou en utilisant des frameworks JavaScript, OK:

Maintenant, imaginez que vous avez cet objet qui est un véritable objet (pas nul ou une fonction ou un tableau):

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

JavaScript pur:

//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 cela retournera vrai si c'est un objet:

isObject(obj);

Si vous utilisez un framework JavaScript, ils ont généralement préparé ce genre de fonctions pour vous, ce sont quelques-unes d'entre elles:

jQuery:

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

Angulaire:

angular.isObject(obj);

Souligner et Lodash:

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

Cela dépend de ce que vous entendez par «est un objet». Si vous voulez tout ce qui n'est pas une primitive , c'est-à-dire des choses sur lesquelles vous pouvez définir de nouvelles propriétés, cela devrait faire l'affaire:

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

Il exclut les primitives (nombres simples / NaN/ Infinity, chaînes simples, symboles, true/ false, undefinedet null) mais doit renvoyer true pour tout le reste (y compris Number, Booleanet les Stringobjets). Notez que JS ne définit pas quels objets "hôte", tels que windowou console, doivent retourner lorsqu'ils sont utilisés avec typeof, donc ceux-ci sont difficiles à couvrir avec une vérification comme celle-ci.

Si vous voulez savoir si quelque chose est un objet "simple", c'est-à-dire qu'il a été créé en tant que 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 : Parce que Symbol.toStringTagpermet désormais de personnaliser la sortie de Object.prototype.toString.call(...), la isPlainObjectfonction ci-dessus peut revenir falsedans certains cas même lorsque l'objet a commencé sa vie en tant que littéral. Sans doute, par convention, un objet avec une balise de chaîne personnalisée n'est plus exactement un objet ordinaire, mais cela a encore brouillé la définition de ce qu'est même un objet ordinaire en Javascript.

Mon Dieu, trop de confusion dans les autres réponses.

Réponse courte

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

Pour tester cela, exécutez simplement les instructions suivantes dans la console Chrome.

Cas 1.

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

Cas 2.

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

Cas 3.

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

Explication

D'accord, décomposons

typeof anyVar == 'object'est retourné vrai de trois candidats - [], {} and null,

anyVar instanceof Object réduit ces candidats à deux - [], {}

!(anyVar instanceof Array) se réduit à un seul - {}

Rouleaux de tambour s'il vous plaît!

Par cela, vous avez peut-être déjà appris à vérifier Array en Javascript.

La façon la plus raisonnable de vérifier le type d'une valeur semble être l' typeofopérateur. Le seul problème est qu'il est horriblement cassé:

• Il renvoie "object"pour null, qui appartient au type Null.
• Il renvoie "function"pour les objets appelables, qui appartiennent au type d'objet.
• Il peut retourner (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"les types primitifs.

typeofn'est fiable que pour les non nullprimitifs. Ainsi, un moyen de vérifier si une valeur est un objet serait de s'assurer que la chaîne retournée par typeofne correspond pas à une primitive, et que l'objet ne l'est pas null. Cependant, le problème est qu'une future norme pourrait introduire un nouveau type primitif, et notre code le considérerait comme un objet. Les nouveaux types n'apparaissent pas fréquemment, mais par exemple ECMAScript 6 a introduit le type Symbol.

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

Liste complète mais non exhaustive des moyens appropriés pour tester si une valeur appartient au type d'objet.

• Object constructeur

  Le Objectconstructeur 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 avec 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 que cela repose sur le fait que le monde Objectn'est pas masqué ni modifié.

• Constructeurs

  Lorsque vous instanciez un constructeur, il peut renvoyer une valeur différente de l'instance qui vient d'être créée. 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 s'est produite, mais les trydéclarations n'existaient pas à l'époque.

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

  Bien qu'un peu moins simple que l'exemple précédent, celui-ci ne repose sur aucune propriété globale, et peut donc être le plus sûr.

• this valeur

  Les anciennes spécifications ECMAScript exigeaient que la thisvaleur soit un objet. ECMAScript 3 introduit Function.prototype.call, qui permettait d'appeler une fonction avec une thisvaleur arbitraire , mais contrainte à un objet.

  ECMAScript 5 a introduit un mode strict qui a supprimé ce comportement, mais en mode bâclé, nous pouvons toujours (mais sans doute pas) y compter.

  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é.

  Les deux Object.createet Object.getPrototypeOfnécessitent 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 nouveaux modes ECMAScript 6

  ECMAScript 6 introduit de nouvelles façons indirectes de vérifier si une valeur est un objet. Ils utilisent l'approche vue précédemment pour transmettre la valeur à un code qui nécessite un objet, enveloppé dans une tryinstruction pour détecter les erreurs. Quelques exemples cachés, qui ne valent pas la peine d'être commentés

  Afficher l'extrait de code

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

  Exécuter l'extrait de codeMasquer les résultats

  Développer l'extrait

  Afficher l'extrait de code

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

  Exécuter l'extrait de codeMasquer les résultats

  Développer l'extrait

Remarque: J'ai intentionnellement ignoré certaines approches comme Object.getPrototypeOf(value)(ES5) et les Reflectméthodes (ES6) car elles appellent des méthodes internes essentielles qui pourraient faire des choses désagréables, par exemple si valuec'est un proxy. Pour des raisons de sécurité, mes exemples ne font référence que valuesans y accéder directement.

Essaye ça

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

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, Dateet functions sont tous les objets. Bien, nullest un peu artificiel. Donc, il vaut mieux vérifier le nullpremier, pour détecter qu'il n'est pas nul.

• Vérification des typeof o === 'object'garanties qui osont un objet. Sans cette vérification, cela Object.prototype.toStringn'aurait aucun sens, car il retournerait un objet pour tout, même pour undefinedet null! Par exemple: toString(undefined)retourne [object Undefined]!

  Après typeof o === 'object'vérification, toString.call (o) est une bonne méthode pour vérifier si oun objet, un objet dérivé comme Array, Dateou function.

• En isDerivedObjectfonction, il vérifie si oest une fonction. Parce que fonctionner aussi un objet, c'est pourquoi il est là. Si ce n'est pas le cas, la fonction retournera false. Exemple: isDerivedObject(function() {})retournerait false, mais maintenant il revient true.

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

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

Si vous souhaitez vérifier si le prototypepour objectprovient uniquement de Object. Filtres à String, Number, Array, Arguments, etc.

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

Ou comme une fonction de flèche à expression unique (ES6 +)

const isObject = n => Object.prototype.toString.call(n) === '[object Object]'

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. La façon la plus claire et compréhensible de vérifier si notre variable est un objet l'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' instanceofopérateur. Il éliminera null, mais Array a un objet dans la chaîne d'héritage.

La solution est donc:

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

Un peu tard ... 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 renverra "true" uniquement si le type de "o" est "object", mais pas de null, ni de tableau, ni de fonction. :)

lodash a isPlainObject , qui pourrait être ce que beaucoup de personnes qui visitent cette page recherchent. Elle retourne false lorsqu'elle donne une fonction ou un tableau.

Cela fonctionnera. Il s'agit d'une fonction qui renvoie vrai, faux ou éventuellement nul.

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

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

Test des primitives: undefined null boolean string number

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 n'importe quelle baie:

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['BigInt64Array']=true;
    arrayTypes['BigUint64Array']=true;
    arrayTypes['Float32Array']=true;
    arrayTypes['Float64Array']=true;
    return function(o){
        if (!o) return false;
        return !isPrimitive(o)&&!!arrayTypes[o.constructor.name];
    }
}());

Test d'objet à l'exclusion de: Date RegExp Boolean Number String Functiontout tableau

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

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

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

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

Paraphraser la fonction complète :

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 la documentation Ramda :

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"

Après avoir lu et essayer beaucoup d'implémentations, j'ai remarqué que très peu de gens essaient de vérifier les valeurs comme JSON, Math, documentou des objets avec des chaînes prototypes plus de 1 étape.

Au lieu de vérifier la typeofvariable de notre variable et de pirater ensuite les cas de bord, j'ai pensé qu'il serait préférable que la vérification soit aussi simple que possible pour éviter d'avoir à refactoriser quand de nouvelles primitives ou objets natifs ont été ajoutés qui s'inscrivent comme typeof`` objet '.

Après tout, l' typeofopérateur vous dira si quelque chose est un objet pour JavaScript , mais la définition JavaScript d'un objet est trop large pour la plupart des scénarios du monde réel (par exemple typeof null === 'object'). Vous trouverez ci-dessous une fonction qui détermine si la variable vest un objet en répétant essentiellement deux vérifications:

1. Une boucle est démarrée qui se poursuit tant que la version chaîne de vest '[object Object]'.
   Je voulais que le résultat de la fonction soit exactement comme les journaux ci-dessous, c'est donc le seul critère "d'objectivité" avec lequel je me suis retrouvé. En cas d'échec, la fonction renvoie immédiatement false.
2. vest remplacé par le prochain prototype de la chaîne avec v = Object.getPrototypeOf(v), mais aussi directement évalué après. Lorsque la nouvelle valeur de vest null, cela signifie que chaque prototype, y compris le prototype racine (qui pourrait très bien être le seul prototype à l'intérieur de la chaîne) a passé la vérification dans la boucle while et nous pouvons retourner vrai. Sinon, une nouvelle itération commence.

function isObj (v) {
  while (     Object.prototype.toString.call(v) === '[object Object]')
  if    ((v = Object.getPrototypeOf(v))         === null)
  return true
  return false
}

console.log('FALSE:')
console.log('[]                   -> ', isObj([]))
console.log('null                 -> ', isObj(null))
console.log('document             -> ', isObj(document))
console.log('JSON                 -> ', isObj(JSON))
console.log('function             -> ', isObj(function () {}))
console.log('new Date()           -> ', isObj(new Date()))
console.log('RegExp               -> ', isObj(/./))

console.log('TRUE:')
console.log('{}                   -> ', isObj({}))
console.log('new Object()         -> ', isObj(new Object()))
console.log('new Object(null)     -> ', isObj(new Object(null)))
console.log('new Object({})       -> ', isObj(new Object({foo: 'bar'})))
console.log('Object.prototype     -> ', isObj(Object.prototype))
console.log('Object.create(null)  -> ', isObj(Object.create(null)))
console.log('Object.create({})    -> ', isObj(Object.create({foo: 'bar'})))
console.log('deep inheritance     -> ', isObj(Object.create(Object.create({foo: 'bar'}))))

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

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

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

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

!!objest un raccourci pour vérifier si elle objest véridique (pour filtrer null)

C'est une vieille question mais j'ai pensé laisser ça ici. La plupart des gens vérifient si la variable {}signifie une paire valeur / clé et non quelle est la construction de soulignement que JavaScript utilise pour une chose donnée, car pour être honnête, la plupart des éléments de JavaScript sont un objet. Donc, retirez cela du chemin. Si tu fais...

let x = function() {}
typeof x === 'function' //true
x === Object(x) // true
x = []
x === Object(x) // true

// also
x = null
typeof null // 'object'

La plupart du temps, ce que nous voulons, c'est savoir si nous avons un objet ressource d'une API ou notre appel de base de données renvoyé par l'ORM. On peut alors tester si ce n'est pas un Array, n'est pas null, n'est pas typeof 'function', et est unObject

// To account also for new Date() as @toddmo pointed out

x instanceof Object && x.constructor === Object

x = 'test' // false
x = 3 // false
x = 45.6 // false
x = undefiend // false
x = 'undefiend' // false
x = null // false
x = function(){} // false
x = [1, 2] // false
x = new Date() // false
x = {} // true

Ce que j'aime utiliser c'est ceci

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 passer le contrôle en tant qu'objet, donc je ne filtre pas les dates

j'ai trouvé une "nouvelle" façon de faire juste ce genre de vérification de type à partir de cette question SO: Pourquoi instanceof retourne faux 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 simplement 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

edit:
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 de inanc: défi accepté: D

si vous voulez perdre des objets de comparaison, vous pouvez essayer de cette façon:

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