¿Hay un equivalente de JavaScript de Java class.getName()?
No se .
Actualización de ES2015 : el nombre de class Foo {}esFoo.name . El nombre de thingla clase, independientemente del thingtipo, es thing.constructor.name. Los constructores incorporados en un entorno ES2015 tienen la namepropiedad correcta ; por ejemplo (2).constructor.namees "Number".
Pero aquí hay varios hacks que se caen de una forma u otra:
Aquí hay un truco que hará lo que necesita: tenga en cuenta que modifica el prototipo del Objeto, algo que la gente desaprueba (generalmente por una buena razón)
Object.prototype.getName = function() {
var funcNameRegex = /function (.{1,})\(/;
var results = (funcNameRegex).exec((this).constructor.toString());
return (results && results.length > 1) ? results[1] : "";
};
Ahora, todos sus objetos tendrán la función getName(), que devolverá el nombre del constructor como una cadena. He probado esto FF3y IE7no puedo hablar de otras implementaciones.
Si no desea hacer eso, aquí hay una discusión sobre las diversas formas de determinar los tipos en JavaScript ...
Recientemente actualicé esto para que sea un poco más exhaustivo, aunque difícilmente sea eso. Correcciones bienvenidas ...
Usando la constructorpropiedad ...
Cada uno objecttiene un valor para su constructorpropiedad, pero dependiendo de cómo objectse construyó y de qué quiere hacer con ese valor, puede ser útil o no.
En términos generales, puede usar la constructorpropiedad para probar el tipo de objeto de la siguiente manera:
var myArray = [1,2,3];
(myArray.constructor == Array); // true
Entonces, eso funciona lo suficientemente bien para la mayoría de las necesidades. Dicho eso ...
Advertencias
No funciona en absoluto en muchos casos
Este patrón, aunque roto, es bastante común:
function Thingy() {
}
Thingy.prototype = {
method1: function() {
},
method2: function() {
}
};
Objectsconstruido vía new Thingytendrá una constructorpropiedad que apunta a Object, no Thingy. Entonces caemos desde el principio; simplemente no puedes confiar constructoren una base de código que no controlas.
Herencia múltiple
Un ejemplo en el que no es tan obvio es usar la herencia múltiple:
function a() { this.foo = 1;}
function b() { this.bar = 2; }
b.prototype = new a(); // b inherits from a
Las cosas ahora no funcionan como es de esperar que:
var f = new b(); // instantiate a new object with the b constructor
(f.constructor == b); // false
(f.constructor == a); // true
Por lo tanto, puede obtener resultados inesperados si la objectprueba tiene un objectconjunto diferente como tal prototype. Hay formas de evitar esto fuera del alcance de esta discusión.
Hay otros usos para la constructorpropiedad, algunos interesantes, otros no tanto; por ahora no profundizaremos en esos usos ya que no es relevante para esta discusión.
No funcionará entre marcos y ventanas cruzadas
El uso .constructorpara la verificación de tipo se interrumpirá cuando desee verificar el tipo de objetos que provienen de diferentes windowobjetos, por ejemplo, de un iframe o una ventana emergente. Esto se debe a que hay una versión diferente de cada tipo de núcleo constructoren cada 'ventana', es decir
iframe.contentWindow.Array === Array // false
Usar el instanceofoperador ...
El instanceofoperador también es una forma limpia de probar el objecttipo, pero tiene sus propios problemas potenciales, al igual que la constructorpropiedad.
var myArray = [1,2,3];
(myArray instanceof Array); // true
(myArray instanceof Object); // true
Pero instanceofno funciona para valores literales (porque los literales no lo son Objects)
3 instanceof Number // false
'abc' instanceof String // false
true instanceof Boolean // false
Los literales deben estar envueltos en un Objectpara instanceofque funcionen, por ejemplo
new Number(3) instanceof Number // true
La .constructorcomprobación funciona bien para los literales porque la .invocación del método envuelve implícitamente los literales en su tipo de objeto respectivo
3..constructor === Number // true
'abc'.constructor === String // true
true.constructor === Boolean // true
¿Por qué dos puntos para los 3? Porque Javascript interpreta el primer punto como un punto decimal;)
No funcionará entre marcos y ventanas cruzadas
instanceoftampoco funcionará en diferentes ventanas, por la misma razón que la constructorverificación de propiedad.
Usar la namepropiedad de la constructorpropiedad ...
No funciona en absoluto en muchos casos
De nuevo, ver arriba; Es bastante común constructorque esté completamente equivocado e inútil.
NO funciona en <IE9
El uso myObjectInstance.constructor.namele dará una cadena que contiene el nombre de la constructorfunción utilizada, pero está sujeta a las advertencias sobre la constructorpropiedad que se mencionó anteriormente.
Para IE9 y superior, puede parchear en soporte :
if (Function.prototype.name === undefined && Object.defineProperty !== undefined) {
Object.defineProperty(Function.prototype, 'name', {
get: function() {
var funcNameRegex = /function\s+([^\s(]+)\s*\(/;
var results = (funcNameRegex).exec((this).toString());
return (results && results.length > 1) ? results[1] : "";
},
set: function(value) {}
});
}
Versión actualizada del artículo en cuestión. Esto se agregó 3 meses después de que se publicó el artículo, esta es la versión recomendada para usar por el autor del artículo Matthew Scharley. Este cambio se inspiró en los comentarios que señalaban posibles dificultades en el código anterior.
if (Function.prototype.name === undefined && Object.defineProperty !== undefined) {
Object.defineProperty(Function.prototype, 'name', {
get: function() {
var funcNameRegex = /function\s([^(]{1,})\(/;
var results = (funcNameRegex).exec((this).toString());
return (results && results.length > 1) ? results[1].trim() : "";
},
set: function(value) {}
});
}
Usando Object.prototype.toString
Resulta que, como se detalla en esta publicación , puede usar Object.prototype.toStringla implementación genérica y de bajo nivel de toStringpara obtener el tipo para todos los tipos integrados
Object.prototype.toString.call('abc') // [object String]
Object.prototype.toString.call(/abc/) // [object RegExp]
Object.prototype.toString.call([1,2,3]) // [object Array]
Se podría escribir una función auxiliar breve como
function type(obj){
return Object.prototype.toString.call(obj).slice(8, -1);
}
para eliminar el cruft y obtener solo el nombre del tipo
type('abc') // String
Sin embargo, regresará Objectpara todos los tipos definidos por el usuario.
Advertencias para todos ...
Todos estos están sujetos a un problema potencial, y esa es la cuestión de cómo se construyó el objeto en cuestión. Aquí hay varias formas de construir objetos y los valores que devolverán los diferentes métodos de verificación de tipos:
// using a named function:
function Foo() { this.a = 1; }
var obj = new Foo();
(obj instanceof Object); // true
(obj instanceof Foo); // true
(obj.constructor == Foo); // true
(obj.constructor.name == "Foo"); // true
// let's add some prototypical inheritance
function Bar() { this.b = 2; }
Foo.prototype = new Bar();
obj = new Foo();
(obj instanceof Object); // true
(obj instanceof Foo); // true
(obj.constructor == Foo); // false
(obj.constructor.name == "Foo"); // false
// using an anonymous function:
obj = new (function() { this.a = 1; })();
(obj instanceof Object); // true
(obj.constructor == obj.constructor); // true
(obj.constructor.name == ""); // true
// using an anonymous function assigned to a variable
var Foo = function() { this.a = 1; };
obj = new Foo();
(obj instanceof Object); // true
(obj instanceof Foo); // true
(obj.constructor == Foo); // true
(obj.constructor.name == ""); // true
// using object literal syntax
obj = { foo : 1 };
(obj instanceof Object); // true
(obj.constructor == Object); // true
(obj.constructor.name == "Object"); // true
Si bien no todas las permutaciones están presentes en este conjunto de ejemplos, es de esperar que haya suficientes para darle una idea acerca de lo desordenado que podrían ser las cosas según sus necesidades. No asumas nada, si no entiendes exactamente lo que estás buscando, puedes terminar con el descifrado del código donde no esperas que lo hagas debido a la falta de asimilar las sutilezas.
NOTA:
La discusión sobre el typeofoperador puede parecer una omisión evidente, pero realmente no es útil para ayudar a identificar si un tipo objectes dado, ya que es muy simplista. Comprender dónde typeofes útil es importante, pero actualmente no siento que sea terriblemente relevante para esta discusión. Sin embargo, mi mente está abierta al cambio. :)