Inserimento delle parentesi

I blocchi sottintendono parentesi. Ad esempio, quando vedi i seguenti blocchi, presupponi che significa -(5 + 2) e non -5 + 2 perché 5 e 2 fanno parte di in un blocco, mentre - fa parte di un altro.

blocchi che rappresentano -(5 + 2)

Ma se racchiudi ogni blocco tra parentesi, il codice diventa molto meno leggibili. Confronta (((5) * (2)) + (3)) con 5 * 2 + 3. Entrambe le opzioni le espressioni restituiscono la stessa cosa (13), ma la seconda è molto più semplice per leggere.

Le regole di precedenza degli operatori di Blockly consentono di generare codice con il minimo di parentesi tonde per ottenere la massima leggibilità.

Genera informazioni "corrette" output

Se non è necessario che il codice generato sia leggibile, non è necessario preoccuparsi di ridurre al minimo le parentesi. Aggregare ogni blocco è un approccio corretto, e garantisce che il codice generato venga sempre valutato correttamente.

Per garantire la correttezza, trasmetti sempre Order.ATOMIC a valueToCode chiamate e restituisce sempre Order.NONE dal generatore di codici a blocchi.

Generare parentesi ottimali

Le parentesi devono essere inserite solo se il codice generato non è corretto senza che li rappresentano. Ciò accade quando la precedenza di un operatore nel blocco esterno è maggiore della precedenza di un operatore nel blocco interno.

Ad esempio, nei blocchi seguenti sono presenti un operatore di negazione unaria e un operatore di addizione. La negazione unaria ha una precedenza più forte rispetto operatore di addizione.

nega e aggiunta

Quindi se non aggiungi parentesi ottieni -5 + 2 e - viene valutato prima di +, che non corrisponde ai blocchi.

Puoi indicare al generatore quando inserire le parentesi indicando l'efficacia dai vari operatori. Se vede che l'operatore esterno è più forte rispetto all'operatore interno, inserisce parentesi per proteggere l'operatore interno.

valueToCode ha la precedenza sull'operatore esterno e il ritorno tupla specifica la precedenza dell'operatore interno.

Di seguito è riportato un esempio di un blocco che include due operatori:

Un blocco con un operatore di negazione unaria e un operatore di addizione, oltre a un bloccare. 

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

Precedenza valueToCode

Quando chiami valueToCode per generare il codice di un blocco interno, lo passi la precedenza dell'operatore più potente che agisce sul codice dell'interfaccia bloccare. Questo è l'operatore da cui deve essere protetto il codice del blocco interno.

Ad esempio, nei blocchi che seguono sia l'operatore di negazione unaria che l'operatore di addizione agisce sul codice del blocco interno. La negazione unaria è più forte, quindi questa è la precedenza da trasmettere a valueToCode.

Un blocco con un operatore di negazione unaria e un operatore di addizione, oltre a un bloccare. 

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

Precedenza restituita

Quando restituisci una precedenza dal generatore di codici a blocchi, restituisci il valore precedenza dell'operatore più debole all'interno del codice del blocco. Questo è il da proteggere.

Ad esempio, il blocco seguente contiene sia un operatore di negazione unaria sia un operatore di addizione. L'aggiunta è più debole, quindi questa è la precedenza su cui dovresti il generatore di codice a blocchi.

Un blocco con un operatore di negazione unaria e un operatore di addizione, senza elementi figlio blocca 

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

Enum dell'ordine

Ogni modulo del generatore di linguaggio definisce un'enumerazione Order che include tutti le precedenti per quella lingua.

Le priorità più elevate hanno valori di supporto più bassi, mentre le precedenti più deboli hanno valori di supporto più bassi. con valori di supporto più elevati. Le forti precedenza sono considerate "classificate" superiore" in termini di forza e più deboli in termini di "ranking più basso" - come se fossero erano combattenti competitivi.

Ecco dove puoi trovare le enumerazioni Order per tutte le lingue integrate:

Precedenza speciali

La maggior parte delle precedenza nei generatori Order enum corrispondono alle precedenti definiti dalle rispettive lingue di testo. Ma ci sono due speciali precedenti, Order.ATOMIC e Order.NONE.

Order.ATOMIC è la priorità più elevata. Viene utilizzata quando:

Order.NONE è la precedenza più debole. Viene utilizzata quando: