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

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

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

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

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

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

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

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

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

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

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

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

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

angular.isObject(...)

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

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

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

var isArray=function(value){
    if(Array.isArray){
        return Array.isArray(value);
    }else{
        return Object.prototype.toString.call(value)==='[object Array]';
    }
}
var isObject=function(value){
    return value !== null&&!isArray(value) && typeof value === 'object';
}

var _val=new Date;
console.log(isObject(_val));//true
console.log(Object.prototype.toString.call(_val)==='[object Object]');//false

У меня есть фрагмент кода, который работает. Я нахожу это странным, когда весь фрагмент кода не указан, поэтому я просто создал его сам:

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

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

Поскольку кажется, что существует много путаницы в отношении правильного решения этой проблемы, я оставлю свои 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['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];
    }
}());

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

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

Хорошо, давайте сначала дадим вам эту концепцию, прежде чем ответить на ваш вопрос, в JavaScript Функции - это Object, также null, Object, Arrays и даже Date, так что, как вы видите, не такой простой способ, как 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:

angular.isObject(obj);

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

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

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

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

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

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

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

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

• Object.prototype
• все происходит от Object.prototype
  • Function.prototype
    • Object
    • Function
    • function C(){} - пользовательские функции
    • C.prototype - свойство прототипа пользовательской функции: это , а не C прототип
      • new C() - «новая» - определяемая пользователем функция
      • Math
      • Array.prototype
        • arrays
        • {"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({})
      

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

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

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

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

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

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

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 для пользовательских объектов, например, новую дату или новый 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

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

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

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
}

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

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

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(...), приведенная выше функция 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' и получим значение true из трех кандидатов - [], {} and null,

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

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

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

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

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

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 и function - все объекты. Хотя 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(){})
);

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

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

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

Объяснил

Типы возвращаемых данных

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

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

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

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

1. цикл А запускается, который продолжается, пока stringified версия v '[object Object]'.
   я хотел, чтобы результат функции точно был похож на журналы ниже, таким образом, это - единственная "объектность" - критерии, я закончил с. Если это перестало работать, функция возвращает false сразу же.
2. v заменен следующим прототипом в цепочке с [1 112], но также и непосредственно оценен после. Когда новое значение [1 113] null, это означает, что каждый прототип включая корневой прототип (который, возможно, очень хорошо был только [1 127] прототип в цепочке) передали регистрацию цикла с условием продолжения, и мы можем возвратить 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'}))))