Is there a reliable way of getting the instance of a JavaScript object?
For example, relying on the fake 'obj.getInstance()' function.
var T = {
Q: {
W: {
C: function() {}
}
}
};
var x = new T.Q.W.C();
console.log( x.getInstance() === T.Q.W.C); // should output true
If this is not part of the ECMA specification, please include browser/node.js support and compatibility in answers.
Only tested on Chrome:
function FooBar() {
}
var foobar = new FooBar();
console.log(foobar.constructor.name); // Prints 'FooBar'
To get a pointer to the instantiating function (which is not a "class", but is the type), use obj.constructor where obj is any object.
In JavaScript there are no classes. As such, there are no class instances in JavaScript. There are only objects. Objects inherit from other objects (their so called prototypes). What you are doing in your code is literally defining an object T, which's attribute Q is another object, which's attribute W is another object, which's attribute C is a function.
When you are "creating a new instance of T.Q.W.C", you are actually only calling the function T.Q.W.C as a constructor. A function called as a constructor will return a new object on which the constructor function was called (that is with this beeing the new object, like constructorFunction.apply(newObject, arguments);). That returned object will have a hidden property constructor which will point to the function that was invoked as a constrcutor to create the object. Additionally there is a language feature which allows you to test if a given function was used as the constructor function for an object using the instanceof operator.
So you could do the following:
console.log(x instanceof T.Q.W.C);
OR
console.log(x.constructor === T.Q.W.C);
In case anyone is still reading this in 2017:
Be careful about using obj.constructor, as it is not an immutable property.
The instanceof operator is generally more reliable. You can also use Object.getPrototypeOf(obj):
var arr = [];
arr instanceof Array; // true
Object.getPrototypeOf(arr); // Array [ ]
Object.getPrototypeOf(arr) === Array.prototype; // true
See this useful document on the topic:
https://github.com/getify/You-Dont-Know-JS/blob/master/this%20%26%20object%20prototypes/ch5.md
I had some trouble with this, the solution was:
String(x.constructor) === String(T.Q.W.C)
You can do :
get(){ // Method
for ( var nameOfVariable in window )
if (eval(nameOfVariable +"=== this")) return nameOfVariable;// true if variable name is instace of this
return "";
}
Be aware that contructor.name cannot be used with minifying (it will be an empty string) - only instanceof can be used here.
var obj = new Template() will have a obj.constructor.name property available.
xis an instance and yes, usingnewis pretty reliable to get an instance. Maybe you are looking forinstancof, to get the type of the instance? developer.mozilla.org/en/JavaScript/Reference/Operators/Special/…Object.getPrototypeOf(instanceName).constructorto safely access (due to immutability) the object's constructor function, which will be its actual JS type (e.g. the type of itsclass, or justObject,Function,Number,String, etc.), and then usetheType.nameto get the string name of said type. For unsafe access, you could simply useinstanceName.constructor.instanceoflike the other comments/answers describe. More likely one would be usingclasses withextendsfor inheritance..prototype) and then usesuper.constructorinstead. Note that here you can't useObject.getPrototypeOf(super), becausesuperis just a JS keyword. You could then for instancereturnthe type from the function. It seems that you can only ever access 1super, the immediate parent, though... Another approach would be to storethis.constructororsuper.constructoras a property of eachclass............................................