it-swarm.com.ru

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

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

984
Danny Fox

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

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

396
Michael Krelin - hacker

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

1190
Chuck

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

примитивная, примитивная ценность 

Данные, которые не являются объектом и не имеют никаких методов. JavaScript имеет 5 примитивных типов данных: строка, число, логическое значение, ноль, неопределенный. 

Что такое примитив?

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

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

  • Object.prototype
  • все произошло от Object.prototype
    • Function.prototype
      • Object
      • Function
      • function C(){} - пользовательские функции
    • C.prototype - свойство prototype определенной пользователем функции: это notCs prototype
      • new C() - "new" -ing определяемая пользователем функция
    • Math
    • Array.prototype
      • массивы
    • {"a": 1, "b": 2} - объекты, созданные с использованием буквенной нотации
    • new Number(3) - обертки вокруг примитивов
    • ... много других вещей ...
  • 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') );
}

Ответ @ Даана также, кажется, работает:

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

потому что, согласно документам MDN :

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


Третий способ, который, кажется, работает (не уверен, что он равен 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({})
469
Matt Fenwick

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

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

ОБНОВЛЕНИЕ

обновленная библиотека underscore.js теперь использует следующее из-за предыдущей ошибки в V8 и незначительной оптимизации микро скорости. 

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

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

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

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

158
Christophe

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

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
80
zupa

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

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

Если элемент является объектом JS, и это не массив JS, и он не является null… если все три окажутся истинными, верните true. Если какое-либо из трех условий не выполнено, тест && замкнется и будет возвращено false. При желании тест null может быть опущен (в зависимости от того, как вы используете 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

70
jtheletter

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

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

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

Просто удивился, сколько голосов за неправильные ответы ????
Только 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! И это работает для всех ранее описанных тестовых случаев! ????

63
Vladimir Kovpak

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

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

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

Подчеркни и Лодаш:

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

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

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

Он исключает примитивы (обычные числа/NaNInfinity, простые строки, символы, true/false, undefined и null), но должен возвращать true для всего остального (включая объекты Number, Boolean и String). Обратите внимание, что JS не определяет, какие объекты «Host», такие как 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;
    }
}

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

21
last-child

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

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

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

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

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

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

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

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

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

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

    Мне нравится этот подход, потому что он прост и информативен, и аналогичная проверка также будет работать для логических значений, чисел и строк. Однако имейте в виду, что он полагается на то, что глобальный 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, не обращаясь к нему напрямую.

16
Oriol

Попробуй это

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

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

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

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' возвращается true от трех кандидатов - [], {} and null,

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

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

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

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

14
kushalvm

Готовы использовать функции для проверки

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, чтобы обнаружить, что он не нулевой.

  • Проверка на typeof o === 'object' гарантирует, что o является объектом. Без этой проверки Object.prototype.toString был бы бессмысленным, поскольку он возвращал бы объект навсегда, даже для 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(){})
);

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

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

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

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

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

Итак, решение таково:

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

Немного поздно ... для "простых объектов" (я имею в виду, например, {'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» равен «объект», но не имеет значения null, массива или функции. :)

10
Emilio Grisolía

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

тип конструкторов и объектов 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

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

Примечание: Function.name может не работать в Т.Е.https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name# Совместимость браузера

9
Erisan Olasheni

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

8
Pat

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

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

Это будет работать Это функция, которая возвращает истину, ложь или, возможно, ноль.

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

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

7
pizza-r0b

Функциональная библиотека 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"
6
DaveGauer

Поскольку кажется, что существует правильное решение этой проблемы, я оставлю свои 2 цента (этот ответ соответствует спецификациям и дает правильные результаты при любых обстоятельствах):

Тестирование на примитивы: undefinednullbooleanstringnumber

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

Объект не является примитивом:

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

Или в качестве альтернативы:

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

Тестирование для любого массива:

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

Тестирование объекта, исключая: 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];
    }
}());
6
c7x43t
if(typeof value === 'object' && value.constructor === Object)
{
    console.log("This is an object");
}
6
Mahak Choudhary
  var isObject = function(obj) {
    var type = typeof obj;
    return type === 'function' || type === 'object' && !!obj;
  };

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

5
Ira

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

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

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

4
JohnPan

я нашел «новый» способ сделать именно такую ​​проверку типов из этого 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

Правка:
Если вы также хотите проверить, является ли переменная нулевой или неопределенной, вы можете использовать это вместо:

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

обновление от комментария Инанка: вызов принят: 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
3
am05mhz

Если вы хотите проверить, действительно ли prototype для object происходит от Object. Отфильтровывает String, Number, Array, Arguments и т.д.

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

использование 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]))
  }
}

1
Mohideen ibn Mohammed

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

angular.isObject(...)
1
Robert

В основном используется 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>

1
Chetabahana

Это зависит от варианта использования. Если мы не хотим, чтобы массив и функции были объектами, мы можем использовать встроенные функции underscore.js. 

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

Рассмотрим - typeof bar === "object", чтобы определить, является ли bar объектом

Хотя typeof bar === "object" - это надежный способ проверки, является ли bar объектом, в коде JavaScript есть удивительное свойство: null также считается объектом!

Поэтому, к удивлению большинства разработчиков, следующий код записывает в консоль true (не false):

var bar = null;console.log(typeof bar === "object"); // logs true! Пока человек знает об этом, проблему можно легко избежать, также проверив, имеет ли строка ноль:

console.log((bar !== null) && (typeof bar === "object")); // logs false Чтобы быть полностью тщательным в нашем ответе, следует отметить еще две вещи:

Во-первых, приведенное выше решение вернет false, если bar является функцией. В большинстве случаев это желаемое поведение, но в ситуациях, когда вы также хотите вернуть true для функций, вы можете изменить приведенное выше решение так:

console.log((bar !== null) && ((typeof bar === "object") || (typeof bar === "function"))); Во-вторых, вышеприведенное решение вернет true, если bar является массивом (например, если var bar = [];). В большинстве случаев это желаемое поведение, так как массивы действительно являются объектами, но в ситуациях, когда вы также хотите использовать false для массивов, вы можете изменить приведенное выше решение так:

console.log((bar !== null) && (typeof bar === "object") && (toString.call(bar) !== "[object Array]")); Однако есть еще одна альтернатива, которая возвращает false для нулей, массивов и функций, но true для объектов:

console.log((bar !== null) && (bar.constructor === Object)); Или, если вы используете jQuery:

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

ES5 делает случай массива довольно простым, включая собственную проверку нуля:

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

1
Exception

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

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

0
GuaHsu