If typeof yourVariable === 'object', It ' s a object or null. Jeśli chcesz wykluczyć null, po prostu zrób to yourVariable !== null && typeof yourVariable === 'object'.

Zdefiniujmy "obiekt" w Javascript . Według MDN docs , każda wartość jest albo obiektem, albo prymitywem:

Prymitywna, prymitywna wartość

Dane, które nie są obiektem i nie mają żadnych metod. JavaScript ma 5 prymitywnych typów danych: string, number, boolean, null, undefined.

Co to jest prymitywne?

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

Czym jest obiekt (tzn. nie prymitywny)?

• Object.prototype
• wszystko pochodzi z Object.prototype
  • Function.prototype
    • Object
    • Function
    • function C(){} -- funkcje zdefiniowane przez użytkownika
  • C.prototype -- właściwość prototypu funkcji zdefiniowanej przez użytkownika: to jest Nie Cs prototype
    • new C() -- " new " -ing funkcja zdefiniowana przez użytkownika
  • Math
  • Array.prototype
    • tablice
  • {"a": 1, "b": 2} -- obiekty tworzone przy użyciu notacji literalnej
  • new Number(3) -- owijki wokół prymitywów
  • ... Wiele innych rzeczy ...
• Object.create(null)
• wszystko pochodzi od Object.create(null)

Jak sprawdzić, czy wartość jest obiektem

instanceof przez sam nie zadziała, ponieważ pomija dwa przypadki:

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

typeof x === 'object' nie będzie działać, z powodu fałszywych pozytywów (null) i fałszywych negatywów (funkcje):

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

Object.prototype.toString.call nie będzie działać, z powodu fałszywych alarmów dla wszystkich prymitywów: {]}

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

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

Więc używam:

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

@Daan ' s answer also seems to work:

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

Ponieważ, zgodnie z MDN docs :

Konstruktor obiektu tworzy object wrapper dla podanego wartość. Jeśli wartość jest NULL lub undefined, wytworzy i zwróci pusty obiekt, w przeciwnym razie zwróci obiekt typu odpowiadającego podanej wartości. Jeśli wartość jest już obiektem, zwróci wartość.

Trzecim sposobem, który wydaje się działać (Nie wiem, czy to 100%) jest użycie Object.getPrototypeOf, które rzuca wyjątek jeśli jego argument nie jest obiektem:

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

Oficjalne podkreślenie.js używa tego czeku, aby dowiedzieć się, czy coś jest naprawdę obiektem

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

Object.prototype.toString.call(myVar) powróci:

• "[object Object]" jeśli myVar jest obiektem
• "[object Array]" jeśli myVar jest tablicą
• itd.

Aby uzyskać więcej informacji na ten temat i dlaczego jest to dobra alternatywa dla typeof, sprawdź ten artykuł .

Lubię po prostu:

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

Jeśli element jest obiektem JS i nie jest tablicą JS, i nie jest null...jeśli wszystkie trzy okazują się prawdziwe, zwróć true. Jeśli którykolwiek z trzech warunków nie powiedzie się, test && ulegnie zwarciu i false zostanie zwrócony. Test null można w razie potrzeby pominąć(w zależności od sposobu użycia 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

Do prostego sprawdzania przed obiektem lub tablicą bez dodatkowego wywołania funkcji (speed). Jak również zamieszczone tutaj .

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 () - Uwaga: używać tylko dla literałów obiektów, ponieważ zwraca false dla obiektów niestandardowych, takich jak new Date lub 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

Z funkcją Array.isArray:

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

BEZ funkcji Array.isArray:

Po prostu zaskoczony, ile głosów za błędnymi odpowiedziami
tylko 1 ODPOWIEDŹ zdałem testy!!! Tutaj stworzyłem swoją uproszczoną wersję:

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

Jeszcze raz: nie wszystkie odpowiedzi przechodzą te testy !!!

W przypadku, gdy musisz zweryfikować, że obiekt jest instancją konkretnej klasy masz aby sprawdzić konstruktor z konkretną klasą, jak:

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

Prosty test:

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

W rezultacie będziesz miał ścisły i solidny kod!

W przypadku, gdy nie utworzysz funkcji takich jak isDate, isError, isRegExp, etc można rozważyć użycie tej funkcji uogólnionej:

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

Nie będzie działać poprawnie we wszystkich przypadkach testowych wymienionych wcześniej, ale jest wystarczająco dobry dla wszystkich obiektów (zwykłych lub skonstruowanych).

isObject nie zadziała w przypadku Object.create(null) ze względu na wewnętrzną implementację Object.create, która jest wyjaśniona tutaj , ale możesz użyć isObject w bardziej wyrafinowanej implementacji:

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

Jest już stworzony pakiet na npm v1 oparty na tej implementacji! I to działa dla wszystkich wcześniej opisanych przypadków testowych!

Ok, dajmy ci tę koncepcję najpierw przed odpowiedzią na twoje pytanie, w JavaScript funkcje są obiekt, również null, obiekt, tablice, a nawet Data, więc jak widzisz, istnieje Nie prosty sposób jak typeof obj = = = 'obiekt', więc wszystko wymienione powyżej zwróci true, ale są sposoby, aby to sprawdzić pisząc funkcję lub używając JavaScript frameworków, OK:

Teraz wyobraź sobie, że masz ten obiekt, który jest obiektem rzeczywistym (nie null lub function lub tablica):

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

Czysty JavaScript:

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

Lub

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

Lub

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

Lub

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

Możesz po prostu użyć jednej z tych funkcji jak wyżej w kodzie, wywołując je i zwróci true, jeśli jest to obiekt:

isObject(obj);

Jeśli używasz frameworka JavaScript, zwykle przygotowują dla Ciebie tego rodzaju funkcje, jest ich kilka:

JQuery:

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

Kątowy:

angular.isObject(obj);

Podkreślenie i Lodash:

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

To zależy od tego, co masz na myśli mówiąc "jest przedmiotem". Jeśli chcesz wszystko, co nie jest prymitywne , czyli rzeczy, na których możesz ustawić nowe właściwości, powinno to załatwić sprawę:

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

Wyklucza primitives (liczby proste/NaN/Infinity, ciągi proste, symbole, true/false, undefined i null), ale powinien zwracać true dla wszystkiego innego (w tym Number, Boolean i String obiektów). Zauważ, że JS nie definiuje, jakie obiekty "host", takie jak window lub console, powinny zwracać gdy są używane z typeof, więc trudno je pokryć takim czekiem.

Jeśli chcesz wiedzieć, czy coś jest "zwykłym" obiektem, tzn. zostało utworzone jako literalne {} lub z Object.create(null), możesz to zrobić: {23]}

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 : ponieważ Symbol.toStringTag teraz pozwala dostosować wyjście Object.prototype.toString.call(...), funkcja isPlainObject powyżej może zwrócić false w niektórych przypadkach, nawet gdy obiekt rozpoczął życie jako literał. Zapewne przez Konwencję obiekt o niestandardowym string tag nie jest już dokładnie zwykłym obiektem, ale to jeszcze bardziej zmąciło definicję tego, czym jest zwykły obiekt w Javascript.

Najbardziej rozsądnym sposobem sprawdzenia typu wartości wydaje się operator typeof. Jedynym problemem jest to, że jest strasznie zepsuty:

• zwraca "object" dla null, który należy do typu Null.
• zwraca "function" dla obiektów, które należą do typu Object.
• może zwrócić (prawie) wszystko, czego chce dla niestandardowych obiektów, których nie można wywołać. Na przykład IE wydaje się lubić "unknown". Jedyne zakazane wyniki to "function" i prymitywne typy.

typeof jest wiarygodny tylko dla NIE - null prymitywów. Tak więc sposobem sprawdzenia, czy wartość jest obiektem, jest upewnienie się, że łańcuch zwracany przez typeof nie odpowiada prymitywowi, a obiekt nie jest null. Jednak problem polega na tym, że przyszły standard mógłby wprowadzić nowy prymitywny typ, a nasz kod uznałby go za obiekt. Nowe typy nie pojawiają się często, ale na przykład ECMAScript 6 wprowadził Typ symbolu.

Dlatego zamiast typeof, polecam tylko podejścia, których wynik różni się w zależności od tego, czy wartość jest obiektem, czy nie. Poniżej znajduje się

Obszerna, ale nie wyczerpująca lista właściwych sposobów sprawdzenia, czy wartość należy do typu obiektu.

• Object konstruktor

  Konstruktor Object wymusza przekazanie argumentu obiektowi. Jeśli jest już obiektem, zwracany jest ten sam obiekt.

  Dlatego możesz użyć go do wymuszenia wartości do obiektu i ściśle porównaj ten obiekt z oryginalną wartością.

  Następująca funkcja wymaga ECMAScript 3, który wprowadził ===:

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

  Podoba mi się to podejście, ponieważ jest proste i samoopisowe, a analogiczne sprawdzenie będzie również działać dla booleanów, liczb i łańcuchów. Jednak należy pamiętać, że opiera się ona na tym, że globalny {18]} nie jest cieniowany ani zmieniany.

• Konstruktorzy

  Kiedy tworzysz konstruktor, to może zwrócić wartość inną niż nowo utworzona instancja. Ale ta wartość będzie ignorowana, chyba że jest obiektem.

  Następująca funkcja wymaga ECMAScript 3, który pozwalał konstruktorom zwracać Nie-obiekty. Przed ECMAScript 3, który wyrzucił błąd, ale try instrukcje nie istniały wtedy.

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

  Choć nieco mniej prosty niż poprzedni przykład, ten nie opiera się na żadnej globalnej własności, a zatem może być najbezpieczniejszy.

• this wartość

  Stare specyfikacje ECMAScript wymagały, aby wartość this była obiektem. ECMAScript 3 wprowadził Function.prototype.call, który pozwalał na wywołanie funkcji o dowolnej wartości this, ale wymuszał na obiekcie.

  ECMAScript 5 wprowadził tryb ścisły, który usunął to zachowanie, ale w trybie niechlujnym nadal możemy (ale prawdopodobnie nie powinniśmy) na nim polegać.

  function isObject(value) { /* Requires ECMAScript 3 or later in sloppy mode */
    return function() { return this === value; }.call(value);
  }
  

• [[Prototype]]

  Wszystkie zwykłe obiekty mają wewnętrzną szczelinę zwaną [[Prototype]], którego wartość określa, od którego innego obiektu dziedziczy. Wartość może być tylko obiektem lub null. Dlatego możesz spróbować utworzyć obiekt, który dziedziczy po żądanej wartości i sprawdzić, czy zadziałał.

  Zarówno Object.create jak i Object.getPrototypeOf wymagają 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;
  }
  

• Niektóre nowe ECMAScript 6 sposobów

  ECMAScript 6 wprowadza kilka nowych pośrednich sposobów sprawdzania czy wartość jest obiektem. Korzystają z wcześniej widzianych podejście do przekazania wartości do jakiegoś kodu, który wymaga obiektu, zawiniętego wewnątrz instrukcji try, aby wychwycić błędy. Niektóre ukryte przykłady, nie warto komentować

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

Uwaga: celowo pominąłem niektóre podejścia, takie jak Object.getPrototypeOf(value) (ES5) i Reflect metody (ES6), ponieważ nazywają one niezbędne wewnętrzne metody, które mogą robić nieprzyjemne rzeczy, np. jeśli value jest proxy. Ze względów bezpieczeństwa moje przykłady tylko reference value bez bezpośredniego dostępu.

Spróbuj tego

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

Gotowe do użycia funkcje do sprawdzania

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

Wyjaśnienie

• W Javascript, null, Object, Array, Date i function S są obiektami. Chociaż, {[2] } jest nieco wymyślony. Więc lepiej najpierw sprawdzić null, aby wykryć, że nie jest null.

• Sprawdzanie typeof o === 'object' gwarantuje, że o jest obiektem. Bez tego czeku, Object.prototype.toString byłoby bez znaczenia, ponieważ zwracałoby obiekt dla everthing, nawet dla undefined i null! Na przykład: toString(undefined) zwraca [object Undefined]!

  Po typeof o === 'object' sprawdź, toString.call (o) jest świetną metodą sprawdzania, czy o jest obiektem pochodnym, takim jak Array, Date lub function.

• W funkcji isDerivedObject sprawdza, czy o jest funkcją. Ponieważ, funkcja również obiekt, dlatego jest tam. Jeśli tego nie zrobił, funkcja powróci jako false. Przykład: isDerivedObject(function() {}) zwróci false, jednak teraz zwraca true.

• Zawsze można zmienić definicję tego, co jest przedmiotem. Można więc odpowiednio zmienić te funkcje.

Testy

function isObject(o) {
  return null != o && 
    typeof o === 'object' && 
    Object.prototype.toString.call(o) === '[object Object]';
}

function isDerivedObject(o) {
  return !isObject(o) && 
    null != o && 
    (typeof o === 'object' || typeof o === 'function') &&
    /^\[object /.test(Object.prototype.toString.call(o));
}

// TESTS

// is null an object?

console.log(
  'is null an object?', isObject(null)
);

console.log(
  'is null a derived object?', isDerivedObject(null)
);

// is 1234 an object?

console.log(
  'is 1234 an object?', isObject(1234)
);

console.log(
  'is 1234 a derived object?', isDerivedObject(1234)
);

// is new Number(1234) an object?

console.log(
  'is new Number(1234) an object?', isObject(new Number(1234))
);

console.log(
  'is new Number(1234) a derived object?', isDerivedObject(1234)
);

// is function object an object?

console.log(
  'is (new (function (){})) an object?', 
  isObject((new (function (){})))
);

console.log(
  'is (new (function (){})) a derived object?', 
  isObject((new (function (){})))
);

// is {} an object?

console.log(
  'is {} an object?', isObject({})
);

console.log(
  'is {} a derived object?', isDerivedObject({})
);

// is Array an object?

console.log(
  'is Array an object?',
  isObject([])
)

console.log(
  'is Array a derived object?',
  isDerivedObject([])
)

// is Date an object?

console.log(
  'is Date an object?', isObject(new Date())
);

console.log(
  'is Date a derived object?', isDerivedObject(new Date())
);

// is function an object?

console.log(
  'is function an object?', isObject(function(){})
);

console.log(
  'is function a derived object?', isDerivedObject(function(){})
);

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

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

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

Niestety zarówno tablica jak i null również mają typ object. Aby pobierać tylko rzeczywiste obiekty, należy sprawdzić łańcuch dziedziczenia za pomocą operatora instanceof. Wyeliminuje null, ale tablica ma obiekt w łańcuchu dziedziczenia.

Więc rozwiązaniem jest:

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

Trochę późno... dla " zwykłych obiektów "(mam na myśli {'x': 5, 'y': 7}) mam taki mały fragment:

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

Generuje następne Wyjście:

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

Lodash posiada isPlainObject , którego może szukać wielu odwiedzających tę stronę. Zwraca false, gdy poda funkcję lub tablicę.

Kiedy wszystko inne zawodzi, używam tego:

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

To zadziała. Jest to funkcja, która zwraca true, false lub ewentualnie 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

Typy Zwrotne

Typ konstruktorów i obiektów JavaScript (w tym null) zwraca "object"

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

Sprawdzanie ich konstruktorów

Sprawdzanie ich właściwości constructor zwraca funkcję z ich nazwami.

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

Introducing Function.name

Function.name zwraca tylko do odczytu nazwę funkcji lub "anonymous" dla zamknięć.

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

Finał kod

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

Uwaga: Function.name może nie działać w IE https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#Browser_compatibility

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

Biblioteka funkcjonalna Ramda posiada wspaniałą funkcję do wykrywania typów JavaScript.

Parafrazując pełną funkcję :

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

Przykładowe użycie z Ramda dokumentacja :

R.type({}); //=> "Object"
R.type(1); //=> "Number"
R.type(false); //=> "Boolean"
R.type('s'); //=> "String"
R.type(null); //=> "Null"
R.type([]); //=> "Array"
R.type(/[A-z]/); //=> "RegExp"
R.type(() => {}); //=> "Function"
R.type(undefined); //=> "Undefined"

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

!!obj jest skrótem do sprawdzania, czy obiekt jest prawdziwy (aby odfiltrować null/undefined)

Lubię używać tego

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

Myślę, że w większości przypadków Data musi przejść kontrolę jako obiekt, więc nie filtruję dat

Znalazłem "nowy" sposób na tego rodzaju sprawdzanie typu z tego pytania: Dlaczego instanceof zwraca false dla niektórych liter?

Z tego utworzyłem funkcję do sprawdzania typu w następujący sposób:

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

Wtedy możesz po prostu zrobić:

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

Edit:
jeśli chcesz również sprawdzić, czy zmienna jest NULL lub undefined, możesz użyć tego zamiast:

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

Aktualizacja z komentarza inanc: wyzwanie przyjęte: d

Jeśli chcesz stracić obiekty porównawcze, możesz spróbować w ten sposób:

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

W ten sposób możesz zrobić tak jak w komentarzu:

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

Lub

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

Mój Boże, za dużo zamieszania w innych odpowiedziach.

Krótka Odpowiedź

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

Aby to przetestować, po prostu uruchom następujące instrukcje w konsoli chrome.

Przypadek 1.

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

Przypadek 2.

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

Przypadek 3.

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

Wyjaśnienie

typeof anyVar == 'object' zwraca true od trzech kandydatów - [], {} and null,

anyVar instanceof Object zawęża tych kandydatów do dwóch - [], {}

!(anyVar instanceof Array) zawęża się tylko do jednego - {}

Być może nauczyłeś się już sprawdzania tablic w Javascript.

Jeśli używasz już AngularJS, to ma wbudowaną metodę, która sprawdzi, czy jest obiektem (bez akceptacji null).

angular.isObject(...)

Użycie typeof(my_obj) powie, jakiego typu jest zmienna.

Jeśli jest to object pokaże 'object'

Prosta funkcja JS,

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

Eg:

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

Zależy od przypadku użycia, jeśli nie chcemy, aby tablica i funkcje były obiektem, możemy użyć podkreślnika.js wbudowane funkcje.

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

Najczęściej używane jest typeof obj[index] === 'object', ale zwróci również function i #document, które są obiektami. To zależy od ciebie, czy trzeba to uwzględnić w wyniku.

Zasadniczo możesz zrobić kod testowy, który filtruje, czy dany element jest obiektem, sprawdzając wyjście w konsoli. Tutaj możesz uruchomić kod tylko dla próbki:

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>

Jeśli chcesz sprawdzić, czy prototype dla object pochodzi wyłącznie z Object. Filtruje String, Number, Array, Arguments, itd.

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