一个基于Matt Fenwick对其完整答案的第三个选项的NodeJS控制台实验。只要稍微调整一下就能判断真假。

以下对象测试返回false。

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

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

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

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

表演

今天2020.09.26我在Chrome v85、Safari v13.1.2和Firefox v80上对MacOs HighSierra 10.13.6进行了测试，以确定所选的解决方案。

后果

解决方案C和H在所有情况下在所有浏览器上都是快速/最快的在所有情况下，解决方案D和G在所有浏览器上都是慢/最慢的

细节

我为解决方案执行3个测试用例A.BCDEFGH我JKLMNOPQRSTU五、

对于小对象-您可以在此处运行对于大型对象-您可以在此处运行没有对象-你可以在这里运行

下面的代码片段介绍了解决方案之间的差异。解决方案A-G为Matt Fenwick描述的选定案例提供了正确的答案

// https://stackoverflow.com/a/14706877/860099函数A（x）{return x===对象（x）；};// https://stackoverflow.com/a/42250981/860099函数B（x）{return _.isObject（x）；}// https://stackoverflow.com/a/34864175/860099函数C（x）{返回x！=null&&（typeof x===“对象”| | typeof x====“函数”）；}// https://stackoverflow.com/a/39187058/860099函数D（x）{return new函数（）｛return x；｝（）==x；}// https://stackoverflow.com/a/39187058/860099函数E（x）{return函数（）{return this==x；}.call（x）；}// https://stackoverflow.com/a/39187058/860099函数F（x）｛/*需要ECMAScript 5或更高版本*/尝试{对象.create（x）；返回x！==无效的}捕获（错误）{return false；}}// https://stackoverflow.com/a/39187058/860099函数G（x）｛/*需要ECMAScript 5或更高版本*/函数构造函数（）｛｝Constructor.prototype=x；return Object.getPrototypeOf（new Constructor（））==x；}// https://stackoverflow.com/a/8511332/860099函数H（x）{返回类型x=='对象'&&x！==无效的}// https://stackoverflow.com/a/25715455/860099函数I（x）{return（typeof x==“object”&&！Array.isArray（x）&&x！==空）；};// https://stackoverflow.com/a/22482737/860099函数J（x）{return x instanceof Object；}// https://stackoverflow.com/a/50712057/860099函数K（x）{设t=JSON.stringify（x）；返回t？t[0]==“｛”：false；}// https://stackoverflow.com/a/13356338/860099函数L（x）{return Object.pr原型.toString.call（x）==“[对象对象]”；};// https://stackoverflow.com/a/46663081/860099函数M（o，strict=true）{如果（o==null | | o==未定义）{return false；}const instanceOfObject=o instanceof Object；const typeOfObject=typeof o==“对象”；constconstructorUndefined=o.constructor===未定义；constconstructorObject=o.constructor==对象；const typeOfConstructorObject=typeof o.constructor==“函数”；设r；if（严格==真）{r=（instanceOfObject | | typeOfObject）&&（constructorUndefined | | constructorObject）；}其他{r=（constructorUndefined | | typeOfConstructorObject）；}返回r；}// https://stackoverflow.com/a/42250981/860099函数N（x）{return$.type（x）==“对象”；}// https://stackoverflow.com/a/34864175/860099函数O（x）{if（Object.pr原型.toString.call（x）！=='[object对象]'）{return false；}其他{var prototype=对象.getPrototypeOf（x）；返回原型==null | |原型==Object.prototype；}}// https://stackoverflow.com/a/57863169/860099函数P（x）{while（Object.product.toString.call（x）=='[Object Object]'）if（（x=Object.getPrototypeOf（x））==null）返回truereturn false}// https://stackoverflow.com/a/43289971/860099函数Q（x）{尝试{开关（x.constructor）{案例编号：case函数：大小写布尔值：case符号：案例日期：case字符串：大小写RegExp：return x.constructor==对象；case错误：case评估错误：大小写范围错误：案例引用错误：case语法错误：案例类型错误：大小写URI错误：return（对象==错误？错误：x.constructor）==对象；case数组：大小写Int8Array：大小写Uint8Array：case Uint8ClampedArray：大小写Int16Array：大小写Uint16Array：case Int32Array：大小写Uint32Array：case Float32阵列：case浮点64Array：return（对象==数组？数组：x.constructor）==对象；case对象：违约：return（对象==对象？对象：x.constructor）==对象；}}捕获（ex）{return x==对象；}}// https://stackoverflow.com/a/52478680/860099函数R（x）{return typeof x=='对象'&&x对象实例&&！（数组的x实例）；}// https://stackoverflow.com/a/51458052/860099函数S（x）{返回x！=null&&x.constructor？。name==“对象”}// https://stackoverflow.com/a/42250981/860099函数T（x）{返回x？。构造函数？。toString（）.indexOf（“对象”）>-1；}// https://stackoverflow.com/a/43223661/860099函数U（x）{返回x？。构造函数==对象；}// https://stackoverflow.com/a/46663081/860099函数V（x）{返回x对象实例&&x.constructor==对象；}// -------------//测试// -------------console.log（'列：1 2 3 4 5 6-7 8 9 10 11'）；[A、B、C、D、E、F、G、H、I、J、K、L、M、N、O、P、Q、R、S、T、U、V].map（f=>console.log（`${f.name｝：${1*f（new Date（）））｝${1*f（/./）｝${1*f（｛｝）｝${1*f（Object.prototype）｝｛1*f（Object.create（null））｝$｛1*f（（）=>{}）｝-$｛1*f（“abc”）｝美元｛1*f（3）｝$1 1*（true）｝{1*（null）｝$2 1*f（未定义）｝`）））控制台日志(`列图例（测试用例）：1：新日期（）2: /./ （RegExp）3: {}4:对象.原型5:对象.create（null）6:（）=>｛｝（函数）7:“abc”（字符串）8:3（数字）9：真（布尔值）10:空11：未定义排：1=是对象0=不是对象理论上，第1-6列应有1，第7-11列应有0`);<脚本src=“https://code.jquery.com/jquery-3.5.1.min.js"integrity=“sha256-9/aliU8dGd2tb6OSsuzixeV4y/faTqgFtohetphpj0=”crossoorigin=“匿名”></script><脚本src=“https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.20/lodash.min.js" 完整性=“sha512-90vH1Z83AJY9DmlWa8WkjkV79yfS2n2Oxhsi2dZbIv0nC4E6m5AbH8Nh156kkM7JePmqD6tcZsfad1ueoaovww==”crossoorigin=“匿名”></script>此shippet只显示性能测试中使用的函数，而不执行测试本身！

下面是铬的示例结果

通过逆向选择的不同方法：

我回顾了这里的所有答案，但仍然缺少一种不同的方法。根据MDN文档，JavaScript中的对象是非原始值。基本值：

布尔型Null类型未定义的类型数字类型BigInt类型字符串类型符号类型

基于这一事实，以下方法正在实施逆向选择：

//根据MDN文档检查值是否为原始值：函数为PrimitiveValue（value）{返回(值类型==“符号”||类型值==“字符串”||值类型==“数字”||类型值==“boolean”||类型值==“未定义”||值==空||类型值==“bigint”);};//检查输入是否不是原始值，因此对象：函数isObject（输入）{if（isPrimitiveValue（输入））{return false；}返回true；};console.log（isObject（10））；//假的console.log（isObject（〔｛foo:“bar”｝〕））；//真的console.log（isObject（{a:1，b:2，c:3}））；//真的console.log（isObject（Object.getPrototypeOf（“foo”））；//真的console.log（isObject（符号（“foo”））；//假的console.log（isObject（BigInt（9007199254740991））；//假的console.log（isObject（null））；//假的console.log（isObject（未定义））；//假的console.log（isObject（false））；//假的console.log（isObject（｛｝））；//真的

这取决于用例，如果我们不想让数组和函数成为Object，我们可以使用undercore.js内置函数。

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

这取决于你所说的“是一个物体”。如果您想要所有非原语的内容，即可以设置新财产的内容，那么这应该可以做到：

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

它排除了基元（纯数字/NaN/Infinity、纯字符串、符号、true/false、undefined和null），但其他所有对象（包括Number、Boolean和String对象）都应返回true。注意，JS没有定义当与typeof一起使用时，应该返回哪些“主机”对象，例如窗口或控制台，因此很难用这样的检查来覆盖这些对象。

如果您想知道某个对象是“普通”对象，即它是作为文本｛｝创建的还是使用object.create（null）创建的，您可以这样做：

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

编辑2018：因为Symbol.toStringTag现在允许自定义Object.protoct.toString.call（…）的输出，所以上面的isPlainObject函数在某些情况下可能会返回false，即使对象以文本形式开始其生命。可以说，按照惯例，带有自定义字符串标记的对象不再是纯对象，但这进一步模糊了Javascript中的纯对象定义。