For

Le espressioni for, a volte chiamate loop for, sono simili alle espressioni loop, tranne per il fatto che le espressioni for eseguono interazioni su un numero limitato di elementi. Ciò significa che il numero di iterazioni è noto prima che venga eseguito il loop for e le decisioni su quando uscire dal loop sono automatizzate.

Il dispositivo Attivatore a impulsi è un esempio di un loop for con iterazioni limitate quando si imposta la ripetizione del dispositivo stesso su un numero. L'impulso dell'Attivatore a impulsi si ripete tutte le volte specificate dall'impostazione looping del dispositivo.

In questo esempio, sono presenti due dispositivi Trigger nel percorso dell'Attivatore a impulsi. Quando l'impulso dell'Attivatore a impulsi raggiunge un dispositivo Trigger, questo invia un segnale per visualizzare il testo su uno dei dispositivi Billboard, ripetendolo tre volte.

Come codice, questo esempio potrebbe essere simile al seguente:

for (X := 0..2):
    TriggerDevice1.Transmit()
    TriggerDevice2.Transmit()
Copy full snippet

L'espressione for contiene due parti:

• Specifica di iterazione: Le espressioni tra parentesi e la prima espressione devono essere un generatore. In questo esempio è (X := 0..2).
• Corpo: Espressioni dopo le parentesi. In questo esempio, queste sono le due righe con Transmit().

Generatore

Un generatore produce una sequenza di valori, uno alla volta, e assegna un nome al valore. In questo esempio, il generatore è X := 0..2, quindi ogni iterazione del loop, il generatore produce il valore successivo e assegna al valore il nome X. Quando il generatore raggiunge la fine della sequenza, il loop for termina. Questo flusso decisionale di controllo, se la variabile loop ha un valore valido, è incorporato nell'espressione for. I generatori supportano soltanto intervalli, array e mappe.

Iterazione su un intervallo

Il tipo intervallo rappresenta una serie di numeri interi, ad esempio, 0..3, e Min..Max.

L'inizio dell'intervallo è il primo valore nell'espressione, ad esempio 0, e la fine dell'intervallo è il valore che segue .. nell'espressione, ad esempio 3. L'intervallo contiene tutti i valori interi compresi tra i valori iniziali e finali. Ad esempio, l'espressione di intervallo 0..3 contiene i numeri 0, 1, 2 e 3. Le espressioni dell'intervallo supportano soltanto i valori int e si possono utilizzare soltanto nelle espressioni for, sync, race e rush.

for (Number := 0 .. 3):
    Log("{Number}")
Copy full snippet

Il risultato aggiunge quattro righe al registro contenente i numeri 0, 1, 2 e 3.

Un'espressione for può restituire i risultati di ogni iterazione in un array. Nell'esempio seguente, Numbers è un array non modificabile con i valori int da -1 a -10.

Numbers := for (Number := 1..10):
    -Number
Copy full snippet

Iterazione su un array o una mappa

Le iterazioni su array e mappe possono essere soltanto i valori o la coppia chiave-valore per le mappe e la coppia indice-valore per gli array.

In questo caso, vengono utilizzati soltanto i valori dell'array e Values è un array non modificabile con i valori int 2, 3 e 5.

Values := for (X : array{1, 2, 4}):
    X+1
Copy full snippet

Lo stesso si può fare con una mappa e ´Values, in questo caso, è un array non modificabile con i valori int 3, 7`.

Values :=  for  (X := map{ 1=>3,  0=>7 }):
    x
Copy full snippet

Il modello X->Y si può utilizzare per decostruire una coppia indice-valore o chiave-valore. L'indice (o chiave) è associato alla parte sinistra (X) e il valore è associato alla parte destra (Y). Un esempio di coppie indice-valore da un array, Values è un array non modificabile con i valori int 1, 3 e 6.

Values := for ( X -> Y : array{1, 2, 4}) :
    X + Y
Copy full snippet

Un esempio di coppie indice-valore da una mappa, Values è un array non modificabile con i valori int 4 e 7.

Values  :=  for ( X->Y := map{ 1=>3,  0=>7 }):
    X + Y
Copy full snippet

Filtro

È possibile aggiungere espressioni fallibili all'espressione for per filtrare i valori dal generatore. Se il filtro non riesce, non c'è alcun risultato per quell'iterazione e for salta al valore successivo prodotto dal generatore.

Ad esempio, il filtro Num <> 0 viene aggiunto all'espressione for per escludere 0 dai risultati restituiti.

NoZero := for (Number := -5..5, Number <> 0):
    Numero
Copy full snippet

Sintatticamente, questo è uguale a:

expression0
for (Item : Collection, test-arg-block):
    expression1
expression2
Copy full snippet

Definizione

Puoi anche aggiungere espressioni denominate alla specifica dell'iterazione e il nome si può utilizzare sia nella specifica dell'iterazione che nel corpo.

Values := for ( X := 1..5; Y:=SomeFunction(X); Y < 10):
    Y
Copy full snippet

Risultato: un array con al massimo 5 elementi in cui tutti i valori sono inferiori a 10.

For nidificato

Puoi nidificare un loop for all'interno di un altro loop for. Ci sono due modi per farlo:

• Singolo per espressione: specificato da più generatori. Il risultato è un array unidimensionale.

• Espressioni for multiple: blocchi for separati. Il risultato è un array multidimensionale.

Le sezioni seguenti li descrivono ulteriormente.

Espressione for singola

È possibile avere più loop in una singola espressione for aggiungendo più generatori. Il risultato di una singola espressione for con più generatori è un array unidimensionale.

In questo esempio, Values è un array non modificabile con i valori int 13, 14, 23 e 24.

    Values := for(X:=1..2, Y:=3..4):
        X * 10 + Y
Copy full snippet

Semanticamente, questo è lo stesso di:

expression0
for (Item : Collection, Item2 : Collection2):
    expression1
expression2
Copy full snippet

Espressioni for multiple

Puoi anche nidificare un'espressione for in un altro corpo for-loop. Poiché un'espressione for restituisce un array unidimensionale, la nidificazione di un'espressione for restituisce un array bidimensionale.

In questo caso, Values è un array non modificabile con due array int non modificabili. Il primo array contiene i valori 13 e 14 e il secondo array contiene 23 e 24. (Si può scrivere array{ array{13, 14}, array{23, 24} }.)

Values := for ( X := 1..2 ):
    for (Y := 3..4):
        X * 10 + Y
Copy full snippet

Errore

Se qualcosa non riesce all'interno della specifica di iterazione, qualsiasi modifica dovuta a tale iterazione verrà sottoposta a rollback.

for(X := 1..5; S := IncrementSomeVariable(); X < 3):
    x
Copy full snippet

Il risultato di questa espressione for è array{1,2}, con due sole chiamate a IncrementSomeVariable dopo la valutazione del loop for perché le altre chiamate sono state sottoposte a rollback quando il filtro X < 3 non è riuscito.