J'ai créé un objet JavaScript, mais comment puis-je déterminer la classe de cet objet?

Je veux quelque chose de similaire à la .getClass()méthode Java .

Il n'y a pas d'équivalent exact à Java getClass()en JavaScript. Cela est principalement dû au fait que JavaScript est un langage basé sur un prototype , par opposition à Java un langage basé sur une classe .

Selon ce dont vous avez besoin getClass(), il existe plusieurs options en JavaScript:

• typeof
• instanceof
• obj.constructor
• func.prototype, proto.isPrototypeOf

Quelques exemples:

function Foo() {}
var foo = new Foo();

typeof Foo;             // == "function"
typeof foo;             // == "object"

foo instanceof Foo;     // == true
foo.constructor.name;   // == "Foo"
Foo.name                // == "Foo"    

Foo.prototype.isPrototypeOf(foo);   // == true

Foo.prototype.bar = function (x) {return x+x;};
foo.bar(21);            // == 42

Remarque: si vous compilez votre code avec Uglify, cela changera les noms de classe non globaux. Pour éviter cela, Uglify a un paramètre --mangleque vous pouvez définir sur false en utilisant gulp ou grunt .

obj.constructor.name

est une méthode fiable dans les navigateurs modernes. Function.namea été officiellement ajouté à la norme dans ES6, ce qui en fait un moyen conforme aux normes d'obtenir la "classe" d'un objet JavaScript sous forme de chaîne. Si l'objet est instancié avec var obj = new MyClass(), il renverra "MyClass".

Il renverra "Number" pour les nombres, "Array" pour les tableaux et "Function" pour les fonctions, etc. Il se comporte généralement comme prévu. Les seuls cas où il échoue sont si un objet est créé sans prototype, via Object.create( null )ou si l'objet a été instancié à partir d'une fonction définie de manière anonyme (sans nom).

Notez également que si vous réduisez votre code, il n'est pas sûr de comparer avec des chaînes de type codées en dur. Par exemple, au lieu de vérifier si obj.constructor.name == "MyType", vérifiez plutôt obj.constructor.name == MyType.name. Ou comparez simplement les constructeurs eux-mêmes, mais cela ne fonctionnera pas au-delà des limites du DOM car il existe différentes instances de la fonction de constructeur sur chaque DOM, donc faire une comparaison d'objets sur leurs constructeurs ne fonctionnera pas.

Cette fonction renvoie "Undefined"pour les valeurs non définies et "Null"pour null.
Pour toutes les autres valeurs, la CLASSNAMEpartie-est extraite de [object CLASSNAME], qui est le résultat de l'utilisation Object.prototype.toString.call(value).

function getClass(obj) {
  if (typeof obj === "undefined") return "Undefined";
  if (obj === null) return "Null";
  return Object.prototype.toString.call(obj).match(/^\[object\s(.*)\]$/)[1];
}

getClass("")   === "String";
getClass(true) === "Boolean";
getClass(0)    === "Number";
getClass([])   === "Array";
getClass({})   === "Object";
getClass(null) === "Null";
// etc...

Pour obtenir la "pseudo classe", vous pouvez obtenir la fonction constructeur, en

obj.constructor

en supposant que le constructorest correctement défini lorsque vous effectuez l'héritage - ce qui est par quelque chose comme:

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

et ces deux lignes, ainsi que:

var woofie = new Dog()

fera woofie.constructorremarquer Dog. Notez qu'il Dogs'agit d'une fonction constructeur et d'un Functionobjet. Mais tu peux le faire if (woofie.constructor === Dog) { ... }.

Si vous voulez obtenir le nom de la classe sous forme de chaîne, j'ai trouvé que ce qui suit fonctionnait 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 accède à la fonction constructeur, la convertit en chaîne et extrait le nom de la fonction constructeur.

Notez que cela obj.constructor.nameaurait pu bien fonctionner, mais ce n'est pas standard. C'est sur Chrome et Firefox, mais pas sur IE, y compris IE 9 ou IE 10 RTM.

Vous pouvez obtenir une référence à la fonction constructeur qui a créé l'objet en utilisant la propriété constructeur :

function MyObject(){
}

var obj = new MyObject();
obj.constructor; // MyObject

Si vous devez confirmer le type d'un objet au moment de l'exécution, vous pouvez utiliser l' opérateur instanceof :

obj instanceof MyObject // true

Conformément à son record ininterrompu de compatibilité descendante, ECMAScript 6, JavaScript n'a toujours pas de classtype (bien que tout le monde ne le comprenne pas). Il ne un classmot - clé dans le cadre de sa classsyntaxe pour la création de prototypes, mais toujours pas de chose appelée classe . JavaScript n'est pas maintenant et n'a jamais été un langage OOP classique . Parler de JS en termes de classe n'est que trompeur ou un signe d'héritage prototypique pas encore bouleversant (juste le garder réel).

Cela signifie que this.constructorc'est toujours un excellent moyen d'obtenir une référence à la constructorfonction. Et this.constructor.prototypec'est le moyen d'accéder au prototype lui-même. Comme ce n'est pas Java, ce n'est pas une classe. C'est l'objet prototype à partir duquel votre instance a été instanciée. Voici un exemple utilisant le sucre syntaxique ES6 pour créer une chaîne prototype:

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 qui sort en utilisant 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'

Voilà! En 2016, il y a un classmot - clé en JavaScript, mais toujours pas de type de classe. this.constructorest le meilleur moyen d'obtenir la fonction constructeur, this.constructor.prototypele meilleur moyen d'accéder au prototype lui-même.

j'avais une situation pour travailler générique maintenant et utilisé ceci:

class Test {
  // your class definition
}

nameByType = function(type){
  return type.prototype["constructor"]["name"];
};

console.log(nameByType(Test));

c'est le seul moyen que j'ai trouvé pour obtenir le nom de classe par type d'entrée si vous n'avez pas d'instance d'objet.

(écrit en ES2017)

la notation par points fonctionne également très bien

console.log(Test.prototype.constructor.name); // returns "Test" 

Pour les classes Javascript dans ES6, vous pouvez utiliser object.constructor. Dans l'exemple de classe ci-dessous, la getClass()méthode renvoie la classe ES6 comme prévu:

var Cat = class {

    meow() {

        console.log("meow!");

    }

    getClass() {

        return this.constructor;

    }

}

var fluffy = new Cat();

...

var AlsoCat = fluffy.getClass();
var ruffles = new AlsoCat();

ruffles.meow();    // "meow!"

Si vous instanciez la classe à partir de la getClassméthode, assurez-vous de la mettre entre crochets, par exempleruffles = new ( fluffy.getClass() )( args... );

Je trouve le object.constructor.toString()retour [object objectClass]dans IE, plutôt que 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 bien fonctionner dans 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 le nom du constructeur et obj.constructor.toString()vous direz ce dont vous avez besoin.

D'accord avec dfa, c'est pourquoi je considère le prototye comme la classe quand aucune classe nommée n'a été trouvée

Voici une fonction améliorée de celle publiée par Eli Gray, pour correspondre à ma façon de penser

function what(obj){
    if(typeof(obj)==="undefined")return "undefined";
    if(obj===null)return "Null";
    var res = Object.prototype.toString.call(obj).match(/^\[object\s(.*)\]$/)[1];
    if(res==="Object"){
        res = obj.constructor.name;
        if(typeof(res)!='string' || res.length==0){
            if(obj instanceof jQuery)return "jQuery";// jQuery build stranges Objects
            if(obj instanceof Array)return "Array";// Array prototype is very sneaky
            return "Object";
        }
    }
    return res;
}

Si vous devez non seulement obtenir la classe GET, mais aussi la prolonger de la simple présence d'une instance, écrivez:

nous allons avoir

 class A{ 
   constructor(name){ 
     this.name = name
   }
 };

 const a1 = new A('hello a1');

afin d'étendre A en utilisant uniquement l'instance:

const a2 = new ((Object.getPrototypeOf(a)).constructor())('hello a2')
// the analog of const a2 = new A()

console.log(a2.name)//'hello a2'

Je suggère d'utiliser Object.prototype.constructor.name:

Object.defineProperty(Object.prototype, "getClass", {
    value: function() {
      return this.constructor.name;
    }
});

var x = new DOMParser();
console.log(x.getClass()); // `DOMParser'

var y = new Error("");
console.log(y.getClass()); // `Error'

Voici une implémentation de getClass()etgetInstance()

Vous pouvez obtenir une référence pour la classe d'un objet en utilisant this.constructor.

À partir d'un contexte d'instance:

function A() {
  this.getClass = function() {
    return this.constructor;
  }

  this.getNewInstance = function() {
    return new this.constructor;
  }
}

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

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

Du contexte statique:

function A() {};

A.getClass = function() {
  return this;
}

A.getInstance() {
  return new this;
}

Vous pouvez également faire quelque chose comme ça

 class Hello {
     constructor(){
     }
    }
    
      function isClass (func) {
        return typeof func === 'function' && /^class\s/.test(Function.prototype.toString.call(func))
    }
    
   console.log(isClass(Hello))

Cela vous dira si l'entrée est de classe ou non

Javascript est un langage sans classe: il n'y a pas de classe qui définit statiquement le comportement d'une classe comme en Java. JavaScript utilise des prototypes au lieu de classes pour définir les propriétés des objets, y compris les méthodes et l'héritage. Il est possible de simuler de nombreuses fonctionnalités basées sur des classes avec des prototypes en JavaScript.

La question semble déjà répondue mais l'OP veut accéder à la classe de et objet, tout comme nous le faisons en Java et la réponse sélectionnée n'est pas suffisante (à mon humble avis).

Avec l'explication suivante, nous pouvons obtenir une classe d'un objet (il est en fait appelé prototype en javascript).

var arr = new Array('red', 'green', 'blue');
var arr2 = new Array('white', 'black', 'orange');

Vous pouvez ajouter une propriété comme celle-ci:

Object.defineProperty(arr,'last', {
  get: function(){
    return this[this.length -1];
  }
});
console.log(arr.last) // blue

Mais la .lastpropriété ne sera disponible que pour arrl'objet ' ' qui est instancié à partir du prototype Array. Donc, pour que la .lastpropriété soit disponible pour tous les objets instanciés à partir du prototype Array, nous devons définir la .lastpropriété pour le prototype Array:

Object.defineProperty(Array.prototype,'last', {
  get: function(){
    return this[this.length -1];
  }
});
console.log(arr.last) // blue
console.log(arr2.last) // orange

Le problème ici est que vous devez savoir à quel type d'objet (prototype) les variables ' arr' et ' arr2' appartiennent! En d'autres termes, si vous ne connaissez pas le type de classe (prototype) de l' arrobjet ' ', vous ne pourrez pas leur définir de propriété. Dans l'exemple ci-dessus, nous savons que arr est une instance de l'objet Array, c'est pourquoi nous avons utilisé Array.prototype pour définir une propriété pour Array. Et si nous ne connaissions pas la classe (prototype) du ' arr'?

Object.defineProperty(arr.__proto__,'last2', {
  get: function(){
    return this[this.length -1];
  }
});
console.log(arr.last) // blue
console.log(arr2.last) // orange

Comme vous pouvez le voir, sans savoir que « arr» est un tableau, nous pouvons ajouter une nouvelle propriété en référençant simplement la classe du « arr» en utilisant « arr.__proto__».

Nous avons accédé au prototype du ' arr' sans savoir qu'il s'agit d'une instance d'Array et je pense que c'est ce que OP a demandé.