15

If you have an instance of an object in javascript, it seems it that can be difficult to find its actual type, ie

var Point2D = function Point2D(x, y) {
  return {
    X: x,
    Y: y
  }
}

var p = new Point2D(1,1);

typeof p // yields just 'Object' not 'Point2D'

One way around it I found was to make the object its own prototype, and then you can gets its name effectively by calling prototype.constructor.name,

var Point2D = function Point2D(x, y) {
  return {
    X: x,
    Y: y,
    prototype: this
  }
}

new Point2D(1,1).prototype.constructor.name // yields 'Point2D'

Would this be an OK way of doing it (what are the pros/cons?) or is there a better practice I am missing out on?

Thanks.

Improve this question
5
  • Point2D(1,1).name doesn't seem to work in FF or chrome. Commented Oct 15, 2011 at 1:00
  • It works for me in Chrome, though I don't know if it's the best way. Commented Oct 15, 2011 at 1:01
  • Does it depend on the function signature? ie var Point2d = function Point2D() { }? Commented Oct 15, 2011 at 1:02
  • @SeanThoman Function.prototype.name is not standard, so it won't be implemented properly or not at all in some browsers. Commented Oct 15, 2011 at 1:37
  • See my edit, I guess this is what you want. Commented Oct 15, 2011 at 1:45

5 Answers 5

Reset to default
6

First we need to fix how you are building your class, since you are tripping in some JS pitfalls and doing some really weird stuff:

function Point2D(x, y){
    //Our constructor/initialization function
    //when run, the 'this object will have
    //Point2D.prototype as its prototype

    this.x = x;
    this.y = y;

    //Don't return a value here! Doing so overrides
    //the default "return this" that we actually want.
}

//You can put things in the Point2D prototype in order to have them
//be shared by all Point2D objects. Normally you want the methods to be shared.
Point2D.prototype.getX = function(){
    return this.x;
};

//Note that there is nothing magical about the "prototype" property.
//It is just where the `new` syntax expects the prototype it will use to be.
//The actual magic property is __proto__ (don't depend on it though
// __proto__ is browser specific and unsafe/evil)

//We now can create points!
var p = new Point2D(17.0, 42.0);
p.getX();

Now we can tackle the part about getting the type names. The better practice you are missing on is not inspecting the type in the first place. From an OO perspective it shouldn't matter how an object is implemented (ts class) but how it behaves and what is its interface (exposed methods and properties). Also, from a Javascript perspective, type names are a second-class hack that don't fit very well with the prototypical OO scheme that is actually used.

Since there are many reasons you could be trying to inspect a type name in the first place, there are many different "best" solutions. Some that I could think of:

  1. If all you case about is "does this object implement a particular point interface" then you can do feature-inspection directly:

    function isPoint(p){
    //check if p has all the methods I expect a point to have:
    //(note that functions are truthy in a boolean context)
    return (p.getX && p.getY);
}

  2. If you use the type names to do dispatching consider using a method instead. Its the natural OO way.

    function speak(obj){
    //fake pseudo-syntax:
    if(obj is of type Cat){ console.log("meow"); }
    if(obj is of type Dog){ console.log("woof"); }
}

    becomes

    Cat.prototype.speak = function(){ console.log("meow"); };
Dog.prototype.speak = function(){ console.log("woof"); };

  3. If you really need some sort of tag, you can explicitely make one, as pointed by some of the other answers already:

    Point2D.prototype.pointType = "2D";

    The advantages here are that you can have more than one class have the same "type" if you need to and that you don't have to worry about any of the tricky instanceof or typeof corner cases.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Thanks for this, very helpful and elaborate, especially the point about looking at the interface as opposed to the type. Cheers!
3

I'm wondering if you want something much simpler like this:

function Point2D(x, y) {
    this.X = x;
    this.Y = y;
}

var p = new Point2D(1,1);

alert(p instanceof Point2D);    // true

Edit:

You could add your own type property:

function Point2D(x, y) {
    this.X = x;
    this.Y = y;
    this.type = "Point2D";
}

var p = new Point2D(1,1);
alert(p.type);   // "Point2D"

You haven't said much about WHY you want to know the type of an object. I would suggest that you might want to rethink that. Whenever possible, type-specific handling of methods should be put into common methods among your objects so that you just ask for an action in a method call and the method implements the type-specific handling in each specific object's method.

Improve this answer

6 Comments

I my case want the function to return an anonymous object. Otherwise this would be fine..however I might be able to work this into a solution.
If the function returns an anonymous object, then its type is an anonymous object. You can't have both here. If you want it to be an instance of Point2D, it has to actually be an instance of Point2D, not an anonymous object. Pick which you really want. Why does it need to be an anonymous object? Both my Point2D function object and your anonymous object have the same properties .X and .Y. The difference with Point2D is you can modify it's prototype so that new instances will have custom methods. And, you can indentify it with instanceof.
You could also add your own property which identifies the type. I added an example to my answer that shows that.
@jfriend00, I want to use an anonymous object so that the returned object can have functions that close over variables in the outer function. Therefore, yes, something has to be added to the anonymous object in order to indicate its type, unless there is some other trick I don't know about. That or a better practice for adding said indicator to the anonymous object.
@jfriend00, I could also just name an inner function the same as the outer function, which may work..
|
1

Typeof tells you only if var x is:

  • a string
  • a number
  • a boolean
  • an object (any object, function, array ... actually everything else)

Now variable.constructor tells you which function actually created current object.

There also is a difference:

var foo = function Test(){

};

var x = new foo();
// Here, x.constructor == function Test(){};
// and x.constructor.name == 'Test'

function Bar(){

}

var y = new Bar();
// But here, y.constrcutor == 'Bar'
Improve this answer

1 Comment

This doesn't work either. Are you sure that isn't meant for a different kind of function signature or a function that isn't returning { } or forming a closure?
0

You're not returning Point2D but this:

{
    X: x,
    Y: y
}

which clearly is an object.

What you're looking for, by the way, is p instanceof Point2D.

Edit:

You don't happen to be looking for this pattern, do you?

function Point2D(x, y) {
    var self = this;

    this.X = x;
    this.Y = y;

    this.getX = function(){
        alert(this.X);
    }
}

var p = new Point2D(1,1);
p.getX();
alert(p instanceof Point2D);    // true
Improve this answer

1 Comment

Are you sure that really works all the time? Doesn't work for me. On the returning issue I see your point, however I need the returned object to have functions that perform a closure.
0

Well, it's complicated. You can start with this function:

Actually there are a lot great functions in jQuery. Look at all the utility functions that start with "is" : http://api.jquery.com/category/utilities/

If those aren't good enough, look up their source code here and write your own variations: http://james.padolsey.com/jquery/#v=1.6.2

Also you can use this function:

function listProps (obj) {
    console.log("constructor: "+obj.constructor);
    console.log("prototype "+obj.prototype);

    for (var prop in obj) {
        console.log(prop+": "+obj.prop);
    }
}
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.