Test si quelque chose est une classe en javascript

Question

Hey tout, j'essaie de tester si l'argument passé dans ma fonction est un nom de classe afin que je puisse le comparer à d'autres classes en utilisant instanceof.

Par exemple:

function foo(class1, class2) { 
    // Test to see if the parameter is a class. 
    if(class1 is a class) 
    { 
    //do some kind of class comparison. 
    if(class2 is a class) 
    { 
     if(class1 instanceof class2) 
     { 
      //... 
     } 
    } 
    else 
    { 
     //... 
    } 
    } 
    else 
    //... 
} 

Est-ce possible? J'ai du mal à googleing une réponse.

Answer 1

Il n'y a vraiment pas une telle chose comme une "classe" en javascript - tout sauf les primitives sont un objet. Même les fonctions sont des objets.

Cependant, cela fonctionne avec les fonctions. Découvrez ce link.

function Car(make, model, year) 
{ 
    this.make = make; 
    this.model = model; 
    this.year = year; 
} 
var mycar = new Car("Honda", "Accord", 1998); 
var a = mycar instanceof Car; // returns true 
var b = mycar instanceof Object; // returns true 

Answer 2

JavaScript n'a pas de cours. Il a des fonctions qui, lorsqu'elles sont utilisées avec new, peuvent être utilisées pour produire des instances d'objet. Par conséquent, vous voulez vraiment tester si class2 est une fonction. Il y a de nombreuses façons d'accomplir cela; le courant (1.3) de la mise en œuvre isFunction() en jQuery ressemble à ceci:

isFunction: function(obj) { 
    return toString.call(obj) === "[object Function]"; 
}, 

... Mais voir ici pour un aperçu des différentes méthodes: Best method of testing for a function in JavaScript?

Answer 3

Maintenant que nous avons mises en œuvre natifs de ES6, il y a des "classes réelles". Ce sont en grande partie du sucre syntaxique pour l'héritage prototypique comme pour les fonctions du constructeur, mais il existe des différences subtiles et les deux ne sont pas complètement interchangeables.

la seule façon que je l'ai trouvé à ce jour, est d'obtenir la .toString() de la fonction constructeur de prototype de l'objet et vérifier si elle commence par class ou si l'objet a un constructeur et la .toString() de que commence par class. Notez que si votre code est compilé (c.-à-d. La plupart des configurations Babel ou TypeScript), alors cela retournera function... au lieu de class... lors de l'exécution (puisque les classes sont transférées aux fonctions constructeurs).

function isClass(obj) { 
    const isCtorClass = obj.constructor 
     && obj.constructor.toString().substring(0, 5) === 'class' 
    if(obj.prototype === undefined) { 
    return isCtorClass 
    } 
    const isPrototypeCtorClass = obj.prototype.constructor 
    && obj.prototype.constructor.toString 
    && obj.prototype.constructor.toString().substring(0, 5) === 'class' 
    return isCtorClass || isPrototypeCtorClass 
} 

Cela ne fonctionnera que dans les environnements natifs (Chrome, Firefox, Edge, Node.js, etc.) qui ont mis en œuvre class pour le code qui n'a pas été transpiled à function.

Utilisation:

class A {} 
class B extends A {} 
isClass(A) // true 
isClass(new A()) // true 
isClass(B) // true 
isClass(new B()) // true 

function C() {} 
isClass(C) // false 
isClass(new C()) // false 
isClass({}) // false 
isClass(Date) // false 
isClass(new Date()) // false 

//These cases return 'true' but I'm not sure it's desired 
isClass(Object.create(A)) // true  
const x = {} 
Object.setPrototypeOf(x, A) 
isClass(x) // true 

S'il y a une meilleure façon, j'aimerais savoir ce qu'il est.