How to check if a function is of given class type in javascript?

Question

I want to be able to check if a function is of a given class type in javascript. For example, let's say I have two classes:

class Horse {}
class Chicken {}

And let's say I want to create a function that will tell me if a function passed is Horse, something like that:

function isHorseClass(func) {
    // check if func is of Horse class type
    return isHorse;
}

The function will be called in the following way:

isHorseClass(Horse) // should return true
isHorseClass(Chicken) // should return false

Notice that the class is passed dynamically without instantiating the object of a class, so I cannot use instanceof to check the type here. Is there a way to check the type of the class dynamically, like in the example above?

Does this answer your question? [Get the name of an object's type](https://stackoverflow.com/questions/332422/get-the-name-of-an-objects-type) — Yogi, Apr 24 '22 at 16:48

Som Shekhar Mukherjee · Answer 1 · 2022-04-24T16:56:06.417

1

Just create an instance and check using the instanceof operator.

class Horse {}
class Dog {}
class SubHorse extends Horse {}

function isHorseClass(Cls) {
  const instance = new Cls();
  return instance instanceof Horse;
}

console.log(isHorseClass(Horse));
console.log(isHorseClass(Dog));
console.log(isHorseClass(SubHorse));

The above answer returns true even for subclasses of Horse, if you just want an exact match use const isHorseClass = () => Cls === Horse.

edited Apr 24 '22 at 16:56

answered Apr 24 '22 at 16:40

Som Shekhar Mukherjee

4,701
1
12
28

Why not just `cls === Horse`? There's no reason to go through the `prototype` property. But note that this will miss `Horse` subclasses. – T.J. Crowder Apr 24 '22 at 16:41
1

@T.J.Crowder Yeah my bad `Cls === Horse` just works fine, I've updated my answer to cover subclasses as well! – Som Shekhar Mukherjee Apr 24 '22 at 16:46
@T.J.Crowder Do you see any problems with creating an instance and then using `instanceof`? – Som Shekhar Mukherjee Apr 24 '22 at 16:57
The function may not have the necessary information to create an instance (or the constructor may not even allow direct creation of instances). – T.J. Crowder Apr 24 '22 at 17:29

score 1 · Accepted Answer · answered Apr 24 '22 at 16:48

For an exact match, you can just use ===:

function isHorseClass(func) {
    return func === Horse;
}

function isHorseClass(func) {
    return func === Horse;
}

class Horse {}
class Chicken {}

console.log("Horse", isHorseClass(Horse));     // true
console.log("Chicken", isHorseClass(Chicken)); // false

...but if you want to also get true for Horse subclasses, then that's possible with class syntax (not as much with the older ES5 syntax, but keep reading). You can do this:

function isHorseClass(func) {
    while (func && func !== Function.prototype) {
        if (func === Horse) {
            return true;
        }
        func = Object.getPrototypeOf(func);
    }
    return false;
}

That works because class syntax sets up two inheritance lines: one for the prototype assigned to instances, and a different one for the constructor functions themselves. For instance:

class Horse {}
class Thoroughbred extends Horse {}

That creates these two chains:

Thoroughbred.prototype −−−−> Horse.prototype −−−−> Object.prototype
Thoroughbred           −−−−> Horse            −−−> Function.prototype

This is fairly unique to JavaScript. :-)

Live Example:

function isHorseClass(func) {
    while (func && func !== Function.prototype) {
        if (func === Horse) {
            return true;
        }
        func = Object.getPrototypeOf(func);
    }
    return false;
}

class Horse {}
class Thoroughbred extends Horse {}
class Chicken {}

console.log("Horse", isHorseClass(Horse));               // true
console.log("Thoroughbred", isHorseClass(Thoroughbred)); // true
console.log("Chicken", isHorseClass(Chicken));           // false

With ES5, though (including standard versions of how class syntax is transpiled to ES5), you can't do that because they usually don't set up the constructor function inheritance (because you couldn't without ES2015+ featuers). You can get close by checking just the prototype chain, though. Combining that with the earlier version:

function isHorseClass(func) {
    while (func && func !== Function.prototype) {
        if (func === Horse || func.prototype === Horse.prototype) {
            return true;
        }
        func = Object.getPrototypeOf(func);
    }
    return false;
}

That will produce false positives. For instance, if I did this:

function Horse() {
}
function Unrelated() {
}
Unrelated.prototype = Horse.prototype;

...it would produce a false positive for Unrelated.

Arguably, `Unrelated` **really is** a “subclass” (sub-something, anyway) of `Horse` in that example: JavaScript is fundamentally prototype-based in how it implements being object-oriented, rather than the typical class-based approach. JavaScript classes are really just syntactic sugar on setting up the prototypes. — KRyan, Apr 25 '22 at 04:39
@KRyan - Yes, JavaScript is prototypical, but I would say that no, `Unrelated` is not a subtype of `Horse`, though as you say there is a relationship of some kind. It just has the same prototype. The *constructors* are different and may give the objects very different shapes (aside from what they inherit from their prototypes). — T.J. Crowder, Apr 25 '22 at 06:20

How to check if a function is of given class type in javascript?

2 Answers2