I have the following javascript code:

function testClass() {
    this.SaveValue = function (value) {
        var isInstance = value instanceof TestEnum;

        if (!isInstance) {
            return;
        }
     }
}

TestEnum = {
    VALUE_0: 0,
    VALUE_1: 1,
    VALUE_2: 2   
}

I create an instance of this object in the following way:

$(function () {
    var a = new testClass();
    a.SaveValue(TestEnum.VALUE_1);    
});

All I'd like to do is test that the value passed to the SaveValue function is actually the type of TestEnum. However, when I run this code I get the following error: Uncaught TypeError: Expecting a function in instanceof check, but got 1

Am I going about this the right way? I tried typeof but it only returns number which is not particularly useful to me.

I have the following javascript code:

function testClass() {
    this.SaveValue = function (value) {
        var isInstance = value instanceof TestEnum;

        if (!isInstance) {
            return;
        }
     }
}

TestEnum = {
    VALUE_0: 0,
    VALUE_1: 1,
    VALUE_2: 2   
}

I create an instance of this object in the following way:

$(function () {
    var a = new testClass();
    a.SaveValue(TestEnum.VALUE_1);    
});

All I'd like to do is test that the value passed to the SaveValue function is actually the type of TestEnum. However, when I run this code I get the following error: Uncaught TypeError: Expecting a function in instanceof check, but got 1

Am I going about this the right way? I tried typeof but it only returns number which is not particularly useful to me.

• javascript
• instanceof

4 Answers 4

You could create the values as instances of the "class":

function TestEnum(value) {
    this._value = value;
}

TestEnum.prototype.valueOf = function() {
    return this._value;
}

TestEnum.prototype.toString = function() {
    return 'TestEnum_' + this._value;
}

TestEnum.VALUE_0 = new TestEnum(0);
TestEnum.VALUE_1 = new TestEnum(1);

The following would work then:

TestEnum.VALUE_0 instanceof TestEnum

But it also means you'd have to explicitly access the numerical value of one value with .valueOf. In some cases JS will do this automatically for you (like in 5 + TestEnum.VALUE_1). Overriding toString so that you can use a value as property might also be necessary.

It really depends on your use case whether this is a viable solution.

Alternatively, if just want to test whether a value is part of the enum, you can have an additional property which holds all possible values:

TestEnum.values = {0: true, 1: true, ...};

And then test it with

value in TestEnum.values
// or more reliable (fails for inherited `Object` properties)
TestEnum.values.hasOwnProperty(value);

You could even automate this:

function collectValues(obj) {
    var values = {}; // or Object.create(null) if available
    for (var prop in obj) {
        if (obj.hasOwnProperty(prop)) {
            values[obj[prop]] = true;
        }
    }
    return values;
}

TestEnum.values = collectValues(TestEnum);

This will only reliably work for primitive values though and won't distinguish between the string "1" and the number 1.

You are passing a number to the function in

a.SaveValue(TestEnum.VALUE_1);

Since TestEnum is simply an Object, and you are referencing a number property on that object, you're calling your function with a number. You should instead create a TestEnumValue object and use that for your Object's properties:

JSFiddle link for below

function testClass() {
    this.SaveValue = function (value) {
        var isInstance = value instanceof TestEnumValue;

        if (!isInstance) {
            return;
        }
     }
}

TestEnumValue = function(arg) {
   arg = arg ? arg : 0;  //  sensible default

   this.key = 'VALUE_' + arg;
   this.val = arg;
}

Level = {
    NumSpiders : new TestEnumValue(0),
    NumCreepers: new TestEnumValue(1),
    NumZombies : new TestEnumValue(2),
    NumChickens: new TestEnumValue  //  uses default enum value    
};

$(function() {
    var a = new testClass();
    a.SaveValue(Level.NumSpiders);

    $('#hi').text(Level.NumSpiders.key);
});

Playing around with this, I noticed that you can leverage the fact that an enum piles into an object that binds the values both ways bined with a hasOwnProperty check.

export enum TEST_ENUM{
    ZERO, // 0
    ONE, // 1
    TWO, // 2
}

let a = 1;
let b = TEST_ENUM.TWO // 2
let c = 5 // incorrect value

TEST_ENUM.hasOwnProperty(a); // TRUE
TEST_ENUM.hasOwnProperty(b); // TRUE
TEST_ENUM.hasOwnProperty(c); // FALSE

This es with a few caveats though;

// An object's keys are always strings...
// Although this shouldn't not matter usually (e.g. parsed user input)
TEST_ENUM.hasOwnProperty("2"); // TRUE

// And the enum is bound two-way so:
let input = "TWO";
if (TEST_ENUM.hasOwnProperty(input) { // TRUE
  let result = input // "TWO"
  // result is now the enum's value, instead of the key.
  result = TEST_ENUM[input]; // this would be the correct assignment
};

Of course you can fix both of these with a typeof check, in case of a string assign it TEST_ENUM[mystring].

Note that my intellisense didn't autoplete the hasOwnProperty function on an enum, but it doesn't plain about it either, and it's available on all browsers.

Edit

Here's an example of how you could do it.

function TestEnum(val) {
    this.vals = this.vals || [];
    if (this.vals.indexOf(val) == -1) console.log('nope: ' + val);
    else console.log('ok: ' + val);
}
(function() {
    var vals = {
        VALUE_0: 0,
        VALUE_1: 1,
        VALUE_2: 2
    };
    TestEnum.prototype.vals = [];
    for (var key in vals) {
        TestEnum[key] = vals[key];
        TestEnum.prototype.vals.push(vals[key]);
    }
})();

Now new TestEnum(TestEnum.VALUE_0); is OK, but if you try, say, new TestEnum(3), then it throws an exception.

This is a bit backwards -- x instanceof y means that x has been created as x = new y(). Since TestEnum isn't even a function, you can't create an instance of it, so this isn't going to work.

What you could do is maybe something like this:

function MyEnum(enumVal) { this.val = enumVal; }
a.SaveValue( new MyEnum(TestEnum.VALUE_1) );

Then check using isInstance = value instanceof MyEnum.