Esiste un equivalente JavaScript di Java class.getName()?
No .
Aggiornamento ES2015 : il nome di class Foo {}èFoo.name . Il nome della thingclasse, indipendentemente dal thingtipo, è thing.constructor.name. I costruttori incorporati in un ambiente ES2015 hanno la nameproprietà corretta ; per esempio (2).constructor.nameè "Number".
Ma qui ci sono vari hack che cadono tutti in un modo o nell'altro:
Ecco un hack che farà ciò di cui hai bisogno: tieni presente che modifica il prototipo dell'Oggetto, qualcosa che la gente non vede bene (di solito per una buona ragione)
Object.prototype.getName = function() {
var funcNameRegex = /function (.{1,})\(/;
var results = (funcNameRegex).exec((this).constructor.toString());
return (results && results.length > 1) ? results[1] : "";
};
Ora, tutti i tuoi oggetti avranno la funzione getName(), che restituirà il nome del costruttore come una stringa. Ho provato questo FF3e IE7, non posso parlare per altre implementazioni.
Se non vuoi farlo, ecco una discussione sui vari modi di determinare i tipi in JavaScript ...
Recentemente ho aggiornato questo per essere un po 'più esaustivo, anche se non è così. Correzioni benvenute ...
Utilizzo della constructorproprietà ...
Ognuno objectha un valore per la sua constructorproprietà, ma a seconda di come è objectstato costruito e di ciò che vuoi fare con quel valore, potrebbe essere utile o meno.
In generale, è possibile utilizzare la constructorproprietà per testare il tipo di oggetto in questo modo:
var myArray = [1,2,3];
(myArray.constructor == Array); // true
Quindi, funziona abbastanza bene per la maggior parte delle esigenze. Detto ciò...
Avvertenze
Non funziona AFFATTO in molti casi
Questo modello, sebbene rotto, è abbastanza comune:
function Thingy() {
}
Thingy.prototype = {
method1: function() {
},
method2: function() {
}
};
Objectscostruito via new Thingyavrà una constructorproprietà che punta a Objectno Thingy. Quindi cadiamo proprio all'inizio; semplicemente non puoi fidarti constructordi una base di codice che non controlli.
Ereditarietà multipla
Un esempio in cui non è così ovvio è l'utilizzo dell'ereditarietà multipla:
function a() { this.foo = 1;}
function b() { this.bar = 2; }
b.prototype = new a(); // b inherits from a
Le cose ora non funzionano come ci si potrebbe aspettare che:
var f = new b(); // instantiate a new object with the b constructor
(f.constructor == b); // false
(f.constructor == a); // true
Quindi, potresti ottenere risultati imprevisti se il objecttuo test ha un objectset diverso come suo prototype. Ci sono modi per aggirare questo al di fuori dell'ambito di questa discussione.
Ci sono altri usi per la constructorproprietà, alcuni interessanti, altri meno; per ora non approfondiremo questi usi poiché non è rilevante per questa discussione.
Non funzionerà cross-frame e cross-window
L'uso .constructorper il controllo del tipo si interromperà quando si desidera controllare il tipo di oggetti provenienti da windowoggetti diversi , ad esempio quello di un iframe o di una finestra popup. Questo perché esiste una versione diversa di ciascun tipo di core constructorin ciascuna `finestra ', cioè
iframe.contentWindow.Array === Array // false
Utilizzo instanceofdell'operatore ...
L' instanceofoperatore è anche un modo pulito di testare il objecttipo, ma ha i suoi potenziali problemi, proprio come la constructorproprietà.
var myArray = [1,2,3];
(myArray instanceof Array); // true
(myArray instanceof Object); // true
Ma instanceofnon funziona per valori letterali (perché i letterali non lo sono Objects)
3 instanceof Number // false
'abc' instanceof String // false
true instanceof Boolean // false
I letterali devono essere racchiusi in un Objectper instanceofpoter funzionare, ad esempio
new Number(3) instanceof Number // true
Il .constructorcontrollo funziona bene per i letterali perché l' .invocazione del metodo avvolge implicitamente i letterali nel rispettivo tipo di oggetto
3..constructor === Number // true
'abc'.constructor === String // true
true.constructor === Boolean // true
Perché due punti per il 3? Perché Javascript interpreta il primo punto come un punto decimale;)
Non funzionerà cross-frame e cross-window
instanceofinoltre non funzionerà su finestre diverse, per lo stesso motivo del constructorcontrollo delle proprietà.
Utilizzo della nameproprietà della constructorproprietà ...
Non funziona AFFATTO in molti casi
Ancora una volta, vedi sopra; è abbastanza comune constructoressere completamente, completamente sbagliato e inutile.
NON funziona in <IE9
L'uso di myObjectInstance.constructor.namefornisce una stringa contenente il nome della constructorfunzione utilizzata, ma è soggetto alle avvertenze sulla constructorproprietà menzionate in precedenza.
Per IE9 e versioni successive, è possibile applicare la patch scimmia nel supporto :
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) {}
});
}
Versione aggiornata dall'articolo in questione. Questo è stato aggiunto 3 mesi dopo la pubblicazione dell'articolo, questa è la versione consigliata da usare dall'autore dell'articolo Matthew Scharley. Questa modifica è stata ispirata da commenti che evidenziano potenziali insidie nel codice precedente.
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) {}
});
}
Utilizzo di Object.prototype.toString
Si scopre che, come indicato in questo post , è possibile utilizzare Object.prototype.toString- l'implementazione generica e di basso livello toString- per ottenere il tipo per tutti i tipi predefiniti
Object.prototype.toString.call('abc') // [object String]
Object.prototype.toString.call(/abc/) // [object RegExp]
Object.prototype.toString.call([1,2,3]) // [object Array]
Si potrebbe scrivere una funzione di supporto breve come
function type(obj){
return Object.prototype.toString.call(obj).slice(8, -1);
}
per rimuovere la cruft e ottenere solo il nome del tipo
type('abc') // String
Tuttavia, verrà restituito Objectper tutti i tipi definiti dall'utente.
Avvertenze per tutti ...
Tutti questi sono soggetti a un potenziale problema, e questa è la domanda su come è stato costruito l'oggetto in questione. Ecco vari modi di costruire oggetti e i valori restituiti dai diversi metodi di verifica del tipo:
// 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
Sebbene non tutte le permutazioni siano presenti in questo set di esempi, speriamo che ce ne siano abbastanza per darti un'idea di come le cose disordinate potrebbero arrivare a seconda delle tue esigenze. Non dare per scontato nulla, se non capisci esattamente cosa stai cercando, potresti finire con la rottura del codice dove non ti aspetti a causa della mancanza di grokking delle sottigliezze.
NOTA:
La discussione typeofsull'operatore può sembrare un'omissione lampante, ma in realtà non è utile per aiutare a identificare se si objecttratta di un determinato tipo, poiché è molto semplicistico. Capire dove typeofè utile è importante, ma al momento non ritengo che sia estremamente rilevante per questa discussione. La mia mente è aperta al cambiamento però. :)