Conditional structures: Difference between revisions
no edit summary
m (→{{header|FutureBasic}}: Indent code) |
No edit summary |
||
Line 800:
a + b is three
two
</pre>
=={{header|Amazing Hopper}}==
Las estructuras condicionales en Hopper son inexistentes. Pero se pueden definir estructuras de alto nivel, todas las que su imaginación le dicte... Bueno, todas las que Hopper le permita hacer con sus instrucciones. Existen instrucciones que permiten evaluar el contenido de la memoria, como "eq?", que evalúa si dos valores son iguales, o "zero?", que evalúa si el valor es cero. También cuenta con saltos condicionales que evalúan el contenido de la memoria, como "jle( etiqueta )", que saltará a etiqueta si el primer valor en memoria es menor o igual al segundo valor en memoria.
Hasta ahora se han definido cuatro "sabores" para Hopper. Aquí repasaremos las estructuras condicionales del sabor "Jambo".
OBSERVACION: todas estas estructuras condicionales permiten anidamiento.
La más clásica:
<pre>
If ( expresion )
...
Else If ( expresion )
...
Else
...
End If
</pre>
La macro "MOVE IF", mueve un valor desde la memoria hasta una variable, según si se cumple una expresión lógica. El valor es quitado de la memoria. En el ejemplo, moverá "15" a la variable "x":
<pre>
sw=1
Add(10,5)
Move if( sw, x, y)
</pre>
La macro "COPY IF" es semejante a "MOVE IF", pero deja el valor en la memoria:
<pre>
sw=1
Add(10,5)
Copy if( sw, x, y) --> x guarda "15"
Prnl --> imprime "15"
</pre>
La macro "MOVE ON" mueve un valor desde la memoria hasta una variable, si se cumple una condición lógica; si no se cumple, el valor se retira de la memoria. Ejemplo:
<pre>
sw=0
Add(10,5)
Move on( sw, x)
</pre>
La macro "COPY ON" es semejante a "MOVE ON", pero deja el valor en la memoria, haya o no haya sido guardado en la variable. Ejemplo:
<pre>
sw=0
Add(10,5)
Copy on( sw, x)
Prnl
</pre>
La macro "SEL ON" deja un valor o resultado de una expresión en memoria, si se cumple la condición:
<pre>
Set '100, 10, 0.05, 1.5E-5'
sw=1
Sel on( sw, Add(10,5) )
Apnd Lst 'lista'
</pre>
La macro "SET IF" deja en memoria el resultado de una expresión o un valor en memoria, dependiendo de una expresión lógica. En el ejemplo, dejará el resultado de la suma:
<pre>
sw=1
Set if ( sw, Add(10,5), Sub( 10, Mul(i,2) ) )
Move to 'res'
</pre>
La macro "GET IF" obtiene un valor o resultado de una expresión, según una expresión lógica. Es idéntica a "SET IF", pero puede ser usada con la macro "LET":
<pre>
sw=1
Let ' res := Get if ( sw, Add(10,5), Sub( 10, Mul(i,2) ) ) '
</pre>
La macro "SWITCH" es una macro de selección múltiple, pero puede ser evaluada una expresión o valor de cualquier tipo:
<pre>
Switch ( expresion|valor )
Case 'valor' { ... [Exit] } --> coincide con el valor
Btwn 'v1, v2' { ... [Exit] } --> si está entre los valores "v1" y "v2"
Exact occurs 's' { ... [Exit] } --> si está contenido exactamente en el string "s"
Occurs 's' { ... [Exit] } --> si está contenido en el string "s"
On list 'l' { ... [Exit] } --> si está en el array-lista "l"
Default { ... [Exit] } --> si nada tiene sentido.
End switch
</pre>
Se pueden usar otras macros como evaluadores "CASE", como son las siguientes:
<pre>
Case not negative { ... [Exit] }
Case not zero { ... [Exit] }
Case not positive { ... [Exit] }
Case not numeric { ... [Exit] }
Case not string { ... [Exit] }
Case not array { ... [Exit] }
Case not null { ... [Exit] }
Case negative { ... [Exit] }
Case zero { ... [Exit] }
Case positive { ... [Exit] }
Case numeric { ... [Exit] }
Case string { ... [Exit] }
Case array { ... [Exit] }
Case null { ... [Exit] }
</pre>
EL "ODIADO" GOTO (pero yo lo amo):
La estructura "ON GOTO" se usa para saltar a una etiqueta de acuerdo a lo que encuentre en la memoria. Evalúa valores desde 1 en adelante. NOTA: si el valor de la memoria no coindice con la evaluación de "ON GOTO", queda en la memoria.
<pre>
EQ3:
instrucciones
Goto 'Elección de saltos'
...
Elección de saltos:
Ceil(Rand '3'), On goto( EQ1, EQ2, EQ3 )
Kill --> retira el valor de la memoria, si no fue consumido por "ON GOTO"
...
EQ1:
instrucciones
EQ2:
instrucciones
</pre>
La estructura "ON GOSUB" es idéntica a "ON GOTO", pero el control del programa retorna luego de ejecutado el bloque:
<pre>
Ceil(Rand '3'), On gosub( EQ1, EQ2, EQ3 )
Kill --> retira el valor de la memoria, si no fue consumido por "ON GOSUB"
...
EQ1:
instrucciones
back
EQ2:
instrucciones
back
EQ3:
instrucciones
back
</pre>
La estructura "ON OPTION" realiza una acción según el valor encontrado en memoria, que debe iniciar desde 1 en adelante. Si el valor memorizado no es consumido por "ON OPTION", queda en memoria y puede ser eliminado o usado por el programa:
<pre>
x=10
Set '3'
On option (x+=0.5, x-=0.5, x*=0.5; l=x) --> ejecuta "x*=0.5" y "l=x"
Printnl ("Resultado X= ", x)
</pre>
La estructura "LINK GOSUB" invoca subrutinas en secuencia. En el ejemplo, se memoriza "100", luego, se invoca a "proc1" que obtiene 200, luego invoca a "proc2" que obtiene "1000", y finalmente invoca a "proc3" que obtiene "500":
<pre>
Main
Set(100), Link gosub(proc1, proc2, proc3)
Prnl --> imprime el valor "500".
End
Subrutines
Define( proc1, dato )
Return ' Add(dato,100) '
Define ( proc2, dato )
Return ' Mul(dato,5) '
Define( proc3, dato )
var(dato) Div into(2)
Return
</pre>
| |||