检查值是否是JavaScript中的对象

2020/09/16 16:32 · javascript ·  · 0评论

如何检查值是否是JavaScript中的Object?

更新

这个答案是不完整的,并且会产生误导的结果例如,在JavaScript中null也被视为类型object,更不用说其他几种极端情况了。请遵循以下建议,然后转到其他“获得最高评价(并且正确!)的答案”

typeof yourVariable === 'object' && yourVariable !== null

原始答案

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

编辑:这个答案给出了一个如何检查变量属性的想法,但是它不是防弹配方(毕竟根本没有配方!)来检查它是否是一个对象,而不是对象。由于人们倾向于在不做任何研究的情况下从这里寻找要复制的东西,因此我强烈建议他们转向另一个最受好评(也是正确的)的答案。

如果为typeof yourVariable === 'object',则为对象或null。如果要排除null,则使其为null typeof yourVariable === 'object' && yourVariable !== null

让我们在Javascript中定义“对象”根据MDN docs,每个值都是对象或基元:

原始的原始值

不是对象且没有任何方法的数据。JavaScript具有5种原始数据类型:字符串,数字,布尔值,空值,未定义。

什么是原始语?

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

什么是对象(即不是原始对象)?

  • Object.prototype
  • 一切都源于 Object.prototype
    • Function.prototype
      • Object
      • Function
      • function C(){} -用户定义的功能
    • C.prototype-用户定义函数的prototype属性:这不是 C s的原型

      • new C() -“新”-用户定义的功能
    • Math
    • Array.prototype
      • 数组
    • {"a": 1, "b": 2} -使用文字符号创建的对象
    • new Number(3) -围绕原语的包装
    • ... 许多其他事情 ...
  • Object.create(null)
  • 一切都源于 Object.create(null)

如何检查值是否为对象

instanceof 本身不起作用,因为它错过了两种情况:

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

typeof x === 'object'由于误报(null)和误报(函数)而无法使用

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

Object.prototype.toString.call 由于所有原语的误报,将无法使用:

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

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

所以我用:

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

@Daan的答案似乎也有效:

function isObject(obj) {
  return obj === Object(obj);
}

因为,根据MDN docs

Object构造函数为给定值创建一个对象包装器。如果该值为null或未定义,它将创建并返回一个空对象,否则,将返回一个与给定值对应的类型的对象。如果该值已经是一个对象,它将返回该值。


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

// 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({})

underscore.js提供以下方法来确定某物是否真的是一个对象:

_.isObject = function(obj) {
  return obj === Object(obj);
};

更新

由于V8中存在先前的错误,并且进行了微速度优化,因此该方法自underscore.js 1.7.0(2014年8月)起如下所示

_.isObject = function(obj) {
  var type = typeof obj;
  return type === 'function' || type === 'object' && !!obj;
};

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

  • "[object Object]" 如果myVar是对象
  • "[object Array]" 如果myVar是一个数组
  • 等等

有关此的更多信息以及为什么它是typeof的很好替代方法,参阅本文

用于简单地检查对象或数组,而无需其他函数调用(速度)。就像在这里也张贴

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

isObject() -注意:仅用于对象文字,因为它对自定义对象(例如新的Date或新的YourCustomObject)返回false。

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

我很喜欢:

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

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

DOCS:

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

http://devdocs.io/javascript/global_objects/object

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

http://devdocs.io/javascript/global_objects/null

具有功能Array.isArray

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

没有功能Array.isArray

只是惊讶于有多少票赞成错误答案😮

只有1个答案通过了我的测试!!!在这里,我创建了简化版本:

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

对于我来说,它很简单明了,并且可以正常工作!这是我的测试:

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

一次以上:并非所有答案都通过此测试!🙈


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

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

简单测试:

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

结果,您将获得严格而强大的代码!


如果你不喜欢创建功能isDateisErrorisRegExp,等你可以考虑选择使用这种广义函数:

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

它不能在前面提到的所有测试用例中正常工作,但是对于所有对象(纯对象或构造对象)都足够好。


isObject不会在以下情况下工作Object.create(null)的,因为内部实现Object.create这说明在这里,但你可以用isObject在更复杂的实现:

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上创建了软件包它适用于所有先前描述的测试用例!🙂

哦,我的上帝!我认为这可能比以往更短,让我们看一下:

简短代码和最终代码

function isObject(obj)
{
    return obj != null && obj.constructor.name === "Object"
}

console.log(isObject({})) // returns true
console.log(isObject([])) // returns false
console.log(isObject(null)) // returns false

讲解

返回类型

类型的JavaScript对象(包括null)返回"object"

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

检查他们的构造函数

检查其constructor属性将返回具有其名称的函数。

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"闭包的只读名称

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

注意:从2018年开始,Function.name在IE https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Function/name#Browser_compatibility中可能不起作用

好的,让我们在回答问题之前首先给您一个概念,在JavaScript函数中,对象是Object,null,Object,Arrays甚至Date。因此,您看到没有像typeof obj ==='object'这样的简单方法,上面提到的所有内容都将返回true,但是可以通过编写函数或使用JavaScript框架来检查它,好的:

现在,假设您有一个真实的对象(不是null或函数或数组):

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

纯JavaScript:

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

要么

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

要么

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

要么

function isObject(obj) {
    return obj instanceof Object;
}

您可以通过调用它们,在代码中简单地使用上述函数之一,如果它是一个对象,它将返回true:

isObject(obj);

如果您使用的是JavaScript框架,那么他们通常会为您准备好这些功能,其中很少几个:

jQuery的:

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

角度:

angular.isObject(obj);

下划线和Lodash:

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

天哪,其他答案太混乱了。

简短答案

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

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

情况1。

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

情况二

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

情况3。

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

说明

好吧,让我们分解一下

typeof anyVar == 'object'从三个候选人中返回true [], {} and null

anyVar instanceof Object 将这些候选人缩小为两个- [], {}

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

请打鼓!

到此为止,您可能已经学习了如何在Javascript中检查数组。

这取决于您对“是一个对象”的意思。如果您希望所有不是原始类型的东西(即可以设置新属性的东西),都可以做到这一点:

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

它不包括原语(纯数字/ NaN/ Infinity,普通字符串,符号,true/ falseundefinednull),但应返回其他一切(包括真正的NumberBooleanString对象)。请注意,JS没有定义与结合使用时应返回的“宿主”对象(例如window或),因此很难用这样的检查来覆盖这些对象。consoletypeof

如果您想知道某事物是否是“普通”对象,即它是作为文字创建的{}还是使用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;
    }
}

Edit 2018:因为Symbol.toStringTag现在允许自定义的输出Object.prototype.toString.call(...),所以即使在对象以文字形式开始生存的情况下,上述isPlainObject函数false在某些情况下也可能返回可以说,按照惯例,带有自定义字符串标签的对象不再完全是普通对象,但这进一步混淆了Java中普通对象的定义。

检查值类型的最合理方法似乎是typeof运算符。唯一的问题是它被严重破坏了:

  • 它返回"object"null,属于空类型。
  • 它返回"function"属于对象类型的可调用对象。
  • 它可以返回(几乎)非标准的不可调用对象所需的任何内容。例如,IE似乎喜欢"unknown"唯一禁止的结果是"function"和原始类型。

typeof仅对非null基本类型可靠因此,一种检查值是否为对象的方法将确保由返回的字符串typeof不对应于基元,并且对象不是null但是,问题在于将来的标准可能会引入新的原始类型,并且我们的代码会将其视为对象。新类型不会经常出现,但是例如ECMAScript 6引入了Symbol类型。

因此,代替typeof,我只推荐其结果根据值是否为对象而变化的方法。以下打算成为

全面但不详尽的列表,列出了测试值是否属于对象类型的正确方法。

  • Object 构造函数

    Object构造胁迫传递的参数的对象。如果已经是一个对象,则返回相同的对象。

    因此,您可以使用它来将值强制转换为对象,并将该对象与原始值进行严格比较。

    以下功能需要引入ECMAScript 3 ===

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

    我喜欢这种方法,因为它简单且可自我描述,并且类似的检查也适用于布尔值,数字和字符串。但是,请注意,它依赖于全局Object不被遮盖或更改。

  • 建设者

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

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

    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引入了一种严格的模式,该模式消除了此行为,但是在草率模式下,我们仍然可以(但可以说不应)依靠它。

    function isObject(value) { /* Requires ECMAScript 3 or later in sloppy mode */
      return function() { return this === value; }.call(value);
    }
  • [[原型]]

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

    无论Object.createObject.getPrototypeOf需要的ECMAScript 5。

    function isObject(value) { /* Requires ECMAScript 5 or later */
      try {
        Object.create(value);
        return value !== null;
      } catch(err) {
        return false;
      }
    }
    function isObject(value) { /* Requires ECMAScript 5 or later */
      function Constructor() {}
      Constructor.prototype = value;
      return Object.getPrototypeOf(new Constructor()) === value;
    }
  • 一些新的ECMAScript 6种方式

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


注意:我故意跳过了Object.getPrototypeOf(value)(ES5)和Reflect方法(ES6)之类的一些方法因为它们调用了可能做讨厌事情的基本内部方法,例如,如果value是代理。出于安全原因,我的示例仅供参考,value不能直接访问。

试试这个

if (objectName instanceof Object == false) {
  alert('Not an object');
}
else {
  alert('An object');
}

准备使用的功能进行检查

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中,nullObjectArrayDatefunctions为所有对象。虽然,null有点人为。因此,最好检查第null一个,以检测它是否不为空。

  • 检查typeof o === 'object'保证o是一个对象。没有此检查,Object.prototype.toString将毫无意义,因为它将返回对象,即使对于undefinedand null例如:toString(undefined)return [object Undefined]

    typeof o === 'object'检查,toString.call(O)是检查是否一个伟大的方法o是一个对象,一个派生对象像ArrayDate或一个function

  • isDerivedObject功能上,它检查o是功能。因为功能也是一个对象,所以才存在它。如果没有这样做,函数将返回false。示例:isDerivedObject(function() {})将返回false,但是现在返回true

  • 人们总是可以更改什么是对象的定义。因此,可以相应地更改这些功能。


测验

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(){})
);

如果您想检查prototypefor的object唯一来源Object过滤掉StringNumberArrayArguments,等。

function isObject (n) {
  return Object.prototype.toString.call(n) === '[object Object]';
}

或作为单表达式箭头功能(ES6 +)

const isObject = n => Object.prototype.toString.call(n) === '[object Object]'
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也都有一个type object要仅获取真实对象,需要使用instanceof运算符检查继承链它将消除null,但是Array在继承链中具有Object。

因此解决方案是:

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

有点晚了...“普通对象”(我的意思是,像{'x':5,'y':7})我有这个小片段:

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

它生成下一个输出:

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”但没有null,数组或函数时,if才会返回“ true”。:)

lodash具有isPlainObject,这可能是许多访问此页面的人正在寻找的东西。给定函数或数组时返回false。

这会起作用。它是一个返回true,false或可能为null的函数。

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类型中一个精彩功能。

解释完整功能

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

当我意识到解决方案多么简单和美观时,我不得不大笑。

Ramda 文档中的用法示例

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"

由于对如何正确处理此问题似乎有很多困惑,我将留下2美分(此答案符合规范,并在所有情况下都能产生正确的结果):

测试原语:
undefined null boolean string number

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

对象不是原始的:

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

或者:

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

测试任何阵列:

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['BigInt64Array']=true;
    arrayTypes['BigUint64Array']=true;
    arrayTypes['Float32Array']=true;
    arrayTypes['Float64Array']=true;
    return function(o){
        if (!o) return false;
        return !isPrimitive(o)&&!!arrayTypes[o.constructor.name];
    }
}());

测试对象,不包括:Date RegExp Boolean Number String Function任何数组

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];
    }
}());

阅读和尝试了很多的实现之后,我发现很少有人尝试检查类似值JSONMathdocument再与原型链或物体比1步。

typeof我认为与其检查变量的大小然后消除边缘情况,不如将检查保持尽可能简单,以免在添加新的原始对象或本机对象注册为typeof“对象” 时避免重构。'。

毕竟,typeof操作员会告诉您某个对象是否是JavaScript的对象,但是JavaScript的对象定义对于大多数实际场景(例如typeof null === 'object')而言过于宽泛下面是一个函数,该函数v通过本质上重复两次检查来确定变量是否为对象:

  1. 一个循环开始,只要区域的字符串版本继续v'[object Object]'

    我希望函数的结果与下面的日志完全一样,所以这是我最后得到的唯一“对象”条件。
    如果失败,该函数立即返回false。
  2. v被替换为链中的下一个原型,v = Object.getPrototypeOf(v)之后也直接进行评估。当新值为vis时null,这意味着包括根原型在内的每个原型(很可能是链中唯一的原型)都已通过while循环中的检查,我们可以返回true。否则,将开始新的迭代。
function isObj (v) {
  while (     Object.prototype.toString.call(v) === '[object Object]')
  if    ((v = Object.getPrototypeOf(v))         === null)
  return true
  return false
}

console.log('FALSE:')
console.log('[]                   -> ', isObj([]))
console.log('null                 -> ', isObj(null))
console.log('document             -> ', isObj(document))
console.log('JSON                 -> ', isObj(JSON))
console.log('function             -> ', isObj(function () {}))
console.log('new Date()           -> ', isObj(new Date()))
console.log('RegExp               -> ', isObj(/./))

console.log('TRUE:')
console.log('{}                   -> ', isObj({}))
console.log('new Object()         -> ', isObj(new Object()))
console.log('new Object(null)     -> ', isObj(new Object(null)))
console.log('new Object({})       -> ', isObj(new Object({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 inheritance     -> ', isObj(Object.create(Object.create({foo: 'bar'}))))

这是一个可选链的答案,也许是isObj这个问题的最小函数。

const isObj = o => o?.constructor === Object;

// True for this
console.log(isObj({}));        // object!

// False for these
console.log(isObj(0));         // number
console.log(isObj([]));        // array
console.log(isObj('lol'));     // string
console.log(isObj(null));      // null
console.log(isObj(undefined)); // undefined
console.log(isObj(() => {}));  // function
console.log(isObj(Object));    // class

当其他所有方法都失败时,我将使用以下方法:

var isObject = function(item) {
   return item.constructor.name === "Object";
}; 
if(typeof value === 'object' && value.constructor === Object)
{
    console.log("This is an object");
}

如果明确想检查给定的值是否为{}

function isObject (value) {
 return value && typeof value === 'object' && value.constructor === Object;
}
const isObject = function(obj) {
  const type = typeof obj;
  return type === 'function' || type === 'object' && !!obj;
};

!!obj是检查是否obj真实的简写(以筛选出null

这是一个古老的问题,但考虑将其留在这里。大多数人都在检查变量是否{}意味着配对的键值,而不是JavaScript用于给定事物的下划线结构,说实话,因为JavaScript中的大多数内容都是对象。因此,将其删除。如果你做...

let x = function() {}
typeof x === 'function' //true
x === Object(x) // true
x = []
x === Object(x) // true

// also
x = null
typeof null // 'object'

大多数时候,我们想要知道的是我们是否有API的资源对象或ORM返回的数据库调用。然后,我们可以测试是否不是Array,不是null,不是typeof 'function'以及是Object

// To account also for new Date() as @toddmo pointed out

x instanceof Object && x.constructor === Object

x = 'test' // false
x = 3 // false
x = 45.6 // false
x = undefiend // false
x = 'undefiend' // false
x = null // false
x = function(){} // false
x = [1, 2] // false
x = new Date() // false
x = {} // true

出于我的代码的目的,我找到了与上述某些答案相对应的决定:

ES6变体:

const checkType = o => Object.prototype
                    .toString
                    .call(o)
                    .replace(/\[|object\s|\]/g, '')
                    .toLowerCase();

ES5变体:

function checkType(o){
   return Object.prototype
                    .toString
                    .call(o)
                    .replace(/\[|object\s|\]/g, '')
                    .toLowerCase();
}

您可以非常简单地使用它:

checkType([]) === 'array'; // true
checkType({}) === 'object'; // true
checkType(1) === 'number'; // true
checkType('') === 'string'; // true
checkType({}.p) === 'undefined'; // true
checkType(null) === 'null'; // true

等等..

本文地址:http://javascript.askforanswer.com/jianchazhishifoushijavascriptzhongdeduixiang.html
文章标签: ,   ,   ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!