Comment obtenir un objet de la classe?

obj.constructor.name

est une méthode fiable dans les navigateurs modernes. Function.name a été officiellement ajouté à la norme dans l'ES6, ce qui en fait un conforme aux normes de moyen d'accéder à la "classe" d'un objet JavaScript en tant que chaîne. Si l'objet est instancié avec var obj = new MyClass(), il sera de retour "MyClass".

Il sera de retour "Nombre" pour les nombres, "Array" pour les tableaux et "Fonctionner" de fonctions, etc. Il se comporte généralement comme prévu. Le seul cas où il échoue si un objet est créé sans un prototype, via Object.create( null ), ou de l'objet instancié à partir d'un auteur anonyme-définis (sans nom) de la fonction.

Notez également que si vous êtes minifying votre code, il n'est pas sûr à comparer codée en dur de type chaînes de caractères. Par exemple, au lieu de vérifier si obj.constructor.name == "MyType", au lieu de vérifier obj.constructor.name == MyType.name. Ou il suffit de comparer les constructeurs eux-mêmes, mais ce ne fonctionneront pas dans les DOM frontières, comme il y a différentes instances de la fonction de constructeur sur chaque DOM, faisant ainsi un objet de comparaison sur leurs constructeurs ne fonctionne pas.

Remarque lorsque le chaînage des prototypes

Edit: C'est apparemment discutable maintenant que ES6 a un meilleur support pour les classes et l'héritage. Comme adalbertpl explique, constructor.name se comporte comme prévu dans le scénario.

Curieusement, constructor.name retourne le nom de la base de la plupart de fonction utilisé dans une chaîne de prototype, ce qui n'est malheureusement pas intuitif. Par exemple, si B tire fait de A et vous créez une nouvelle instance de B, b, b.constructor.name renvoie "A", ce qui semble erroné. Il n'beau travail pour un seul niveau de prototypes et de toutes les primitives, cependant.

Pour obtenir le "pseudo-classe", vous pouvez obtenir la fonction de constructeur, par

obj.constructor

en supposant que le constructor est correctement réglé lorsque vous ne l'héritage, qui est par quelque chose comme:

Dog.prototype = new Animal();
Dog.prototype.constructor = Dog;

et ces deux lignes, avec:

var woofie = new Dog()

fera woofie.constructor point de Dog. Notez que Dog est une fonction constructeur, et est un Function objet. Mais vous pouvez faire if (woofie.constructor === Dog) { ... }.

Si vous voulez obtenir le nom de la classe comme une chaîne de caractères, j'ai trouvé le suivant fonctionne bien:

http://blog.magnetiq.com/post/514962277/finding-out-class-names-of-javascript-objects

function getObjectClass(obj) {
    if (obj && obj.constructor && obj.constructor.toString) {
        var arr = obj.constructor.toString().match(
            /function\s*(\w+)/);

        if (arr && arr.length == 2) {
            return arr[1];
        }
    }

    return undefined;
}

Il obtient à la fonction constructeur, la convertit en chaîne, et en extrait le nom de la fonction constructeur.

Noter que obj.constructor.name pourrait avoir bien fonctionné, mais il n'est pas standard. C'est sur Chrome et Firefox, mais pas sur IE, y compris IE 9 ou 10 IE RTM.

En accord avec son ininterrompue de rétro-compatibilité, ECMAScript 6, JavaScript n'ai toujours pas de class type (mais pas tout le monde comprend cela). Il ne ont un class mot-clé dans le cadre de son class syntaxe pour la création de prototypes,—mais toujours pas de chose qui s'appelle la classe. Le JavaScript n'est pas maintenant et a jamais été un classique de la programmation orientée objet du langage. En parlant de JS en termes de classe est uniquement soit trompeuse ou d'un signe de pas encore grokking l'héritage par prototype (juste keeping it real).

Qui signifie this.constructor est encore un excellent moyen pour obtenir une référence à la constructor fonction. Et this.constructor.prototype est le moyen d'accès le prototype lui-même. Car ce n'est pas Java, il n'est pas une classe. C'est le prototype de l'objet de votre instance a été instancié à partir d'. Voici un exemple d'utilisation de l'ES6 sucre syntaxique pour la création d'un prototype de chaîne:

class Foo {
  get foo () {
    console.info(this.constructor, this.constructor.name)
    return 'foo'
  }
}

class Bar extends Foo {
  get foo () {
    console.info('[THIS]', this.constructor, this.constructor.name, Object.getOwnPropertyNames(this.constructor.prototype))
    console.info('[SUPER]', super.constructor, super.constructor.name, Object.getOwnPropertyNames(super.constructor.prototype))

    return `${super.foo} + bar`
  }
}

const bar = new Bar()
console.dir(bar.foo)

C'est ce que les sorties à l'aide de babel-node:

> $ babel-node ./foo.js                                                                                                                   ⬡ 6.2.0 [±master ●]
[THIS] [Function: Bar] 'Bar' [ 'constructor', 'foo' ]
[SUPER] [Function: Foo] 'Foo' [ 'constructor', 'foo' ]
[Function: Bar] 'Bar'
'foo + bar'

Là vous l'avez! En 2016, il y a un class mot-clé en JavaScript, mais toujours pas de type de classe. this.constructor est la meilleure façon d'obtenir la fonction de constructeur, this.constructor.prototype la meilleure façon d'obtenir l'accès au prototype lui-même.

Je trouve object.constructor.toString() retour [object objectClass] dans IE ,plutôt que de function objectClass () {} retourné dans chome. Donc,je pense que le code dans http://blog.magnetiq.com/post/514962277/finding-out-class-names-of-javascript-objects peut ne pas fonctionner bien sous IE.Et j'ai corrigé le code comme suit:

code:

var getObjectClass = function (obj) {
        if (obj && obj.constructor && obj.constructor.toString()) {

                /*
                 *  for browsers which have name property in the constructor
                 *  of the object,such as chrome 
                 */
                if(obj.constructor.name) {
                    return obj.constructor.name;
                }
                var str = obj.constructor.toString();
                /*
                 * executed if the return of object.constructor.toString() is 
                 * "[object objectClass]"
                 */

                if(str.charAt(0) == '[')
                {
                        var arr = str.match(/\[\w+\s*(\w+)\]/);
                } else {
                        /*
                         * executed if the return of object.constructor.toString() is 
                         * "function objectClass () {}"
                         * for IE Firefox
                         */
                        var arr = str.match(/function\s*(\w+)/);
                }
                if (arr && arr.length == 2) {
                            return arr[1];
                        }
          }
          return undefined; 
    };

En javascript, il n'y a pas de classes, mais je pense que vous voulez que le constructeur nom et obj.constructor.toString() vais vous dire ce dont vous avez besoin.

Javascript est une classe de moins de langues: il n'y a pas de classes qui définit le comportement d'une classe de façon statique comme en Java. JavaScript utilise des prototypes au lieu de classes pour définir les propriétés de l'objet, y compris les méthodes, et à l'héritage. Il est possible de simuler de nombreux la classe de base des fonctionnalités à l'aide de prototypes en JavaScript.

Voici une mise en œuvre de getClass() et getInstance()

Vous êtes en mesure d'obtenir une référence d'une classe de l'Objet à l'aide de window.

À partir d'une instance de contexte:

function A() {
    this.getClass = function() {
        return window[this.constructor.name];
    }

    this.getNewInstance = function() {
        return new window[this.constructor.name];
    }
}

var a = new A();
console.log(a.getClass());  // function A { //etc... }

//you can even:
var b = new a.getClass();
b instanceof A; //true

De contexte statique:

function B() {};

B.getClass = function() {
    return window[this.name];
}

B.getInstance() {
    return new window[this.name];
}