How to determine if a javascript object is simple or complex?

Question

Basically I need to tell apart the following two:

var simple = 5 // or "word", or 56.78, or any other "simple" object
var complex = {propname: "propvalue", "otherprop": "othervalue"}

Answer 1

Using typeof operator you can determine the following:

"number"        Operand is a number
"string"        Operand is a string
"boolean"       Operand is a Boolean
"object"        Operand is an object
"undefined"     Operand is not defined.

Edited: As it was suggested in a comment you may want to also check if value is null, as typeof null will return object.

Answer 2

You could use typeof:

typeof 5 == "number";
typeof 1.5 == "number";
typeof true == "boolean";
typeof "word" == "string";
typeof {} == "object";

Basically:

if(obj == null) {
  //null or undefined
}
else if(typeof obj == "object") {
  //It's "complex"
}
else {
  //Primitive or "simple"
}

Note: null will return "object", so you need to check for it.

Answer 3

Credit here

Object.prototype.getName = function() { 
   var funcNameRegex = /function (.{1,})\(/;
   var results = (funcNameRegex).exec((this).constructor.toString());
   return (results && results.length > 1) ? results[1] : "";
};


var simple  = 5;            // or "word", or 56.78, or any other "simple" object
var complex = { propname    : "propvalue"
              , "otherprop" : "othervalue"
              };

---

simple.getName();           // returns: "Number"
complex.getName();          // returns: "Object"

Answer 4

The problem is that more than just {} returns a type of 'object'

typeof 5 == 'number'
typeof NaN == 'number'
typeof 'test' == 'string'
typeof true == 'boolean'
typeof undefined == 'undefined'    

typeof null == 'object'
typeof /asdf/ == 'object' // this is true in some engines, like Firefox's. Not in V8 (in which it is 'function')
typeof [] == 'object'
typeof {} == 'object'

But, by using toString you can check further:

toString.call(null) == '[object Window]' // or '[object global]' or '[object Null]' - depends on engine
toString.call(/asdf/) == '[object RegExp]'
toString.call([]) == '[object Array]'
toString.call({}) == '[object Object]'

So, the best way to check is:

var test;

test = {};
typeof test == 'object' && toString.call(test) == '[object Object]'; // true

test = [];
typeof test == 'object' && toString.call(test) == '[object Object]'; // false

// et cetera

Hope that helps

Answer 5

Try the following

if (typeof obj === 'object') {
  // It's complex
} else {
  // It's not
}

Answer 6

In your case:

var simple = 5; // number, not an object
var simple = new Number(5); // now it is an object, but still the value is 5
var complex = {propname: "propvalue", "otherprop": "othervalue"};

for ( property in complex ) {
   if ( complex.hasOwnProperty( property ) )
   {
      alert ( 'composite object' );
      return;
   } else {
      alert ( 'simple object' );
      return;
   }
}

As of what I understand from you question - you need to tell if the object has properties/methods.

Answer 7

You could just make a simple function that returns true for simple types:

function isSimple( a ) {
    return (typeof a).match(/(number)|(boolean)|(string)/)
}

Note that this will return true for NaN as it's considered a number, and false for 'undefined' - but you could easily modify this to suit your specific case.

Run the snippet below to see it in action

<script>
// return true/false if typeof matches simple regex pattern
function isSimple( a ) {
    return (typeof a).match(/(number)|(boolean)|(string)/);
}

// setup some tests cases
var tests = [
  [1,2,3],
  'hello',
  7,
  { foo: 'bar' },
  NaN
]

// log output of isSimple function against each test case
for( var i in tests ) {
  var value = tests[ i ];
  if( isSimple( value ) ) {
    console.log( 'simple value', value );
  } else {
    console.log( 'not simple', value );
  }
}
  
  
</script>