如何判断一个javascript对象是简单对象还是复杂对象？

Question

基本上我需要区分以下两个：

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

Answer 1

使用 typeof 运算符，您可以确定以下内容：

"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.

已编辑：
正如评论中所建议的，您可能还想检查 value 是否为 null，因为 typeof null 将返回对象。

Answer 2

您可以使用 typeof：

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

基本上:

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

注意： null 将返回 "object"，因此您需要检查它。

Answer 3

问题是不仅仅是 {} 返回“对象”类型

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'

但是，通过使用 toString 您可以进一步检查：

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]'

因此，最好的检查方法是：

var test;

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

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

// et cetera

希望有帮助

Answer 4

在此注明

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 5

尝试以下操作

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

Answer 6

就您的情况而言：

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

据我从您的问题中了解到的，您需要判断该对象是否具有属性/方法。

Answer 7

您可以创建一个简单的函数，为简单类型返回 true：

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

请注意，这将为 NaN 返回 true，因为它被视为数字，而为“未定义”返回 false - 但您可以轻松修改它以适应你的具体情况。

运行下面的代码片段以查看其实际效果

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