web-dev-qa-db-fra.com

TypeScript: Accédez aux méthodes statiques au sein de classes (identiques ou différentes)

Supposons que nous ayons le code suivant:

[Test.js file]:
class Test {
    ...
    public static aStaticFunction():void {
          ...

           this.aMemberFunction(); // <- Issue #1.
    }

    private aMemberFunction():void {
          ...

          this.aStaticFunction(); // <- Issue #2.
    }
}

[Another.js file]:
class Another {
    ...

    private anotherMemberFunction():void {
          Test.aStaticFunction(); // <- Issue #3.
    }
}

Voir le Issue #x. commentaires pour les problèmes (3) que je veux aborder.

Je joue avec certaines configurations maintenant et je ne comprends pas tout.

Pouvez-vous m'aider à comprendre comment puis-je accéder à ces méthodes aux trois endroits?

Merci.

javascripttypescriptstatic-methods
46
diosney

Il y a du code ci-dessous, mais il y a quelques concepts importants à garder à l'esprit.

Une méthode statique n'existe sur aucune instance. Il y a de bonnes raisons pour ça:

  1. Il peut être appelé avant que vous ayez créé une instance new
  2. Il peut être appelé de l'extérieur d'une instance pour que vous ne sachiez pas à quelle instance l'appel était associé.

Donc, dans tous les cas où vous appelez la méthode statique, vous devez utiliser le nom complet:

Test.aStaticFunction();

Si la méthode statique a besoin d'appeler une méthode d'instance, vous devez la transmettre. Cela déclenche toutefois des cloches d'alarme pour moi. Si la méthode statique dépend d'une méthode d'instance, il ne devrait probablement pas s'agir d'une méthode statique.

Pour voir ce que je veux dire, réfléchissez à ce problème.

Si j'appelle Test.aStaticFunction() de l'extérieur d'une instance, lorsque 100 instances ont été créées, quelle instance la fonction statique doit-elle utiliser? Il n'y a aucun moyen de le dire. Si votre méthode a besoin de connaître les données de l'instance ou d'appeler des méthodes sur l'instance, elle ne devrait presque certainement pas être statique.

Ainsi, bien que le code ci-dessous fonctionne, ce n'est probablement pas vraiment ce dont vous avez besoin - vous avez probablement besoin de supprimer le mot clé static et de vous assurer que vous disposez d'une instance pour appeler vos autres classes.

interface IHasMemberFunction {
    aMemberFunction(): void;
}

class Test {
    public static aStaticFunction(aClass: IHasMemberFunction):void {
           aClass.aMemberFunction();
    }

    private aMemberFunction():void {
          Test.aStaticFunction(this);
    }
}

class Another {
    private anotherMemberFunction():void {
          Test.aStaticFunction(new Test());
    }
}
48
Fenton

this est lié à une instance alors que static membres sont indépendants de toute instance. Donc, si vous voulez accéder aux membres d'une instance dans un membre statique, vous devez la transmettre. Cependant, dans ce cas, je ne vois pas de raison d'avoir un membre statique en premier lieu. Je crois que vous avez besoin de deux fonctions. un statique et un non statique. Cela fait deux choses différentes, donc:

class Test {

    public  notaStaticFunction():void {
           this.aMemberFunction(); // <- Issue #1.
    }

    public static aStaticFunction():void {

    }

    private aMemberFunction():void {
          this.notaStaticFunction(); // <- Issue #2.
    }
}

class Another {
    private anotherMemberFunction():void {
          Test.aStaticFunction(); // <- Issue #3.
    }
}

Cela dit, vous pouvez partager des propriétés entre des fonctions membres et statiques à l'aide de propriétés statiques.

3
basarat