How to reliably check an object is an EcmaScript 6 Map/Set?

Question

I just want to check that an object is a Map or Set and not an Array.

to check an Array I'm using lodash's _.isArray.

function myFunc(arg) {
  if (_.isArray(arg)) {
    // doSomethingWithArray(arg)
  }

  if (isMap(arg)) {
    // doSomethingWithMap(arg)
  }

  if (isSet(arg)) {
    // doSomethingWithSet(arg)
  }
}

If I were to implement isMap/isSet, what does it need to look like? I'd like for it to be able to catch subclasses of Map/Set if possible as well.

Answer 1

The situation is similar to pre-ES5 methods to detect arrays properly and reliably. See this great article for the possible pitfalls of implementing isArray.

We can use

• obj.constructor == Map/Set, but that doesn't work on subclass instances (and can easily be deceived)
• obj instanceof Map/Set, but that still doesn't work across realms (and can be deceived by prototype mangling)
• obj[Symbol.toStringTag] == "Map"/"Set", but that can trivially be deceived again.

To be really sure, we'd need to test whether an object has a [[MapData]]/[[SetData]] internal slot. Which is not so easily accessible - it's internal. We can use a hack, though:

function isMap(o) {
    try {
        Map.prototype.has.call(o); // throws if o is not an object or has no [[MapData]]
        return true;
    } catch(e) {
        return false;
    }
}
function isSet(o) {
    try {
        Set.prototype.has.call(o); // throws if o is not an object or has no [[SetData]]
        return true;
    } catch(e) {
        return false;
    }
}

For common use, I'd recommend instanceof - it's simple, understandable, performant, and works for most reasonable cases. Or you go for duck typing right away and only check whether the object has has/get/set/delete/add/delete methods.

Answer 2

You can use the instanceof operator:

function isSet(candidate) {
  return candidate instanceof Set;
}

If the candidate object has Set.prototype in its prototype chain, then the instanceof operator returns true.

edit — while the instanceof thing will work most of the time, there are situations in which it won't, as described in Bergi's answer.

Answer 3

You can simply use:

export function isMap(item) {
  return !!item && Object.prototype.toString.call(item) === '[object Map]';
}

export function isSet(item) {
  return !!item && Object.prototype.toString.call(item) === '[object Set]';
}

Unless the prototype of this method was overridden

Answer 4

The following method is used in Vue source code. You can borrow the idea from here.

export const isMap = (val: unknown): val is Map<any, any> =>
  toTypeString(val) === '[object Map]'
export const isSet = (val: unknown): val is Set<any> =>
  toTypeString(val) === '[object Set]'


export const objectToString = Object.prototype.toString
export const toTypeString = (value: unknown): string =>
  objectToString.call(value)

It is easy to understand. After converting the object to string. Then you just need to check the value of string if it is '[object Map]' or '[object Set]'

I highly recommend front-ender read the Utility functions in the source code. You can always find the best practice.

Here is the link to Vue source: https://github.com/vuejs/vue-next/blob/master/packages/shared/src/index.ts

you can find the code I quoted here.

Answer 5

Or check the prototypes:

Object.getPrototypeOf(i) === Map.prototype