Проверьте, является ли значение объектом в JavaScript

Как проверить, является ли значение объектом в JavaScript?

30 ответов


попробуйте использовать typeof(var) и/или var instanceof something.

EDIT: этот ответ дает представление о том, как исследовать свойства переменной, но это не пуленепробиваемый рецепт (в конце концов, нет никакого рецепта вообще!) для проверки, является ли это объектом, далеко от него. Поскольку люди, как правило, ищут что-то, чтобы скопировать отсюда, не проводя никаких исследований, я настоятельно рекомендую им обратиться к другому, наиболее популярному (и правильному!) ответ.


Если typeof yourVariable === 'object', Это объект или null. Если вы хотите исключить null, просто сделайте это yourVariable !== null && typeof yourVariable === 'object'.


давайте определим "объект" в Javascript. Согласно MDN docs, каждое значение является либо объектом, либо примитивом:

первобытное, примитивное значение

данные, которые не являются объектом и не имеют никаких методов. JavaScript имеет 5 примитивных типов данных: string, number, boolean, null, undefined.

что примитивно?

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

что такое объект (т. е. не примитивный)?

  • Object.prototype
  • все произошли от Object.prototype
    • Function.prototype
      • Object
      • Function
      • function C(){} -- пользовательские функции
    • C.prototype -- свойство прототипа определяемой пользователем функции: это не Cпрототип s
      • new C() -- " new " -ing пользовательская функция
    • Math
    • Array.prototype
      • массивы
    • {"a": 1, "b": 2} -- объекты, созданные с использованием буквенных обозначений
    • new Number(3) -- фантики вокруг примитивы!--49-->
    • ... многое другое ...
  • Object.create(null)
  • все произошло от Object.create(null)

Как проверить, является ли значение объекта

instanceof сам по себе не будет работать, потому что он пропускает два случая:

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

typeof x === 'object' не будет работать, из-за ложных срабатываний (null) и ложноотрицательных результатов (функции):

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

Object.prototype.toString.call не будет работать, из-за ложных срабатываний для всех примитивов:

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

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

я:

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

ответ@Daan также, кажется, работает:

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

потому что, согласно MDN docs:

конструктор объекта создает оболочку объекта для заданного значения. Если значение равно null или undefined, оно создаст и вернет пустой объект, в противном случае он вернет объект типа, соответствующего заданному значению. Если значение уже является объектом,оно возвращает значение.


третий способ, который, кажется, работает (не уверен, что это 100%), - использовать Object.getPrototypeOf, который исключение если его аргумент не является объектом:

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

чиновник подчеркивания.js использует эту проверку, чтобы узнать, действительно ли что-то является объектом

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

Object.prototype.toString.call(myVar) вернутся:

  • "[object Object]" если myVar является объектом
  • "[object Array]" Если myVar является массивом
  • etc.

для получения дополнительной информации об этом и почему это хорошая альтернатива typeof, прочитать статью.


Я люблю просто:

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

если элемент является объектом JS, и это не массив JS, и это не null...если все три окажутся верными, верните true. Если какое-либо из трех условий не выполняется,&& тест будет короткое замыкание и false будут возвращены. The


для просто проверки против объекта или массива без дополнительного вызова функции (скорости). Как и написал здесь.

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() - Примечание: используйте только для объектных литералов, так как он возвращает false для пользовательских объектов, таких как new Date или 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

С функцией Array.isArray:

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

без функции Array.isArray:

просто удивлен, сколько upvotes для неправильных ответов
только ответ 1 прошел мои тесты!!! Здесь я создал свою упрощенную версию:

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

Что касается меня, это ясно и просто, и просто работает! Вот мои тесты:

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

еще раз: не все ответы проходят эти тесты !!!


в случае, если вам нужно убедитесь, что объект экземпляр определенного класса вы должны проверить конструктор с вашим конкретным классом, например:

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

простой тест:

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

в результате у вас будет строгий и надежный код!


в случае, если вы не будете создавать такие функции, как isDate, isError, isRegExp и т. д. Вы можете рассмотреть возможность использования этих обобщенных функций:

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

оно не будет работать правильно для всех тестовых случаев, упомянутых ранее, но это достаточно хорошо для всех объектов (простых или построенных).


isObject не будет работать в случае Object.create(null) из-за внутренней реализации Object.create, который пояснил,здесь но вы можете использовать isObject в более сложной реализации:

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

уже создано пакет на npm v1 на основе этой реализации! И это работает для всех ранее описанных тестов!


хорошо, давайте сначала дадим вам эту концепцию, прежде чем отвечать на ваш вопрос, в JavaScript функции являются Object, также null, Object, Arrays и даже Date, так как вы видите, что есть не простой способ, такой как typeof obj === 'object', поэтому все, что упоминалось выше, будет возвращает true, но есть способы проверить его с помощью написания функции или с помощью JavaScript-фреймворков, OK:

теперь представьте, что у вас есть этот объект, который является реальным объектом (не null или function или массив):

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

Чистый JavaScript:

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

или

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

или

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

или

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

вы можете просто использовать одну из этих функций, как указано выше в вашем коде, вызвав их, и она вернет true, если это объект:

isObject(obj);

если вы используете фреймворк JavaScript, они обычно подготовили для вас такие функции, их немного:

в jQuery:

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

Угловое:

angular.isObject(obj);

подчеркивание и Lodash:

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

это зависит от того, что вы имеете в виду "объект". Если вы хотите все, что не является первобытное, то есть вещи, которые вы можете установить новые свойства, это должно сделать трюк:

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

он исключает примитивы (простые числа/NaN/Infinity, простые строки, символы,true/false, undefined и null), но должен вернуть true для всего остального (включая Number, Boolean и String объекты). Обратите внимание, что JS не определяет, что " хост" объекты, такие как window или console, следует вернуть при использовании typeof, поэтому их трудно покрыть таким чеком.

если вы хотите знать, является ли что-то" простым " объектом, т. е. оно было создано как литерал {} или Object.create(null), вы можете сделать это:

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

редактировать 2018: потому что Symbol.toStringTag теперь позволяет настроить вывод Object.prototype.toString.call(...), the isPlainObject функция выше может вернуть false в некоторых случаях даже когда объект начал свою жизнь в буквальном смысле. Возможно, по соглашению объект с пользовательским строковым тегом больше не является простым объектом, но это еще больше запутало определение того, что простой объект даже в Javascript.


наиболее разумным способом проверки типа значения кажется typeof оператора. Единственная проблема в том, что он ужасно сломан:

  • возвращает "object" на null, который принадлежит типу Null.
  • возвращает "function" для вызываемых объектов, которые принадлежат к типу объекта.
  • он может вернуть (почти) все, что он хочет для нестандартных не вызываемых объектов. Например, IE, казалось, нравится "unknown". Единственные Запрещенные результаты "function" и примитивные типы.

typeof надежно только для не -null примитивы. Таким образом, способ проверить, является ли значение объектом, будет гарантировать, что строка, возвращаемая typeof не соответствует примитиву, и что объект не null. Однако проблема в том, что будущий стандарт может ввести новый примитивный тип, и наш код будет рассматривать его как объект. Новые типы не появляются часто, но, например, ECMAScript 6 представил Тип символа.

таким образом, вместо typeof, Я рекомендую только подходы, результат которых зависит от того, является ли значение объектом или нет. Следующее намеревается быть

полный, но не исчерпывающий список правильных способов проверки, принадлежит ли значение типу объекта.

  • Object конструктор

    на Object конструктор согласовывает переданный аргумент с объектом. Если это уже объект, возвращается тот же объект.

    таким образом, вы можете использовать его для принуждения значения к объекту и строго сравнить этот объект с исходным значением.

    следующая функция требует ECMAScript 3, который представил ===:

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

    мне нравится этот подход, потому что он прост и самоописателен, и аналогичная проверка также будет работать для булевых, чисел и строк. Однако имейте в виду, что он полагается на global Object не тень не изменена.

  • конструкторы

    при создании экземпляра конструктора он может возвращать значение, отличное от только что созданного экземпляра. Но это значение будет игнорироваться, если это объект.

    для следующей функции требуется ECMAScript 3, который позволяет конструкторам возвращать не-объекты. Перед ECMAScript 3, который бросил ошибку, но try заявления не существует назад затем.

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

    хотя немного менее простой, чем предыдущий пример, этот не полагается на какое-либо глобальное свойство и, следовательно, может быть самым безопасным.

  • this стоимостью

    старые спецификации ECMAScript требовали this значение объекта. ECMAScript 3 введен Function.prototype.call, что позволило вызвать функцию с произвольным this значение, но принудительно к объекту.

    ECMAScript 5 введен строгий режим, который удалил это поведение, но в небрежном режиме мы все еще можем (но, возможно, не должны) полагаться на него.

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

    все обычные объекты имеют внутренний слот под названием [[Prototype]], значение которого определяет, от какого другого объекта он наследуется. Значение может быть только объектом или null. Таким образом можно попытаться создать объект, который наследует от нужного значения, и проверить, если это работал.

    и Object.create и Object.getPrototypeOf требуется 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;
    }
    
  • некоторые новые способы ECMAScript 6

    ECMAScript 6 вводит некоторые новые косвенные способы проверить, является ли значение объектом. Они используют ранее рассмотренный подход для передачи значения некоторому коду, который требует объекта, обернутого внутри try оператор для обнаружения ошибок. Некоторые скрытые примеры, не стоит комментируя

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

примечание: Я намеренно пропустил некоторые подходы, такие как Object.getPrototypeOf(value) (в ES5) и Reflect методы (ES6), потому что они называют существенные внутренние методы, которые могут делать неприятные вещи, например, если value - это прокси. По соображениям безопасности мои примеры только ссылка value без прямого доступа к нему.


попробуй такое

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

готов к использованию функций для проверки

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

объяснение

  • В Javascript,null, Object, Array, Date и functions-это все объекты. Хотя,null немного надумано. Итак, лучше проверить на null во-первых, обнаружить, что это не null.

  • проверка typeof o === 'object' гарантии o - это объект. Без этого чека,Object.prototype.toString было бы бессмысленно, так как это было бы возвращайте объект для everthing, даже для undefined и null! Например: toString(undefined) возвращает [object Undefined]!

    после typeof o === 'object' проверить, toString.call (o) - отличный способ проверить, является ли o - это объект, производный объект как Array, Date или function.

  • на isDerivedObject функция, она проверяет для o - это функция. Потому что, функция также объект, вот почему он есть. Если этого не сделать, функция вернет значение false. Образец: isDerivedObject(function() {}) вернутся false, однако теперь он возвращается true.

  • всегда можно изменить определение того, что является объектом. Таким образом, можно соответствующим образом изменить эти функции.


тесты

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

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

меня попросили предоставить более подробную информацию. Самый чистый и понятный способ проверить, является ли наша переменная объектом typeof myVar. Он возвращает строку с типом (например,"object", "undefined").

к сожалению, либо Array и null также имеют тип object. Брать только реальные объекты необходимо проверить цепочку наследования с помощью instanceof оператора. Он устранит null, но массив имеет объект в цепочке наследования.

такое решение есть:

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

поздновато... для "простых объектов" (я имею в виду, например, {'x': 5, 'y': 7}) у меня есть этот маленький фрагмент:

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

Он генерирует следующий вывод:

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

это всегда работает для меня. If вернет " true "только в том случае, если тип" o " - "object", но не null, или array, или function. :)


лодашь имеет isPlainObject, что может быть, что многие, кто приходит на эту страницу ищете. Он возвращает false, когда дает функцию или массив.


когда все остальное терпит неудачу, я использую этот:

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

Это будет работать. Это функция, которая возвращает true, false или, возможно, 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

Типы Возврата

typeof JavaScript конструкторы и объекты (в том числе null) возвращает "object"

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

проверка их конструкторов

проверка на их constructor свойство возвращает функцию с их именами.

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

Введение Функции.имя

Function.name возвращает имя функции только для чтения или "anonymous" для закрытия.

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

код

function isAnObject(obj)
{
    if(obj==null) return false;
    return obj.constructor.name.toLowerCase() === "object"
}

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

Примечание: функция.имя может не работать в IE https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#Browser_compatibility


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

на Ramda функциональная библиотека имеет замечательную функцию для обнаружения типов JavaScript.

перефразируя полная функция:

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

Я рассмеялся, когда понял, насколько простым и красивым было решение.

пример использования из 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"

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

!!obj является сокращением для проверки истинности объекта (для фильтрации null/undefined)


что мне нравится использовать это

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

Я думаю, что в большинстве случаев дата должна пройти проверку как объект, поэтому я не фильтрую даты


Я нашел "новый" способ сделать именно такую проверку типа из этого вопроса SO:почему instanceof возвращает false для некоторых литералов?

этого, я создал функцию для проверки типа следующим образом:

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

затем вы можете просто сделать:

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

это протестировано на Chrome 56, Firefox 52, Microsoft Edge 38, Internet Explorer 11, Opera 43

edit:
если вы также хотите проверить, если переменная null или undefined, вы можете использовать это вместо:

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

обновление из комментария inanc: вызов принят :D

если вы хотите потерять объекты сравнения, вы можете попробовать так:

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

таким образом, вы можете сделать так же, как комментарий inanc:

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

или

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

Боже мой, слишком много путаницы в другие ответы.

Короткий Ответ:

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

чтобы проверить это, просто запустите следующие инструкции в консоли chrome.

корпус 1.

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

корпус 2.

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

корпус 3.

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

объяснение

ОК.Давайте сломаем его

typeof anyVar == 'object' is вернули истину от трех кандидатов -[], {} and null,

anyVar instanceof Object сужает список кандидатов до двух -[], {}

!(anyVar instanceof Array) сужается только до одного - {}

барабанная дробь, пожалуйста!

возможно, вы уже научились проверять наличие массива в Javascript.


Если вы уже используете AngularJS, то у него есть встроенный метод, который проверит, является ли его объектом (без принятия null).

angular.isObject(...)

использовать typeof(my_obj) рассказывает, какой тип переменной.

если это объект покажет 'объект'

простая функция JS,

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

например:

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

Its зависит от варианта использования, если мы не хотим, чтобы массив и функции были объектом, мы можем использовать подчеркивание.встроенные функции в JS.

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

в основном typeof obj[index] === 'object'используется, но он также вернется function и #document, которые являются объектами. Это зависит от вас, если он должен быть включен в результат.

в основном вы можете сделать тестовый код, который отфильтровывает, если определенные элементы являются объектом, проверяя вывод в консоли. Здесь вы можете запустить код только для примера:

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>

если вы хотите проверить, если prototype на object исключительно исходит от Object. Отфильтровывает String, Number, Array, Arguments, etc.

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