Surcharge des opérateurs dans AS3 avec Realaxy Editor

Dans le précédent article sur Realaxy Editor, nous avons parlé du langage Traits, qui vous permet de tirer parti de l'héritage multiple. Nous nous tournons maintenant vers une autre opportunité remarquable: la surcharge des opérateurs..

Realaxy ActionScript Editor (RASE) est disponible ici (pour Windows, Macintosh OS X et Linux). Remarque: s'il s'agit de votre première expérience avec l'éditeur, veuillez lire le manuel d'utilisation de RASE..

Intoduction

L'une des principales fonctionnalités ajoutées à la version 10 de RASE est la prise en charge de la surcharge des opérateurs, qui permet aux développeurs de modifier le comportement des opérateurs (*, +, etc.) dans différentes circonstances. Cette fonctionnalité, ainsi que l’héritage multiple, sont l’objet d’une guerre sainte entre ardents défenseurs de deux paradigmes de programmation différents..

Les avantages de surcharger les opérateurs sont évidents:

  1. Style compact. Vos programmes pourraient devenir plus courts et plus lisibles; par exemple, il est beaucoup plus facile d'utiliser quelque chose comme abc que a.multiply (b) .multiply (b).
  2. Code semble souvent plus naturel. Un opérateur bien défini est plus facile à comprendre et à retenir que le nom de fonction ou le nom de fonction. Par exemple, en combinant deux variables de type Point, vous préféreriez voir quelque chose comme: point1 + point2, mais non point1.plus (point2).

Le véritable argument contre la surcharge de l'opérateur est la perte du contrôle de votre code. Parfois, il est difficile de savoir où un opérateur est surchargé ou non. L'ajout d'un opérateur surchargé appelle des modifications dans le comportement du code existant pouvant entraîner des conséquences inattendues..

La surcharge d’opérateur n’est pas incluse dans ActionScript (ECMA3) bien qu’elle soit proposée pour la norme ECMA4. Java ne prend pas en charge la surcharge des opérateurs, mais Groovy ("Java avec sucre syntaxique?) Et Scala le font. De plus, les opérateurs de C # peuvent être surchargés.

On ne peut pas dire si c'est une bonne ou une mauvaise chose. Cependant, il est également pratiquement assuré que c'est parfois un must-have virtuel. Par exemple, lors de l'enchaînement de plusieurs opérations mathématiques, la surcharge d'opérateurs rend le code beaucoup plus concis, améliorant ainsi votre compréhension de son fonctionnement. Mais assez de théorie - référons-nous à la pratique.

Nous parlons d'une extension de langue surchargéOpérateurs qui a été introduit dans RASE depuis Beta 10 (build 8145+).

Un moyen facile de l’importer (ou de toute autre langue) dans votre projet consiste à appuyer sur Ctrl + L (Cmd + L) dans Realaxy Editor.

Au fait, surchargéOpérateursdans RASE est juste un port de la surchargéOpérateurs langage de la plate-forme Jetbrains MPS. Nous avons simplement décidé de ne pas réinventer la roue et, après avoir étudié le domaine d'application cible, sommes parvenus à la conclusion que la solution Jetbrains semblait suffisante et répond à tous nos besoins. Nous avons ajouté quelques petites fonctionnalités supplémentaires..

Nous pensons que c’est le bon moyen de programmation orientée vers les langues, qui tire le meilleur des autres langues et la personnalise pour ses propres besoins. Plus d'informations à ce sujet plus tard dans nos prochains articles sur la création d'extensions de langage.


Étape 1

Créer un nouveau projet avec un module à l'intérieur.


Étape 2

Appeler les nouveaux opérateurs root??.


Étape 3

Ajouter du code à tester dans la classe principale.

Ici, nous avons créé deux variables, p1 et p2 (type Point). Maintenant, nous aimerions obtenir une troisième variable, p3, qui serait le résultat de la combinaison de ces deux points.

Sortez ces trois valeurs: p1, p2, p3. Nous avons utilisé l'expression valeurs de la langue enregistrement afin d'implémenter le message de chaîne pour la sortie de la console.

Notre code provoque un message d'erreur: "L'opération ne peut pas s'appliquer à ces opérandes". Compiler est impossible.


Étape 4

Déclarons la surcharge de l'opérateur. Importation com.realaxy.actionScript.overloadedOperators.


Étape 5

Ajouter un nouveau ?OverlodedOperatorsContainer? root: cliquez avec le bouton droit sur le nœud du package et choisissez dans un menu contextuel..


Étape 6

Nomme le ?MyOperators?.

Nous voyons ici deux blocs de déclaration: ?opérateurs binaires surchargés? et ?déclarations d'opérateurs personnalisés?.


Étape 7

Passez au premier bloc et appuyez sur Entrer. Une nouvelle déclaration d'opérateur est ajoutée.


Étape 8

Choisir ?+? opérateur. Choisissez le type Point pour les deux côtés. Définir la valeur de retour Point (changez-le de défaut ?vide? réglage).

Maintenant, nous pouvons ajouter un code qui serait exécuté en combinant Point avec Point (en utilisant ?+? opérateur).

C'est tout.

La surbrillance rouge qui indique qu'une erreur dans notre classe a disparu.


Étape 9

Commencer à compiler.


Étape 10

Créer une configuration d'exécution pour notre module.


Étape 11

Attribuer la classe principale (si vous ne l'aviez pas fait plus tôt).


Étape 12

Nous obtenons le message suivant sur la console:


Étape 13

Essayons maintenant de terminer une tâche légèrement plus sophistiquée et de redéfinir les opérations de soustraction, de multiplication et de division. Pour les deux Nombre et Point.

 opérateur + (Point, Point) -> Point commutatif: false (gauche, droite) -> Point retour nouveau Point (left.x + right.x, left.y + right.y);  opérateur + (Point, Nombre) -> Point commutatif: false (gauche, droite) -> Point retour nouveau Point (gauche.x + droite, gauche.y + droite);  opérateur - (Point, Point) -> Point commutatif: false (gauche, droite) -> Point retour nouveau Point (left.x - right.x, left.y - right.y);  opérateur - (Point, Nombre) -> Point commutatif: false (gauche, droite) -> Point retour nouveau Point (gauche.x - droite, gauche.y - droite);  opérateur * (Point, Point) -> Point commutatif: false (gauche, droite) -> Point retour nouveau Point (left.x * right.x, left.y * right.y);  opérateur * (Point, Nombre) -> Point commutatif: false (gauche, droite) -> Point retour nouveau Point (gauche.x * droite, gauche.y * droite);  opérateur / (Point, Point) -> Point commutatif: false (gauche, droite) -> Point retour nouveau Point (left.x / right.x, left.y / right.y);  opérateur / (Point, Nombre) -> Point commutatif: false (gauche, droite) -> Point retour nouveau Point (gauche.x / droite, gauche.y / droite); 

Étape 14

Imaginez que vous deviez calculer un point situé à gauche et en bas de 50 pixels du centre de la distance entre les deux points..

C'est simple:

Ou encore plus simple:

Mais n'oubliez pas que dans la vie réelle d'un Flasher, ce serait comme ça:

Comparez ces chiffres. C'est une raison suffisante d'utiliser la surcharge d'opérateur dans les projets ActionScript.


Étape 15

Maintenant, apprenons à créer nos propres opérateurs personnalisés.

Tout d'abord, revenez à MyOperators déclaration et aller à déclarations d'opérateurs personnalisés.

presse Entrer créer une nouvelle déclaration. Présentation visuelle serait ~ =.


Étape 16

Notre opérateur personnalisé doit vérifier qu'une chaîne correspond à une expression régulière. Pour décrire le comportement d'un tel opérateur, nous ajoutons une nouvelle surcharge, comme nous l'avons fait il y a 10 minutes avec Point. La seule différence est d'ajouter ~ = à compléter automatiquement.

L’opérande de gauche doit prendre un Chaîne, tandis que le bon doit être RegExp. La valeur renvoyée doit être Booléen.

Ajoutez ensuite du code qui serait exécuté par notre opérateur en appelant tester méthode de la valeur.


Étape 17

Créer une opération de test dans Principale () pour voir comment cela fonctionne:

Rapide et facile.

Pour éviter toute confusion entre tous ces opérateurs personnalisés, vous devez mémoriser un seul raccourci clavier lié à la navigation: Ctrl-B (ou Ctrl + clic sur un opérateur) vous mènera à la déclaration de l'opérateur.

Un bon conseil: pour faire la différence entre un opérateur rechargé et un opérateur intégré, passez la souris dessus et appuyez sur Ctrl.

Bien sûr, si vous êtes sur un Mac, utilisez Cmd au lieu de Ctrl.


Étape 18

Étendons le comportement de notre opérateur personnalisé avec une nouvelle fonctionnalité, commutativité.

Sélectionnez l'opérateur et appuyez sur Alt-Enter. Choisir Opération binaire Flip dans un menu contextuel. Cela échangera les deux côtés, mais avec un message d'erreur, car ~ = l'opérateur n'est pas encore défini pour de tels opérandes.

Passez à la déclaration de l'opérateur. Ensemble commutatif = vrai. La surbrillance d'erreur rouge devrait disparaître (vous devez parfois appuyer sur F5 pour actualiser une vue).

En d'autres termes, cette ?commutatif? le réglage est une bonne vieille règle selon laquelle changer l’ordre des summands ne change pas la somme. Maintenant, notre ~ = L'opérateur fonctionnera toujours si nous plaçons le RegExp avant le String.

Mot d'avertissement

Les gourous de la POO mettent en garde contre une utilisation excessive de ce comportement. Parfois, cela implique des effets inattendus. Prenons-le sur la foi et souvenons-nous.

C'est tout ce qu'on peut en dire. Nous avons une surcharge d'opérateur dans ActionScript 3.