I have a function I need to pass an object to. I use typeof operator to make a check before processing. But looking at this link, it appears that many javascript instances, such as array or regex, are typed as Objects.
I need my argument to be a pure object (like this : {key: value, . . .}).
Is their any way I can check if a variable is pure object, without having to run specific test for each Object instance, like Array.isArray() ?
To achieve expected result, use below option of finding constructor name to check if variable is pure javascript Object or not
As per MDN,
All objects (with the exception of objects created with Object.create(null)) will have a constructor property. Objects created without the explicit use of a constructor function (i.e. the object and array literals) will have a constructor property that points to the Fundamental Object constructor type for that object.
Please refer this link for more details on constructor property - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor
var x = {a:1,b:2};
var y = [1,2,3];
console.log(x.constructor.name === "Object")//x.constructor.name is Object
console.log(y.constructor.name === "Object")//y.constructor.name is ArrayYou can check prototypes:
function isPureObject(input) {
return null !== input &&
typeof input === 'object' &&
Object.getPrototypeOf(input).isPrototypeOf(Object);
}
console.log(isPureObject({})); // true
console.log(isPureObject(new Object())); // true
console.log(isPureObject(undefined)); // false
console.log(isPureObject(null)); // false
console.log(isPureObject(1)); // false
console.log(isPureObject('a')); // false
console.log(isPureObject(false)); // false
console.log(isPureObject([])); // false
console.log(isPureObject(new Array())); // false
console.log(isPureObject(() => {})); // false
console.log(isPureObject(function () {})); // false
console.log(isPureObject(new Date())); // false
console.log(isPureObject(new RegExp())); // false
function myFunction (){ /* ... */ } test it isPureObject(myFunction) and will return truethe shortest version
const isObj = o => o?.constructor === Object;
found here: https://stackoverflow.com/a/61684890/7138254
If you just want to check for "normal" pure objects (the ones created by {...}, JSON.parse(...), etc.), then this function will work
function is_pure_object(val) {
return val ? Object.getPrototypeOf(val)==Object.prototype : false
}
If you also need to handle objects without a prototype (very rare, only created by Object.create(null)), then you need to do an additional check:
function is_pure_object2(val) {
if (!val)
return false
let proto = Object.getPrototypeOf(val)
return proto == Object.prototype || proto == null
}
Notes about other solutions:
val.constructor is not reliable:
{constructor: 1}Object.create(null)Object.prototype.constructor is modifiedObject.getPrototypeOf(val).isPrototypeOf(Object) is also not ideal:
Object.create(null)Object.prototype.isPrototypeOf is modified(Object.prototype being modified is unlikely, but I've dealt with it before)
Detection of a plain object is a bit problematic because of the definition of "plain" or "pure". I use the following method to detect plain objects. I never use x instanceof NodeList type validations because they do not work on cross-frame situations. (each window or frame has its own instance)
I think this is the simplest and most effective way of detecting plain objects.
function isPlainObject(o) {
var c = Object.prototype.toString.call(o) == '[object Object]'
&& o.constructor && o.constructor.name=="Object";
return c === true;
}
function myTestFunction(){
/* ... */
}
class myTestClass{
/* ... */
}
console.log( isPlainObject({"a":1,"b":2}) ); //true
console.log( isPlainObject({}) ); //true
console.log( isPlainObject(null) ); //false
console.log( isPlainObject("my string") ); //false
console.log( isPlainObject("") ); //false
console.log( isPlainObject([1,2,3]) ); //false
console.log( isPlainObject(document.querySelectorAll("*")) ); //false
console.log( isPlainObject(new RegExp(/[a-z]+/)) ); //false
console.log( isPlainObject(myTestFunction) ); //false
console.log( isPlainObject(new myTestFunction()) ); //false
console.log( isPlainObject(myTestClass) ); //false
console.log( isPlainObject(new myTestClass()) ); //false
return c === true ? true : false; can be simplified to just return c === true;return c === true is a better way. I edited it. Thanks.typeof o === 'object' is a little bit redundant in the context of your implementation (as soon as you're relying on the .toString implementation) see more in tc39.es/ecma262/#sec-object.prototype.tostringnull - this typeof o === 'object' will result in 1000000 unnecessary checks.Using the lodash library, you can achieve this with the following function:
const isPureObject = _.isPlainObject({ foo: 'Zebra' });
expect(isPureObject).to.be.true;
const isMapPureObject = _.isPlainObject(new Map());
expect(isMapPureObject).to.be.false;
The official docs can be found here.
Boolean(obj) && obj.constructor === Objectbe good enough for you, knowing that even objects that are instances of any class wouldn’t be matched?Object.getPrototypeOf(variable) === Object.prototypeHTMLElement(etc), you can useinstanceof. The "plain object" is theelsecase.