检查值是否是JavaScript中的对象


Check if a value is an object in JavaScript

如何检查值是否是javascript中的对象？

相关讨论

如果typeof yourVariable === 'object'是一个对象或空值。如果要排除空值，只需将其设置为typeof yourVariable === 'object' && yourVariable !== null。

相关讨论

让我们在javascript中定义"对象"。根据MDN文档，每个值都是一个对象或原语：

primitive, primitive value

A data that is not an object and does not have any methods. JavaScript has 5 primitive datatypes: string, number, boolean, null, undefined.

什么是原始人？

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

什么是物体(即不是原始物体)？

  • Object.prototype
  • 一切都是从Object.prototype传下来的。
    • Function.prototype
      • Object
      • Function
      • function C(){}用户定义函数
    • C.prototype用户定义函数的原型属性：这不是C的原型
      • new C()－"新"—使用用户定义函数
    • Math
    • Array.prototype
      • 数组
    • {"a": 1,"b": 2}—使用文字符号创建的对象
    • new Number(3)——原语包装纸
    • …其他很多事情…
  • Object.create(null)
  • 一切都是从一个Object.create(null)衍生而来的。

如何检查值是否为对象

instanceof本身不起作用，因为它遗漏了两个案例：

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

由于假阳性(null和假阴性(功能)，typeof x === 'object'不起作用：

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

Object.prototype.toString.call不起作用，因为所有原语都有假阳性：

1
2
3
4
5
> Object.prototype.toString.call(3)
"[object Number]"

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

所以我用：

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

@达安的回答似乎也有效：

1
2
3
function isObject(obj) {
  return obj === Object(obj);
}

因为，根据MDN文档：

The Object constructor creates an object wrapper for the given value. If the value is null or undefined, it will create and return an empty object, otherwise, it will return an object of a type that corresponds to the given value. If the value is an object already, it will return the value.

第三种似乎有效的方法(不确定是否为100%)是使用Object.getPrototypeOf，如果其参数不是对象，则抛出异常：

1
2
3
4
5
6
7
8
9
10
11
12
13
// 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({})
相关讨论

尝试使用typeof(var)和/或var instanceof something。

编辑：这个答案给出了如何检查变量属性的概念，但它不是一个防弹配方(毕竟根本没有配方！)检查它是否是一个物体，远离它。因为人们往往在不做任何研究的情况下从这里寻找可以复制的东西，所以我强烈建议他们转向另一个最上乘的人(并且是正确的！)回答。

相关讨论

official underline.js使用此检查来确定某个东西是否真的是一个对象

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

更新

更新后的underline.js库现在正在使用以下功能，因为V8中以前有一个bug，并且还有一些微速度优化。

1
2
3
4
5
// Is a given variable an object?
_.isObject = function(obj) {
  var type = typeof obj;
  return type === 'function' || type === 'object' && !!obj;
};
相关讨论

Object.prototype.toString.call(myVar)将返回：

  • 如果myvar是一个对象，则为"[object Object]"。
  • 如果myvar是一个数组，则为"[object Array]"。
  • 等。

有关这方面的更多信息以及为什么它是typeof的一个很好的替代方法，请阅读本文。

相关讨论

用于简单地检查对象或数组，而不需要额外的函数调用(速度)。也张贴在这里。

ISARAY()

1
2
3
4
5
6
7
8
9
10
11
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()-注意：仅用于对象文本，因为它对自定义对象(如new date或new yourcustomObject)返回false。

1
2
3
4
5
6
7
8
9
10
11
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
相关讨论

我喜欢简单的：

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

如果该项是JS对象，并且不是JS数组，也不是null，如果这三个都证明为真，则返回true。如果三个条件中的任何一个失败，&&测试将短路，false将返回。如果需要，可以省略null测试(取决于您如何使用null测试)。

文档：

http://devdocs.io/javascript/operators/typeof

http://devdocs.io/javascript/global_对象/object

http://devdocs.io/javascript/global_objects/array/isarray

http://devdocs.io/javascript/global_对象/null

相关讨论

具有Array.isArray功能：

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

无功能Array.isArray：

只是奇怪有多少人对错误的答案投了赞成票？？只有一个答案通过了我的测试！！！！这里我创建了我的简化版本：

1
2
3
function isObject(o) {
  return o instanceof Object && o.constructor === Object;
}

对于我来说，这很简单明了，而且很有效！这里是我的测试：

1
2
3
4
5
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

再一次：并非所有答案都通过了这项测试！！！！？？？

如果需要验证对象是特定类的实例，则必须使用特定类检查构造函数，例如：

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

简单测试：

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

因此，您将拥有严格而健壮的代码！

如果不创建isDate、isError、isRegExp等函数，可以考虑使用此通用函数：

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

它不能适用于前面提到的所有测试用例，但对于所有对象(普通的或构造的)来说已经足够好了。

由于Object.create的内部实现，isObject在Object.create(null)的情况下不起作用，这里解释了这一点，但您可以在更复杂的实现中使用isObject：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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;
};

基于此实现，已经在NPM v1上创建了包！它适用于所有前面描述的测试用例！？？？

相关讨论

好吧，在回答问题之前，让我们先给你这个概念，在javascript中，函数是object，也有null，object，array，even date，所以正如你所看到的，没有一个简单的方法像typeof obj==‘object’，所以上面提到的一切都将返回true，但是有一些方法可以通过编写函数或使用javascript框架来检查它。S，OK：

现在，假设您有一个真正的对象(不是空值、函数或数组)：

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

纯javascript：

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

或

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

或

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

或

1
2
3
function isObject(obj) {
    return obj instanceof Object;
}

通过调用这些函数，您可以在代码中简单地使用它们中的一个，如果它是一个对象，它将返回true：

1
isObject(obj);

如果您使用的是一个javascript框架，那么他们通常为您准备了这类功能，其中包括：

jQuery：

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

Angular：

1
angular.isObject(obj);

下划线和阴影：

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

这取决于你所说的"是一个物体"。如果你想要所有不是原始的东西，例如你可以设置新属性的东西，这应该可以做到：

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

它不包括原语(普通数字/NaN/Infinity、普通字符串、符号、true/false、undefined和null，但对于其他所有对象(包括Number、Boolean和String应返回为真。注意，JS没有定义什么"主机"对象，如window或console在与typeof一起使用时应该返回，因此很难用这样的检查覆盖这些对象。

如果您想知道某个对象是"普通"对象，即它是作为文字{}或Object.create(null)创建的，可以这样做：

1
2
3
4
5
6
7
8
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:由于Symbol.toStringTag现在允许自定义Object.prototype.toString.call(...)的输出，所以上面的isPlainObject函数在某些情况下可能返回false，即使对象以文字形式开始其生命。可以说，按照惯例，带有自定义字符串标记的对象不再是纯对象，但这进一步模糊了纯对象在javascript中的定义。

相关讨论

检查值类型的最合理方法似乎是typeof运算符。唯一的问题是它破得很厉害：

  • 返回null的"object"，属于空类型。
  • 它为属于对象类型的可调用对象返回"function"。
  • 它可以返回(几乎)任何它想要的非标准非可调用对象。例如，Ie似乎喜欢"unknown"。唯一禁止的结果是"function"和原始类型。

typeof只对非null原语可靠。因此，检查值是否为对象的一种方法是确保由typeof返回的字符串与原语不对应，并且该对象不是null。然而，问题是未来的标准可能引入一个新的基元类型，我们的代码会将它视为一个对象。新类型不经常出现，但例如ECMAScript 6引入了符号类型。

因此，我建议的方法不是typeof，而是根据值是否为对象而改变结果的方法。以下计划是

全面但并非详尽的适当方法列表，用于测试值是否属于对象类型。

  • Object构造函数

    Object构造函数将传递的参数强制为对象。如果它已经是一个对象，则返回相同的对象。

    因此，可以使用它将值强制为对象，并严格地将该对象与原始值进行比较。

    以下功能需要ecmascript 3，它引入了===：

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

    我喜欢这种方法，因为它简单且自我描述，类似的检查也适用于布尔值、数字和字符串。然而，要知道，它依赖的是全球的Object，既不隐藏也不改变。

  • 构造函数

    当您实例化一个构造函数时，它可以返回一个不同于刚刚创建的实例的值。但除非该值是一个对象，否则它将被忽略。

    以下函数需要ECMAScript 3，这允许构造函数返回非对象。在ecmascript 3之前，它抛出了一个错误，但当时try语句并不存在。

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

    虽然比前一个例子简单一些，但这个例子不依赖任何全局属性，因此可能是最安全的。

  • this值

    旧的ecmascript规范要求this值是一个对象。ecmascript 3引入了Function.prototype.call，允许调用具有任意this值的函数，但强制调用对象。

    ECMAScript 5引入了一种严格的模式，消除了这种行为，但在草率的模式下，我们仍然可以(但可以说不应该)依赖它。

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

  • [原型]

    所有普通对象都有一个名为[[原型]]的内部槽，其值决定了它从哪个其他对象继承。该值只能是一个对象或null。因此，您可以尝试创建从所需值继承的对象，并检查它是否工作。

    Object.create和Object.getPrototypeOf都需要ECMAScript 5。

    1
    2
    3
    4
    5
    6
    7
    8
    function isObject(value) { /* Requires ECMAScript 5 or later */
      try {
        Object.create(value);
        return value !== null;
      } catch(err) {
        return false;
      }
    }
    1
    2
    3
    4
    5
    function isObject(value) { /* Requires ECMAScript 5 or later */
      function Constructor() {}
      Constructor.prototype = value;
      return Object.getPrototypeOf(new Constructor()) === value;
    }

  • 一些新的ecmascript 6方法

    ECMAScript 6引入了一些新的间接方法来检查值是否是一个对象。他们使用前面看到的方法将值传递给一些代码，这些代码需要包装在try语句中的对象来捕获错误。一些隐藏的例子，不值得评论

    1
    2
    3
    4
    5
    6
    7
    8
    function isObject(value) { /* Requires ECMAScript 6 or later */
      try {
        Object.setPrototypeOf({}, value);
        return value !== null;
      } catch(err) {
        return false;
      }
    }

    1
    2
    3
    4
    5
    6
    7
    8
    function isObject(value) { /* Requires ECMAScript 6 or later */
      try {
        new WeakSet([value]);
        return true;
      } catch(err) {
        return false;
      }
    }

注：我故意跳过了一些方法，如Object.getPrototypeOf(value)方法(es5)和Reflect方法(es6)，因为它们称为基本的内部方法，这些方法可能会做一些不好的事情，例如，如果value是代理。出于安全原因，我的示例仅引用value，而不直接访问它。

相关讨论

天哪，其他答案太过混乱了。

简短回答

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

要测试这一点，只需在chrome控制台中运行以下语句。

案例1。

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

案例2。

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

案例3。

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

解释

好吧，我们把它分解一下

typeof anyVar == 'object'由三位候选人([], {} and null返回为真，

anyVar instanceof Object将这些候选对象缩小到两个[], {}。

!(anyVar instanceof Array)缩小到只有一个--{}。

请转鼓！

通过这个，您可能已经学会了如何在javascript中检查数组。

相关讨论

试试这个

1
2
3
4
5
6
if (objectName instanceof Object == false) {
  alert('Not an object');
}
else {
  alert('An object');
}
相关讨论

准备好使用功能进行检查

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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。

  • 人们总是可以更改对象的定义。所以，我们可以相应地改变这些函数。

测验

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
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(){})
);

1
2
3
4
5
6
7
8
9
10
11
12
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运算符检查继承链。它将消除空值，但数组在继承链中有对象。

所以解决方案是：

1
2
3
if (myVar instanceof Object && !(myVar instanceof Array)) {
  // code for objects
}
相关讨论

晚了一点…对于"普通对象"(我的意思是，如'x'：5，'y'：7)，我有一个小片段：

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

它生成下一个输出：

1
2
3
4
5
6
7
8
9
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

它总是对我有用。只有当"o"的类型为"object"但没有空值、数组或函数时，if才会返回"true"。：)

相关讨论

返回类型

类型化的javascript构造函数和对象(包括null)返回"object"。

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

检查他们的建设者

检查它们的constructor属性返回函数及其名称。

1
2
3
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"名称。

1
2
3
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

最终代码

1
2
3
4
5
6
7
8
9
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

Note: Function.name might not work in IE https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#Browser_compatibility

洛达什有isplainObject，这可能是许多人来这个页面寻找的。当给出一个函数或数组时，它返回false。

相关讨论

由于对于如何正确处理这个问题似乎有很多困惑，我将留下2美分(这个答案符合规范，在任何情况下都会产生正确的结果)：

测试原语：undefinednullbooleanstringnumber。

1
function isPrimitive(o){return typeof o!=='object'||null}

对象不是基元：

1
function isObject(o){return !isPrimitive(o)}

或者：

1
2
function isObject(o){return o instanceof Object}
function isPrimitive(o){return !isObject(o)}

测试任何阵列：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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];
    }
}());

测试对象不包括：DateRegExpbooleannumberstringFunction任何阵列

1
2
3
4
5
6
7
8
9
10
11
12
13
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];
    }
}());

这是可行的。它是一个返回真、假或可能为空的函数。

1
2
3
4
5
6
7
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

相关讨论

Ramda函数库具有检测javascript类型的出色功能。

解释完整功能：

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

当我意识到这个解决方案是多么简单和美丽时，我不得不大笑。

Ramda文档中的示例用法：

1
2
3
4
5
6
7
8
9
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"

当其他一切都失败时，我使用这个：

1
2
3
var isObject = function(item) {
   return item.constructor.name ==="Object";
};
相关讨论

1
2
3
4
if(typeof value === 'object' && value.constructor === Object)
{
    console.log("This is an object");
}
1
2
3
4
  var isObject = function(obj) {
    var type = typeof obj;
    return type === 'function' || type === 'object' && !!obj;
  };

!!obj是检查对象是否真实的简写(过滤掉空/未定义)

我喜欢用这个

1
2
3
4
5
6
function isObject (obj) {
  return typeof(obj) =="object"
        && !Array.isArray(obj)
        && obj != null
        && obj !=""
        && !(obj instanceof String)  }

我认为在大多数情况下，日期必须作为一个对象通过检查，所以我不过滤日期

如果您想检查object的prototype是否仅来自object。过滤掉String、Number、Array、Arguments等。

1
2
3
4
function isObject(n) {
  if (n == null) return false;
  return Object.prototype.toString.call(n) === '[object Object]';
}
相关讨论

我从这个问题中找到了一种"新"的方式来进行这种类型检查：为什么instanceof对于某些文本返回false？

在此基础上，我创建了一个用于类型检查的函数，如下所示：

1
2
3
4
5
6
7
function isVarTypeOf(_var, _type){
    try {
        return _var.constructor === _type;
    } catch(ex) {
        return false;         //fallback for null or undefined
    }
}

然后你可以做：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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

这是在Chrome56、Firefox 52、Microsoft Edge 38、Internet Explorer 11、Opera 43上测试的。

编辑：如果还要检查变量是否为空或未定义，则可以使用此选项：

1
2
3
4
5
6
7
8
9
10
11
12
13
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

如果要释放比较对象，可以尝试以下方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
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
        }
    }
}

这样，你就可以像国际航空公司的评论那样：

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

或

1
2
3
4
5
6
7
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
相关讨论

考虑-typeof bar ==="object"以确定bar是否为对象

虽然typeof bar ==="object"是检查bar是否为对象的可靠方法，但在javascript中令人惊讶的是，空值也被认为是一个对象！

因此，令大多数开发人员惊讶的是，以下代码将向控制台记录true(而非false)：

var bar = null;console.log(typeof bar ==="object"); // logs true!只要知道这一点，也可以通过检查条是否为空来轻松避免问题：

console.log((bar !== null) && (typeof bar ==="object")); // logs false为了彻底理解我们的答案，还有两件事值得注意：

首先，如果bar是一个函数，上述解决方案将返回false。在大多数情况下，这是所需的行为，但在您还希望为函数返回true的情况下，可以将上述解决方案修改为：

console.log((bar !== null) && ((typeof bar ==="object") || (typeof bar ==="function")));其次，如果bar是一个数组(例如，如果var bar = [];)，上述解决方案将返回true。在大多数情况下，这是所需的行为，因为数组确实是对象，但在您希望对数组也使用false的情况下，可以将上述解决方案修改为：

console.log((bar !== null) && (typeof bar ==="object") && (toString.call(bar) !=="[object Array]"));但是，还有另一种方法可以为空值、数组和函数返回false，为对象返回true：

console.log((bar !== null) && (bar.constructor === Object));或者，如果使用jquery：

console.log((bar !== null) && (typeof bar ==="object") && (! $.isArray(bar)));

ES5使数组的大小写非常简单，包括它自己的空检查：

console.log(Array.isArray(bar));

如果您已经在使用AngularJS，那么它有一个内置方法来检查它是否是一个对象(不接受空值)。

1
angular.isObject(...)

主要使用typeof obj[index] === 'object'，但也会返回function和#document这两个对象。这取决于你是否需要包含在结果中。

基本上，您可以通过检查控制台中的输出来做一个测试代码，过滤掉特定元素是否是对象。在这里，您可以为一个示例运行一个代码：

1
2
3
4
5
6
7
8
9
10
function cekObject(obj, index) {  
  if (!obj.tagName) {

    //test case #1      
    if (typeof obj === 'object') {
      console.log('obj['+ index +'] is listed as an object');
    }  
   
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.2.3/jquery.min.js">

  function updateFilters() {
    var object = $('.j-image');
    $('.juicer-feed').empty();
   
    for(var index in object) {
      cekObject(object[index], index);
    };
  }


<ul class="juicer-feed" data-feed-id="chetabahana" data-after="updateFilters()">
</ul>

<script src="https://assets.juicer.io/embed.js">

它取决于用例，如果我们不想让数组和函数成为一个对象，我们可以使用underline.js内置函数。

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

您可以使用JSON.stringify来测试您的对象，如下所示：

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

使用typeof(my_obj)将告诉它是哪种类型的变量。

数组：Array.isArray(inp)或[] isinstanceof Array。

如果是对象，则显示"对象"

简单的JS函数，

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

如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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]))
  }
}

相关讨论

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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

使用object.prototype的toString()方法可以很容易地做到这一点。

1
2
3
if(Object.prototype.toString.call(variable) =="[object Object]"){
   doSomething();
}

或

1
2
3
if(Object.prototype.toString.call(variable).slice(8,-1).toLowerCase() =="object"){
   doSomething();
}
相关讨论

一个小小的nodejs控制台实验，基于马特芬威克的第三个选择阅读他的完整答案上面。只需稍作调整即可获得true或false。

对于对象测试，以下返回false。

1
2
3
4
5
6
7
8
9
10
11
12
> if(Object.getPrototypeOf('v') === Object.prototype){console.log(true);}else{console.log(false);}
false
undefined
> if(Object.getPrototypeOf(1) === Object.prototype){console.log(true);}else{console.log(false);}
false
undefined
> if(Object.getPrototypeOf(false) === Object.prototype){console.log(true);}else{console.log(false);}
false
undefined
> if(Object.getPrototypeOf(['apple']) === Object.prototype){console.log(true);}else{console.log(false);}
false
undefined

对象将返回true。

1
2
3
> if(Object.getPrototypeOf({'this':10}) === Object.prototype){console.log(true);}else{console.log(false);}
true
undefined

直接回答当然是typeof v==='object'，但这是非常无用的。我想知道这首歌是不是意味着一本普通的字典。

尝试：

1
isdict(v) { return  v !== undefined && v!==null && typeof v==='object' && v.constructor!==Array && v.constructor!==Date; }
相关讨论

我有一个有效的代码片段。当整段代码都没有给出时，我觉得很困惑，所以我自己创建了它：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    <!DOCTYPE html>
    <html>
    <body>
    <button onclick="myFunc()">Try it</button>

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

    </body>
    </html>
相关讨论