Existe um equivalente em JavaScript ao Java class.getName()?
Não .
Atualização do ES2015 : o nome de class Foo {}éFoo.name . O nome da thingclasse de, independentemente do thingtipo, é thing.constructor.name. Construtores internos em um ambiente ES2015 têm a namepropriedade correta ; por exemplo (2).constructor.nameé "Number".
Mas aqui estão vários hacks que caem de uma maneira ou de outra:
Aqui está um truque que fará o que você precisa - saiba que ele modifica o protótipo do objeto, algo que as pessoas desaprovam (geralmente por um bom motivo)
Object.prototype.getName = function() {
var funcNameRegex = /function (.{1,})\(/;
var results = (funcNameRegex).exec((this).constructor.toString());
return (results && results.length > 1) ? results[1] : "";
};
Agora, todos os seus objetos terão a função,, getName()que retornará o nome do construtor como uma string. Eu testei isso FF3e IE7não posso falar em outras implementações.
Se você não quiser fazer isso, aqui está uma discussão sobre as várias maneiras de determinar tipos em JavaScript ...
Eu atualizei isso recentemente para ser um pouco mais exaustivo, embora dificilmente seja isso. Correções bem-vindas ...
Usando a constructorpropriedade ...
Cada objectum tem um valor para sua constructorpropriedade, mas, dependendo de como isso objectfoi construído e do que você deseja fazer com esse valor, ele pode ou não ser útil.
De um modo geral, você pode usar a constructorpropriedade para testar o tipo de objeto da seguinte maneira:
var myArray = [1,2,3];
(myArray.constructor == Array); // true
Então, isso funciona bem o suficiente para a maioria das necessidades. Dito isto...
Ressalvas
Não vai funcionar AT ALL , em muitos casos
Esse padrão, embora quebrado, é bastante comum:
function Thingy() {
}
Thingy.prototype = {
method1: function() {
},
method2: function() {
}
};
Objectsconstruído via new Thingyterá uma constructorpropriedade que aponta para Object, não Thingy. Então, caímos logo no início; você simplesmente não pode confiar constructorem uma base de código que não controla.
Herança múltipla
Um exemplo em que não é tão óbvio é usar herança múltipla:
function a() { this.foo = 1;}
function b() { this.bar = 2; }
b.prototype = new a(); // b inherits from a
As coisas agora não funcionam como você pode esperar:
var f = new b(); // instantiate a new object with the b constructor
(f.constructor == b); // false
(f.constructor == a); // true
Portanto, você poderá obter resultados inesperados se o objectteste tiver um objectconjunto diferente prototype. Existem maneiras de contornar isso fora do escopo desta discussão.
Existem outros usos para a constructorpropriedade, alguns interessantes, outros nem tanto; por enquanto não nos aprofundaremos nesses usos, pois não é relevante para esta discussão.
Não funcionará em quadros cruzados e em janelas cruzadas
O uso .constructorda verificação de tipo será interrompido quando você quiser verificar o tipo de objetos provenientes de diferentes windowobjetos, digamos o de um iframe ou uma janela pop-up. Isso ocorre porque há uma versão diferente de cada tipo de núcleo constructorem cada `janela ', ou seja,
iframe.contentWindow.Array === Array // false
Usando o instanceofoperador ...
O instanceofoperador também é uma maneira limpa de testar object, mas tem seus próprios problemas em potencial, assim como a constructorpropriedade.
var myArray = [1,2,3];
(myArray instanceof Array); // true
(myArray instanceof Object); // true
Mas instanceoffalha ao trabalhar com valores literais (porque literais não são Objects)
3 instanceof Number // false
'abc' instanceof String // false
true instanceof Boolean // false
Os literais precisam ser agrupados em um Objectpara instanceofque funcionem, por exemplo
new Number(3) instanceof Number // true
A .constructorverificação funciona bem para literais, porque a .invocação do método envolve implicitamente os literais em seu respectivo tipo de objeto
3..constructor === Number // true
'abc'.constructor === String // true
true.constructor === Boolean // true
Por que dois pontos para os 3? Porque o Javascript interpreta o primeiro ponto como um ponto decimal;)
Não funcionará em quadros cruzados e em janelas cruzadas
instanceoftambém não funcionará em janelas diferentes, pelo mesmo motivo que a constructorverificação de propriedade.
Usando a namepropriedade da constructorpropriedade ...
Não funciona AT ALL , em muitos casos
Mais uma vez, veja acima; é bastante comum constructorestar completamente e completamente errado e inútil.
NÃO funciona no <IE9
O uso myObjectInstance.constructor.namefornecerá uma string contendo o nome da constructorfunção usada, mas está sujeita às advertências sobre a constructorpropriedade mencionada anteriormente.
Para o IE9 e superior, você pode fazer um patch de macaco no suporte :
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) {}
});
}
Versão atualizada do artigo em questão. Isso foi adicionado três meses após a publicação do artigo. Essa é a versão recomendada para uso pelo autor do artigo, Matthew Scharley. Essa mudança foi inspirada em comentários apontando possíveis armadilhas no 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
Acontece que, como este post detalha , você pode usar Object.prototype.toString- o baixo nível e implementação genérica de toString- para obter o tipo para todos os tipos internos
Object.prototype.toString.call('abc') // [object String]
Object.prototype.toString.call(/abc/) // [object RegExp]
Object.prototype.toString.call([1,2,3]) // [object Array]
Pode-se escrever uma função auxiliar curta, como
function type(obj){
return Object.prototype.toString.call(obj).slice(8, -1);
}
para remover a crosta e obter apenas o nome do tipo
type('abc') // String
No entanto, ele retornará Objectpara todos os tipos definidos pelo usuário.
Advertências para todos ...
Tudo isso está sujeito a um problema em potencial, e essa é a questão de como o objeto em questão foi construído. Aqui estão várias maneiras de criar objetos e os valores que os diferentes métodos de verificação de tipo retornarão:
// 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
Embora nem todas as permutações estejam presentes neste conjunto de exemplos, espero que haja o suficiente para fornecer uma idéia sobre como as coisas podem ficar confusas dependendo de suas necessidades. Não assuma nada, se você não entender exatamente o que está procurando, poderá acabar com a quebra de código onde não espera, devido à falta de grokking nas sutilezas.
NOTA:
A discussão sobre o typeofoperador pode parecer uma omissão flagrante, mas realmente não é útil para ajudar a identificar se um objecté um determinado tipo, pois é muito simplista. Entender onde typeofé útil é importante, mas atualmente não acho que seja terrivelmente relevante para essa discussão. Minha mente está aberta para mudar. :)