Insertion de parenthèses

Les blocs impliquent des parenthèses. Par exemple, lorsque vous voyez les blocs suivants, vous supposons que cela signifie -(5 + 2) et non -5 + 2, car 5 et 2 font partie de un bloc, et le - fait partie d'un autre bloc.

blocs représentant -(5 + 2)

Mais si vous mettez des parenthèses autour de chaque bloc, le code est bien moins et lisibles. Comparez (((5) * (2)) + (3)) avec 5 * 2 + 3. Les deux deux expressions ont la même valeur (13), mais la seconde est beaucoup plus facile à lire.

Les règles de priorité des opérateurs de Blockly vous aident à générer du code avec le minimum de parenthèses, pour une lisibilité optimale.

Générer le mot "correct" sortie

Si vous n'avez pas besoin que le code généré soit lisible par l'humain, il n'est pas nécessaire de vous soucier de réduire les parenthèses. Encapsuler chaque bloc est une bonne approche, et garantit que le code généré est toujours évalué correctement.

Pour garantir l'exactitude, transmettez toujours les appels Order.ATOMIC aux appels valueToCode. renvoie toujours Order.NONE à partir de votre générateur de code de bloc.

Générer des parenthèses optimales

Les parenthèses ne doivent être insérées que si le code généré est incorrect sans de l'IA générative. Cela se produit lorsque la priorité d'un opérateur dans le bloc externe est plus forte que la priorité d'un opérateur dans le bloc interne.

Par exemple, les blocs suivants comportent un opérateur de négation unaire et un autre additionnel. La négation unaire a plus de priorité que la négation additionnel.

négation et ajout

Si vous n'ajoutez pas de parenthèses, vous obtenez -5 + 2, et - est évalué. avant +, ce qui ne correspond pas aux blocs.

Vous pouvez indiquer au générateur quand insérer des parenthèses en lui indiquant la force vos différents opérateurs. Si elle constate que l'opérateur externe est plus fort que l'opérateur interne, il insère des parenthèses pour protéger l'opérateur interne.

valueToCode a la priorité sur l'opérateur externe, et l'état renvoyé tuple spécifie la priorité de l'opérateur interne.

Voici un exemple de bloc comprenant deux opérateurs:

Bloc avec un opérateur de négation unaire, un opérateur d'addition et un enfant . 

import {javascriptGenerator, Order} from 'blockly/javascript';

javascriptGenerator.forBlock['negate_plus_two'] = function(block, generator) {
  // valueToCode takes in the precedence of the outer operator.
  const innerCode = generator.valueToCode(block, 'INNER', Order.UNARY_NEGATION);
  const code = `-${innerCode} + 2`;
  // The return tuple specifies the precedence of the inner operator.
  return [code, Order.ADDITION];
}

Priorité valueToCode

Lorsque vous appelez valueToCode pour générer le code d'un bloc interne, vous le transmettez la priorité de l'opérateur le plus fort agissant sur le code de l'opérateur interne . Il s'agit de l'opérateur contre lequel le code du bloc interne doit être protégé.

Par exemple, dans les blocs suivants, l'opérateur de négation unaire et l'opérateur agissent sur le code du bloc interne. La négation unaire est plus forte. Il s'agit donc de la priorité que vous devez transmettre à valueToCode.

Bloc avec un opérateur de négation unaire, un opérateur d'addition et un enfant . 

// The - is the strongest operator acting on the inner code.
const innerCode = generator.valueToCode(block, 'INNER', Order.UNARY_NEGATION);
const code = `-${innerCode} + 2`;

Priorité de retour

Lorsque vous renvoyez un paramètre de priorité à partir de votre générateur de code de bloc, renvoyez le priorité de l'opérateur le plus faible dans le code du bloc. Il s'agit de la un opérateur qui doit être protégé.

Par exemple, le bloc suivant contient à la fois un opérateur de négation unaire et un opérateur additionnel. L'addition est plus faible, c'est donc la priorité que vous devez du générateur de code de bloc.

Bloc avec un opérateur de négation unaire et un opérateur d'addition, mais sans enfant bloquer 

const code = `-${innerCode} + 2`;
// The + is the weakest operator in the block.
return [code, Order.ADDITION];

Énumération de la commande

Chaque module de générateur de langage définit une énumération Order qui inclut l'ensemble des les priorités de cette langue.

Les priorités les plus fortes ont des valeurs de sauvegarde inférieures, tandis que les priorités plus faibles ont avec des valeurs de sauvegarde plus élevées. Vous pouvez considérer les fortes priorité comme étant « classées plus élevé" par ordre de priorité, tandis que les priorités les plus faibles sont "inférieures". - comme s'ils étaient des combattants compétitifs.

Vous trouverez ci-dessous les énumérations Order pour toutes les langues intégrées:

Priorités spéciales

La plupart des priorités dans les colonnes Les énumérations Order correspondent aux priorités définies par leurs langues textuelles respectives. Mais il existe deux types Order.ATOMIC et Order.NONE.

Order.ATOMIC a la priorité la plus forte. Elle est utilisée dans les cas suivants:

Order.NONE est la priorité la plus faible. Elle est utilisée dans les cas suivants: