web-dev-qa-db-fra.com

typescript MyObject.instanceOf ()

Toutes nos classes TypeScript héritent (directement ou indirectement) de:

export class WrObject {
    className:string;

    public instanceOf(name : String) : boolean {
        return this.className === name;
    }
}

Nous déclarons ensuite une sous-classe en tant que:

export class Section extends WrObject {
    public static CLASS_NAME = 'Section';
    className = Section.CLASS_NAME;

        public instanceOf(name : String) : boolean {
            if (this.className === name)
                return true;
            return super.instanceOf(name);
        }

}

Et vous pouvez alors vérifier avec:

if (obj.instanceOf(Section.CLASS_NAME))

Tout fonctionne très bien. Cependant, je pense que ce serait plus propre si nous pouvions faire:

if (obj.instanceOf(Section))

Y'a-t'il un quelconque moyen d'y arriver? Ou des suggestions quant à une meilleure approche?

merci - dave

typescriptinstanceof
10
David Thielen

Si vous êtes prêt à accepter la nature prototype de JavaScript, vous pouvez simplement utiliser instanceof qui vérifie la chaîne de prototypes: 

class Foo{}
class Bar extends Foo{}
class Bas{}

var bar = new Bar();

console.log(bar instanceof Bar); // true
console.log(bar instanceof Foo); // true
console.log(bar instanceof Object); // true

console.log(bar instanceof Bas); // false
18
basarat

Vous pouvez le faire. Remplacez simplement votre implémentation instanceOf par celle-ci:

public instanceOf(cls: { CLASS_NAME: string; }) {
    return cls.CLASS_NAME === this.className || super.instanceOf(cls);
}
2
Igorbek

Je suppose que cela pourrait fonctionner Exemple sur un terrain de jeu

var getName = function(obj) : string { 
   var funcNameRegex = /function (.{1,})\(/;
   var results = (funcNameRegex).exec(obj);
   return (results && results.length > 1) ? results[1] : "";
};

class Foo
{

}

function IsTypeOf(obj: any, type: Function)
{
    alert(obj.constructor.name + " == " + getName(type));
}

IsTypeOf(new Foo(), Foo);

En relation

0
BrunoLM