可随时使用的检查功能

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和函数都是对象。虽然，null有点做作。因此，最好先检查空值，以检测它是否为空。检查o==“object”的类型可确保o是一个对象。如果不进行此检查，Object.prototype.toString将毫无意义，因为它将返回任何对象，即使是未定义和null！例如：toString（undefined）返回[object undefined]！在typeofo=='object'检查之后，toString.call（o）是一个很好的方法来检查o是一个对象，还是一个派生对象，如Array、Date或函数。在isDerivedObject函数中，它检查o是否为函数。因为，函数也是一个对象，这就是它存在的原因。若并没有这样做，函数将返回false。示例：isDerivedObject（function（）｛｝）将返回false，但现在返回true。人们总是可以改变对象的定义。因此，可以相应地更改这些函数。

测验

函数isObject（o）{返回null！=o&&typeof o==“对象”&&Object.pr原型.toString.call（o）==“[对象对象]”；}函数isDerivedObject（o）{回来isObject（o）&&空！=o&&（类型o==“对象”| |类型o===“函数”）&&/^\[object/.test（object.protype.toString.call（o））；}//测试//null是对象吗？控制台日志('是空的对象吗？'，isObject（空）);控制台日志('是否为null派生对象？'，isDerivedObject（空）);//1234是一个对象吗？控制台日志('1234是对象吗？'，isObject（1234）);控制台日志('1234是派生对象吗？'，isDerivedObject（1234）);//新编号（1234）是对象吗？控制台日志('新编号（1234）是对象吗？'，isObject（新编号（1234））);控制台日志('新编号（1234）是派生对象吗？'，isDerivedObject（1234）);//函数对象是对象吗？控制台日志('是（new（function（）｛｝））对象吗？'，isObject（（new（函数（）｛｝））);控制台日志(“（new（function（）｛｝））是派生对象吗？”，isObject（（new（函数（）｛｝））);//｛｝是对象吗？控制台日志(“是｛｝对象吗？”，isObject（｛｝）);控制台日志(“｛｝是派生对象吗？”，isDerivedObject（｛｝）);//Array是对象吗？控制台日志('数组是对象吗？'，isObject（[]）)控制台日志('数组是派生对象吗？'，isDerivedObject（[]）)//Date是对象吗？控制台日志('日期是对象吗？'，isObject（新日期（））);控制台日志('日期是派生对象吗？'，isDerivedObject（新日期（））);//函数是对象吗？控制台日志('函数是对象吗？'，isObject（函数（）｛｝）);控制台日志('函数是派生对象吗？'，isDerivedObject（函数（）｛｝）);

如果明确希望检查给定值是否为｛｝。

function isObject (value) {
 return value && typeof value === 'object' && value.constructor === Object;
}

usetypeof（myobj）将告诉它是哪种类型的变量。

对于阵列：Array.isArray（inp）或[]是数组的实例

如果是object，将显示“object”

简单的JS函数，

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

Eg:

函数isObj（v）{return typeof（v）==“对象”}变量samp_obj={“a”：1，“b”：2，“c”：3}变量num=10；var txt=“您好！”var_collection=[samp_obj，num，txt]for（var_collection中的var i）{if（isObj（var_collection[i]））{console.log（“是的，它是对象”）}其他{console.log（“No it is”+typeof（var_collection[i]））}}

在阅读并尝试了许多实现之后，我注意到很少有人尝试检查JSON、Math、文档或原型链长度超过1步的对象等值。

我认为，与其检查变量的类型，然后删除边缘事例，不如尽可能简单地进行检查，以避免在添加了注册为“对象”类型的新原语或本地对象时进行重构。

毕竟，typeof运算符会告诉您某个对象是否是JavaScript的对象，但JavaScript对对象的定义对于大多数真实场景来说太宽泛了（例如typeof null==“object”）。下面是一个函数，它通过基本上重复两次检查来确定变量v是否为对象：

只要v的字符串化版本为“[object object]”，就会启动一个循环。我希望函数的结果与下面的日志完全相同，所以这是我最终得出的唯一“对象性”标准。如果失败，函数将立即返回false。v被链中的下一个原型替换为v=Object.getPrototypeOf（v），但也在之后直接求值。当v的新值为null时，这意味着包括根原型（很可能是链中唯一的原型）在内的每个原型都通过了while循环中的检查，我们可以返回true。否则，新的迭代开始。

函数isObj（v）{while（Object.product.toString.call（v）=='[Object Object]'）if（（v=Object.getPrototypeOf（v））==null）返回truereturn false}console.log（'FALSE：'）console.log（'[]->'，isObj（[]））console.log（'ull->'，isObj（null））console.log（'文档->'，isObj（文档））console.log（'JSON->'，isObj（JSON））console.log（'function->'，isObj（函数（）｛｝））console.log（'newDate（）->'，isObj（newDate（（）））console.log（'RegExp->'，isObj（/./））console.log（'TRUE:'）console.log（“｛｝->”，isObj（｛｝））console.log（'newObject（）->'，isObj（newObject（（）））console.log（'新对象（null）->'，isObj（新对象（空）））console.log（'newObject（｛｝）->'，isObj（newObject（{foo:'bar'｝）））console.log（'Object.prototype->'，isObj（Object.prototype））console.log（'Object.create（null）->'，isObj（Object.create（null）））console.log（“Object.create（｛｝）->”，isObj（Object.create（｛foo:'bar'｝）））console.log（“deep继承->”，isObj（Object.create（Object.create（｛foo:'bar'｝））））

如果typeof yourVariable==“object”，则它是一个对象或null。

如果要排除null、数组或函数，只需执行以下操作：

if (
    typeof yourVariable === 'object' &&
    !Array.isArray(yourVariable) &&
    yourVariable !== null
) {
    executeSomeCode();
}

只需检查对象或数组，无需额外的函数调用（速度）。同样张贴在这里。

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

isLiteralObject（）-注意：仅用于Object文本，因为它对自定义对象（如newDate或newYourCustomObject）返回false。

isLiteralObject = function(a) {
    return (!!a) && (a.constructor === Object);
};
console.log(isLiteralObject(        )); // false
console.log(isLiteralObject(    null)); // false
console.log(isLiteralObject(    true)); // false
console.log(isLiteralObject(       1)); // false
console.log(isLiteralObject(   'str')); // false
console.log(isLiteralObject(      [])); // false
console.log(isLiteralObject(new Date)); // false
console.log(isLiteralObject(      {})); // true