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

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]））}}

if(typeof value === 'object' && value.constructor === Object)
{
    console.log("This is an object");
}

我认为有这么多答案的原因是，无论你是否喜欢，很多东西都是javascript中的对象。

您可以像任何其他对象一样迭代数组的“键”。。。

var key, 
    arr = ['one', 'two', 'three'];
for (key in arr)
    console.log(`${key}=${arr[key]}`);

console.log(arr[1]);
console.log(arr['1']);

// 0=one
// 1=two
// 2=three
// two
// two

数组是特殊的（像许多对象一样），因为它有一些通用对象没有的财产/方法（例如长度、forEach等）。

所以这个问题应该是：如何过滤特定类型的对象？

毕竟，我可以很容易地实现自己的数组、正则表达式或符号，它也可以是一个对象，但可能会通过各种“它是真实对象吗？”测试。。。。因为它是一个真实的物体。

所以你想过滤到某些类型的javascript对象。。。

最好的方法是只做特性测试。例如，您是否关心它是否具有长度属性？示例：浏览器中的NodeList看起来像一个数组，可以像数组一样迭代，但不是数组。

无论如何，如果您只想过滤掉特定类型的对象，那么只有您才能定义要过滤的对象。是否要筛选出RegExp？日期大堆浏览器DOM对象？只有你才能决定你的过滤链是什么样子。您可以使用直通开关来构建紧凑的过滤器。

function typeOfIs(val, type) {
    return typeof val == type;
}

function constructorIs(val, constructor) {
    return val && constructor && val.constructor === constructor;
}

function isObject(val) {
    // catch the easy non-object values
    if (!typeOfIs(val, 'object')) 
        return false;

    // catch the cases you don't want to consider to be 
    // "real" objects for your use-case
    switch (true) {
        case val === null:
        case Array.isArray(val):
        case typeOfIs(val, 'function'):
        case constructorIs(val, RegExp):
            return false;
        default:
            return true;
    }
}
function test(val) {
    console.log(Object.prototype.toString.call(val)+': '+isObject(val));
}
test(undefined);
test(null);
test(function () {});
test(Symbol('foo'));
test(1);
test(true);
test(false);
test('hello world');
test([]);
test(/.*/g);
test(new Date()); // true (because we didn't filter for it)
test({});  // true

特性测试

但更好的方法可能是询问为什么要筛选，或者只测试给定变量上是否存在您需要/期望的财产/函数。。。如果它们存在，使用变量，不要担心它是某种类型的对象还是另一种类型的对象。如果它们不存在，则抛出一个API错误，即您被传递了一些类型不正确的值（即缺少预期的财产/函数）。

e.g.

if (typeof someVariable.hasOwnProperty == 'function')
    // ...

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

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

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

我被要求提供更多细节。检查变量是否为对象的最简单易懂的方法是myVar类型。它返回一个带有类型的字符串（例如“object”、“undefined”）。

不幸的是，Array和null都有一个类型对象。要仅获取真实对象，需要使用instanceof运算符检查继承链。它将消除null，但Array在继承链中有Object。

因此，解决方案是：

if (myVar instanceof Object && !(myVar instanceof Array)) {
  // code for objects
}