О мой Бог! Я думаю, это могло бы быть короче, чем когда-либо, давайте посмотрим на это:

Краткий и окончательный код

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

Объяснил

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

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

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

Примечание. По состоянию на 2018 год Function.name может не работать в IE https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#Browser_compatibility < / а>

Хорошо, давайте сначала дадим вам эту концепцию, прежде чем отвечать на ваш вопрос, в функциях JavaScript являются Object, а также null, Object, Arrays и даже Date, поэтому, как вы видите, нет простого способа, такого как typeof obj = == 'object', поэтому все вышеупомянутое вернет истину, но есть способы проверить это, написав функцию или используя фреймворки 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';
}

or

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

or

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

or

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

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

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

Он исключает примитивы (простые числа / _2 _ / _ 3_, простые строки, символы, _4 _ / _ 5_, undefined и null), но должен возвращать истину для всего остального (включая объекты 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(...), isPlainObject функция может возвращать false в некоторых случаях, даже когда объект начал свою жизнь как литерал. Возможно, по соглашению объект с настраиваемым строковым тегом уже не совсем простой объект, но это еще больше запутало определение того, что такое простой объект даже в Javascript.

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

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

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

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

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

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

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

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

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

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

Поэтому вместо 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, не обращаясь к нему напрямую.

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

function isPlainObject(o) {
   return (o === null || Array.isArray(o) || typeof o == 'function' || o.constructor === Date ) ?
           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, массив или функция. :)

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

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

Попробуй это

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

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

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

Или как функция стрелки с одним выражением (ES6 +)

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

Вот ответ с необязательной цепочкой и, возможно, самой маленькой isObj функцией для этого вопроса.

const isObj = o => o?.constructor === Object;

// True for this
console.log(isObj({}));        // object!

// False for these
console.log(isObj(0));         // number
console.log(isObj([]));        // array
console.log(isObj('lol'));     // string
console.log(isObj(null));      // null
console.log(isObj(undefined)); // undefined
console.log(isObj(() => {}));  // function
console.log(isObj(Object));    // class

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, но у Array есть Object в цепочке наследования.

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

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

lodash имеет 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

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

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

Тестирование примитивов: undefined null boolean string number

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

Тестирование на предмет исключая: Date RegExp Boolean Number String Function любой массив

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

Прочитав и опробовав множество реализаций, я заметил, что очень немногие люди пытаются проверять такие значения, как JSON, Math, document или объекты с цепочками прототипов длиннее 1 шага.

Вместо того, чтобы проверять typeof нашей переменной и затем избавляться от крайних случаев, я подумал, что было бы лучше, если бы проверка была как можно более простой, чтобы избежать необходимости рефакторинга, когда добавляются новые примитивы или собственные объекты, которые регистрируются как typeof из 'объект'.

В конце концов, оператор typeof сообщит вам, является ли что-то объектом JavaScript, но определение объекта в JavaScript слишком широко для большинства реальных сценариев (например, typeof null === 'object'). Ниже приведена функция, которая определяет, является ли переменная v объектом, путем повторения двух проверок:

1. Запускается цикл, который продолжается до тех пор, пока строковая версия v равна '[object Object]'.
   Я хотел, чтобы результат функции был точно таким же, как в журналах ниже, так что это единственный критерий "объектности", с которым я столкнулся. . В случае неудачи функция сразу же возвращает false.
2. v заменяется следующим прототипом в цепочке с v = Object.getPrototypeOf(v), но также оценивается непосредственно после него. Когда новое значение v равно null, это означает, что каждый прототип, включая корневой прототип (который вполне мог быть единственным прототипом внутри цепочки) прошел проверку. в цикле while, и мы можем вернуть true. В противном случае начинается новая итерация.

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

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

Вариант ES6:

const checkType = o => Object.prototype
                    .toString
                    .call(o)
                    .replace(/\[|object\s|\]/g, '')
                    .toLowerCase();

Вариант ES5:

function checkType(o){
   return Object.prototype
                    .toString
                    .call(o)
                    .replace(/\[|object\s|\]/g, '')
                    .toLowerCase();
}

Вы можете использовать это очень просто:

checkType([]) === 'array'; // true
checkType({}) === 'object'; // true
checkType(1) === 'number'; // true
checkType('') === 'string'; // true
checkType({}.p) === 'undefined'; // true
checkType(null) === 'null'; // true

и так далее..

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

!!obj - это сокращение для проверки правдивости obj (чтобы отфильтровать null)

Это старый вопрос, но я решил оставить его здесь. Большинство людей проверяют, является ли переменная {}, что означает пару "ключ-значение", а не то, что является подчеркиванием конструкции, которую JavaScript использует для данной вещи, потому что, честно говоря, в JavaScript в основном все является объектом. Так что убираем это с дороги. Если да ...

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

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

В большинстве случаев нам нужно знать, есть ли у нас объект ресурса из API или вызов нашей базы данных, возвращенный из ORM. Затем мы можем проверить, не является ли он Array, не null, не является ли он типом 'function' и является ли Object

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

Представление

Сегодня, 2020.09.26, я провожу тесты на MacOs HighSierra 10.13.6 на Chrome v85, Safari v13.1.2 и Firefox v80 для выбранных решений.

Полученные результаты

• решения C и H быстрые / самые быстрые во всех браузерах для всех случаев
• решения D и G медленные / самые медленные во всех браузерах во всех случаях

Подробности

Я выполняю 3 тестовых примера для решений A B C D E F G H I J K L M N O P Q R S T U V

• для небольшого объекта - вы можете запустить его ЗДЕСЬ
• для большого объекта - вы можете запустить его ЗДЕСЬ
• без объекта - вы можете запустить его ЗДЕСЬ

Во фрагменте ниже представлены различия между решениями. Решения A – G дают правильные ответы для выбранных случаев, описанных Мэттом Фенвиком

// https://stackoverflow.com/a/14706877/860099
function A(x) {
  return x === Object(x);
};

// https://stackoverflow.com/a/42250981/860099
function B(x) {
    return _.isObject(x);
}

// https://stackoverflow.com/a/34864175/860099
function C(x) {
    return x != null && (typeof x === 'object' || typeof x === 'function');
}

// https://stackoverflow.com/a/39187058/860099
function D(x) { 
  return new function() { return x; }() === x;
}

// https://stackoverflow.com/a/39187058/860099
function E(x) { 
  return function() { return this === x; }.call(x);
}

// https://stackoverflow.com/a/39187058/860099
function F(x) { /* Requires ECMAScript 5 or later */
  try {
    Object.create(x);
    return x !== null;
  } catch(err) {
    return false;
  }
}

// https://stackoverflow.com/a/39187058/860099
function G(x) { /* Requires ECMAScript 5 or later */
  function Constructor() {}
  Constructor.prototype = x;
  return Object.getPrototypeOf(new Constructor()) === x;
}

// https://stackoverflow.com/a/8511332/860099
function H(x) {
  return typeof x === 'object' && x !== null
}

// https://stackoverflow.com/a/25715455/860099
function I(x) {
  return (typeof x === "object" && !Array.isArray(x) && x !== null);
};

// https://stackoverflow.com/a/22482737/860099
function J(x) {
  return x instanceof Object; 
}

// https://stackoverflow.com/a/50712057/860099
function K(x)
{
    let t= JSON.stringify(x);
    return t ? t[0] === '{' : false;
}

// https://stackoverflow.com/a/13356338/860099
function L(x) {
  return Object.prototype.toString.call(x) === "[object Object]";
};



// https://stackoverflow.com/a/46663081/860099
function M(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;
}

// https://stackoverflow.com/a/42250981/860099
function N(x) {
    return $.type(x) === 'object';
}

// https://stackoverflow.com/a/34864175/860099
function O(x) {
    if (Object.prototype.toString.call(x) !== '[object Object]') {
        return false;
    } else {
        var prototype = Object.getPrototypeOf(x);
        return prototype === null || prototype === Object.prototype;
    }
}

// https://stackoverflow.com/a/57863169/860099
function P(x) {
  while (     Object.prototype.toString.call(x) === '[object Object]')
  if    ((x = Object.getPrototypeOf(x))         === null)
  return true
  return false
}

// https://stackoverflow.com/a/43289971/860099
function Q(x){
  try{
    switch(x.constructor){
      case Number:
      case Function:
      case Boolean:
      case Symbol:
      case Date:
      case String:
      case RegExp:
        return x.constructor === Object;
      case Error:
      case EvalError:
      case RangeError:
      case ReferenceError:
      case SyntaxError:
      case TypeError:
      case URIError:
        return (Object === Error ? Error : x.constructor) === Object;
      case Array:
      case Int8Array:
      case Uint8Array:
      case Uint8ClampedArray:
      case Int16Array:
      case Uint16Array:
      case Int32Array:
      case Uint32Array:
      case Float32Array:
      case Float64Array:
        return (Object === Array ? Array : x.constructor) === Object;
      case Object:
      default:
        return (Object === Object ? Object : x.constructor) === Object;
    }
  } catch(ex){
    return x == Object;   
  }
}

// https://stackoverflow.com/a/52478680/860099
function R(x) {
    return typeof x == 'object' && x instanceof Object && !(x instanceof Array);
}

// https://stackoverflow.com/a/51458052/860099
function S(x)
{
    return x != null && x.constructor?.name === "Object"
}

// https://stackoverflow.com/a/42250981/860099
function T(x) {
    return x?.constructor?.toString().indexOf("Object") > -1;
}

// https://stackoverflow.com/a/43223661/860099
function U(x)
{
    return x?.constructor === Object;
}

// https://stackoverflow.com/a/46663081/860099
function V(x) {
  return x instanceof Object && x.constructor === Object;
}




// -------------
// TEST
// -------------

console.log('column: 1 2 3 4 5 6 - 7 8 9 10 11');

[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V]
.map(f=> console.log(`${f.name}:      ${1*f(new Date())} ${1*f(/./)} ${1*f({})} ${1*f(Object.prototype)} ${1*f(Object.create(null))} ${1*f(()=>{})} - ${1*f("abc")} ${1*f(3)} ${1*f(true)}  ${1*f(null)}  ${1*f(undefined)}`))

console.log(`
Columns legend (test cases):
 1: new Date()
 2: /./ (RegExp)
 3: {}
 4: Object.prototype
 5: Object.create(null)
 6: ()=>{} (function)
 7: "abc" (string)
 8: 3 (number)
 9: true (boolean)
10: null
11: undefined

Rows:
1 = is object
0 = is NOT object

Theoretically columns 1-6 should have have 1, columns 7-11 shoud have 0
`);

<script
  src="https://code.jquery.com/jquery-3.5.1.min.js"
  integrity="sha256-9/aliU8dGd2tb6OSsuzixeV4y/faTqgFtohetphbbj0="
  crossorigin="anonymous"></script>
  
<script 
  src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.20/lodash.min.js" 
  integrity="sha512-90vH1Z83AJY9DmlWa8WkjkV79yfS2n2Oxhsi2dZbIv0nC4E6m5AbH8Nh156kkM7JePmqD6tcZsfad1ueoaovww==" 
  crossorigin="anonymous"></script>
  
This shippet only presents functions used in performance tests - it not perform tests itself!

А вот примеры результатов для хрома

Если вы явно хотите проверить, является ли данное значение {}.

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

function isObjectLike(value) {
  return value != null && typeof value == 'object' && !Array.isArray(value);
}

На основе lodash

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

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

or

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

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

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

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

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

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

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

angular.isObject(...)

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

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

Следовательно, следующий код, к удивлению большинства разработчиков, выводит в консоль «истину» (а не ложь):

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

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

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

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

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

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

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

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

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

Самый простой способ определить, является ли переменная Объектом или нет:

сначала: оцените тип объекта

второй: получение свойства массива из объекта должно возвращать undefined (например, length - это свойство массива, которое не работает с объектом)

so:

if (_object instanceof Object && _object.length === undefined) {
// here you can be sure that you have a curly bracket 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>

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

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

Это сложно, потому что массив является типом объекта, функция - типом объекта, а фактический объект {} также является типом объекта.

Проблема

const arr = []
const fun = function(){}
const actualObj = {}

arr instanceof Object // true
fun instanceof Object // true
actualObj instanceof Object // true

Итак, цель актуальна: Obj должен возвращать истину, а все остальное - ложь.

actualObj instanceof Object && !(actualObj instanceof Array) && !(typeof actualObj === 'function') // true

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

для массива: Array.isArray(inp) или [] isinstanceof Array

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

простая функция 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]))
  }
}

Помните, ребята, что typeof new Date() это "object".

Поэтому, если вы ищете { key: value } объектов, объект даты недействителен.

Наконец, на мой взгляд, o => o && typeof o === 'object' && !(o instanceof Date) - лучший ответ на ваш вопрос.

Небольшой консольный эксперимент NodeJS, основанный на прочтении третьего варианта Мэтта Фенвика к его полному ответу выше. Просто небольшая настройка, чтобы получить true или false.

Следующее возвращает false для объекта test.

> if(Object.getPrototypeOf('v') === Object.prototype){console.log(true);}else{console.log(false);}
false
undefined
> if(Object.getPrototypeOf(1) === Object.prototype){console.log(true);}else{console.log(false);}
false
undefined
> if(Object.getPrototypeOf(false) === Object.prototype){console.log(true);}else{console.log(false);}
false
undefined
> if(Object.getPrototypeOf(['apple']) === Object.prototype){console.log(true);}else{console.log(false);}
false
undefined

Объект вернет истину.

> if(Object.getPrototypeOf({'this':10}) === Object.prototype){console.log(true);}else{console.log(false);}
true
undefined

прямой ответ, конечно, typeof v==='object', но это ужасно бесполезно. Интересно, имел ли OP в виду простой словарь ..

пытаться:

isdict(v) { return  v !== undefined && v!==null && typeof v==='object' && v.constructor!==Array && v.constructor!==Date; }

Это легко сделать с помощью метода toString () класса Object.prototype.

if(Object.prototype.toString.call(variable) == "[object Object]"){
   doSomething();
}

or

if(Object.prototype.toString.call(variable).slice(8,-1).toLowerCase() == "object"){
   doSomething();
}

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

    <!DOCTYPE html>
    <html>
    <body>
    <button onclick="myFunc()">Try it</button>

    <script>
    var abc = new Number();
    // var abc = 4;
    //this is a code variation which will give a diff alert

    function myFunc()
    {
    if(abc && typeof abc === "object")
    alert('abc is an object and does not return null value');
    else
    alert('abc is not an object');
    }
    </script>

    </body>
    </html>