Inserción de paréntesis

Los bloques implican paréntesis. Por ejemplo, cuando ves los siguientes bloques, supón que significa -(5 + 2), no -5 + 2 porque 5 y 2 son parte de un bloque, y - es parte de otro bloque.

bloques que representan -(5 + 2)

Pero si colocas paréntesis alrededor de cada bloque, hace que el código sea mucho sean legibles. Compara (((5) * (2)) + (3)) con 5 * 2 + 3. Ambos se evalúan como lo mismo (13), pero la segunda es mucho más fácil para leer.

Las reglas de prioridad del operador de Blockly te ayudan a generar código con el mínimo la cantidad de paréntesis, para una máxima legibilidad.

Generar "correcto" salida

Si no necesitas que el código generado sea legible por humanos, no es necesario no te preocupes por minimizar los paréntesis. Unir cada bloque es un buen enfoque, y garantiza que el código generado siempre se evalúe de forma correcta.

Para garantizar la precisión, siempre pasa las llamadas de Order.ATOMIC a valueToCode. Siempre muestra Order.NONE desde tu generador de código de bloque.

Genera paréntesis óptimos

Los paréntesis solo deben insertarse si el código generado es incorrecto, sin de ellos. Esto sucede cuando la prioridad de un operador en el bloque externo es es mayor que la precedencia de un operador en el bloque interno.

Por ejemplo, en los siguientes bloques hay un operador de negación unario y un operador de suma. La negación unaria tiene mayor precedencia que la operador de suma.

negación y suma

Por lo tanto, si no agregas paréntesis, obtendrás -5 + 2 y - se evaluará. antes de +, que no coincide con los bloques.

Para indicarle al generador cuándo debe insertar paréntesis, dile la intensidad los diferentes operadores. Si ve que el operador externo es más fuerte que el operador interno, inserta paréntesis para protegerlo.

valueToCode tiene la prioridad del operador externo, y el resultado tupla especifica la precedencia del operador interno.

Este es un ejemplo de un bloque que incluye dos operadores:

Un bloque con un operador de negación unario, un operador de suma y un operador secundario bloque. 

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];
}

Prioridad de valueToCode

Cuando llamas a valueToCode para generar el código de un bloque interno, lo pasas la precedencia del operador más potente que actúa sobre el código del interno bloque. Este es el operador contra el que se debe proteger el código del bloque interno.

En el siguiente ejemplo, se bloquean tanto el operador de negación unario como el de suma actúan sobre el código del bloque interno. La negación unaria es más fuerte, por lo que esa es la prioridad que debes pasar a valueToCode.

Un bloque con un operador de negación unario, un operador de suma y un operador secundario bloque. 

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

Prioridad de la devolución

Cuando muestres una prioridad del generador de código de bloque, precedencia del operador más débil dentro del código del bloque. Este es el que necesita protección.

Por ejemplo, el siguiente bloque contiene un operador de negación unario y un operador de suma. La suma es más débil, por lo que esa es la prioridad que debes del generador de código de bloque.

Un bloque con un operador de negación unario y un operador de suma, y ningún elemento secundario bloquear 

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

Ordenar enumeración

Cada módulo generador de lenguaje define una enum Order que incluye todos los precedentes para ese idioma.

Las prioridades más fuertes tienen valores de copia de seguridad más bajos y las más débiles tienen valores de copia de seguridad más altos. Puedes pensar que los grandes precedentes son la "clasificación" más alto" en fortaleza y menos precedencia, como estar "clasificado en una posición más baja" - como si eran luchadores de la competencia.

Aquí puedes encontrar las enumeraciones Order para todos los idiomas integrados:

Prioridades especiales

La mayoría de las prioridades Las enumeraciones Order coinciden con las prioridades definidas por sus respectivos idiomas basados en texto. Pero hay dos tipos precedencias, Order.ATOMIC y Order.NONE.

Order.ATOMIC es la mayor precedencia. Se usa en los siguientes casos:

Order.NONE es la prioridad más débil. Se usa en los siguientes casos: