Argthtjtr

This should do it for you:

if( Object.prototype.toString.call( someObject ) === '[object Object]' ) {

    // do your iteration

}

From ECMAScript 5 Section 8.6.2 if you're interested:

The value of the [[Class]] internal property is defined by this specification for every kind of built-in object. The value of the [[Class]] internal property of a host object may be any String value except one of "Arguments", "Array", "Boolean", "Date", "Error", "Function", "JSON", "Math", "Number", "Object", "RegExp", and "String". The value of a [[Class]] internal property is used internally to distinguish different kinds of objects. Note that this specification does not provide any means for a program to access that value except through Object.prototype.toString (see 15.2.4.2).

You could also do something like:

    if (someObject.constructor == Object) {

        // do your thing

    }

you can read more about it here

I think a function like this should be native, just like Array.isArray:

Object.isObject = function(obj) {

    return obj && obj.constructor === this || false;

};

This one doesn't make function calls nor string comparisons, and doesn't reference global objects (like Object), so it should be quite fast. I don't think this will used in performance intensive tasks though, but whatever.

I'm not totally convinced about the name... maybe something like Object.isLiteral would be better.

It can cause problem with host objects, though, but I don't have a test ready.

Say you have some testvar and want to see if it is an object, but not an array or null (these are both of type Object). You can do the following

testVar instanceof Object && !Array.isArray(testVar) && testVar !== null

Well, you don't need to check everything by yourself or write your own codes, when there are good libraries such as Lodash and Underscore.

In Lodash, you can easily check it by isPlainObject function, e.g.:

_.isPlainObject({'a': 12});

Check this page: https://lodash.com/docs#isPlainObject

Bumping old thread, but it's still shows up in searches and people are even referencing it as duplicate for a new similar ones - and still the top-most answers here are far from being correct (sorry people, no offends).

To check if variable is an object the following should be used:

if (typeof variable === 'object') {

    // do something

}

Arrays are also objects, so this would be true for an array too.
Moreover - null is a valid object as well, therefore the above will return true on null too.
Personally, when really need to check if an expected variable is 'workable' object I'm always using this boringly repeated formula:

if (variable && typeof variable === `object`) {

    // do something

}

Last but not least :) please please please, do yourself a favor and don't use any libraries for such a simple things. Javascript is a fastly evolving language having today much much more than yesterday, so fast that most of the libraries are not even fast enough to fetch up.
Beside it, people who are working on the spec are doing a great job and mostly the native APIs are clean, correct, making perfect sense and coherent with the rest of the language.

Little gist, not really elegant but efficient

function _isObj( _obj ){



   return ( typeof _obj === "object" && JSON.stringify( _obj ).indexOf( "{" ) == 0 ); 



}

Little example

function _isObj( _obj ){



   return ( typeof _obj === "object" && JSON.stringify( _obj ).indexOf( "{" ) == 0 ); 



}



var p = document.createElement( "p" );

p.textContent = "undefined : " + _isObj( undefined );

document.body.appendChild( p );



p = document.createElement( "p" );

p.textContent = "null : " + _isObj( null );

document.body.appendChild( p );



p = document.createElement( "p" );

p.textContent = "boolean : " + _isObj( true );

document.body.appendChild( p );



p = document.createElement( "p" );

p.textContent = "function : " + _isObj( function(){} );

document.body.appendChild( p );



p = document.createElement( "p" );

p.textContent = "array : " + _isObj(  );

document.body.appendChild( p );



p = document.createElement( "p" );

p.textContent = "string : " + _isObj( "{}" );

document.body.appendChild( p );

document.body.appendChild( p );

document.body.appendChild( p );



p = document.createElement( "p" );

p.textContent = "number : " + _isObj( 1 );

document.body.appendChild( p );

document.body.appendChild( p );



p = document.createElement( "p" );

p.textContent = "object : " + _isObj( {} );

document.body.appendChild( p );



p = document.createElement( "p" );

p.textContent = "another object : " + _isObj( p );

document.body.appendChild( p );

hope this help

Strangely, I'm seeing different values for toString() for a subclassed object depending how toString() is being called:

Object.prototype.toString.call(aThing)

"[object Object]"



aThing.toString()

"ZmPopupMenu"

That results in a false positive, so I amended it to prefer the object's toString():

var str = someObject.toString

    ? someObject.toString()

    : Object.prototype.toString.call(someObject);

return str === '[object Object]';

This works for me:

function isObject(o) {

    try {

        return ((typeof o == "object") && (o !== null) && (o.length === undefined));

    } catch (err) {

        return false;

    }

}