Fallar puede dar miedo, pero es una parte importante de la programación. Puedes utilizar los fallos para aprender a depurar, encontrar los límites de un programa o ver con rapidez lo que no debes hacer.
Está bien fallar
En Verse, fallo significa algo específico. No siempre significa que algo no funcionó. Es una forma de controlar lo que hace tu programa.
¿Recuerdas en la Lección 4 cuando aprendiste que podías escribir código para hacer una pregunta sí o no?
var Tired: logic = false
var WhatToWatch: string = “nada”
if (Tired?):
set WhatToWatch = “tus párpados”
else:
set WhatToWatch = “dibujos animados”
Print(“Deberías ver {WhatToWatch}”)
# Deberías ver dibujos animados
El código con el que se hace la pregunta se escribe como una expresión falible. En el ejemplo anterior, Tired?
es una expresión falible.
Las expresiones falibles se utilizan para evitar errores que podrían hacer que el programa dejara de funcionar. Por ejemplo, debes saber que la división por cero es imposible. Si intentaras hacer esto en tu código, ¡podría fallar! Pero el siguiente código de Verse funcionará a la perfección.
if (5/0):
Print("¡Vaya!")
else:
Print("¡No puedes hacer eso!")
Para evitar este tipo de errores, Verse requiere que escribas las expresiones falibles en un contexto de fallo. Los contextos de fallo son lugares seguros para que las expresiones falibles fallen. En el ejemplo anterior, 5/0
era la expresión falible, y if()
era el contexto de fallo. Continúa leyendo para saber más sobre estos dos conceptos de Verse.

Expresiones falibles
Existen muchas formas de escribir expresiones falibles en Verse. Si una expresión hace una pregunta que requiera una respuesta afirmativa o negativa, es probable que sea falible.
A continuación se indican algunos tipos de preguntas que plantean las expresiones falibles:
- ¿Estas dos variables son mayores, menores o iguales entre sí?
- ¿Esta variable tiene el valor
true
? - ¿Esta variable tiene un valor?
- ¿Esta expresión provoca un error?
Si la respuesta a cualquiera de estas preguntas es sí, la expresión es correcta. Si la respuesta es no, la expresión falla. Lo que ocurre después de un éxito o un fallo depende de cómo escribas tu código.
Expresiones de comparación
Las expresiones de comparación, que utilizan operadores de comparación como <
(menor que), >
(mayor que) o <>
(no igual), son falibles. En el siguiente ejemplo, 5 < 4
es una expresión falible que fallará:
if (5 < 4):
Print(“Esto no se imprimirá nunca.”)
La expresión 5 < 4
es como preguntar "¿es 5 menor que 4?". La respuesta es no, la expresión falla y el bloque de código (indentado bajo la expresión if
) no se ejecuta.
Veamos el siguiente ejemplo, y la expresión falible MoustrapsSet <> MiceCaught
. Se pregunta "¿Los valores de MousetrapsSet y MiceCaught no son iguales?".
MousetrapsSet := 3
MiceCaught := 0
if (MousetrapsSet<>MiceCaught):
Print(“¡Necesito más queso!”)
Esta vez, la respuesta a la pregunta es sí porque MoustrapsSet
es 3 y MiceCaught
es 0, por lo que la expresión tiene éxito y el bloque de código se ejecuta.
Expresiones de decisión
Las expresiones de decisión, que utilizan los operadores and
, or
y not
, son falibles. En el siguiente ejemplo, MousetrapsForSale > 0 y Coins >= MousetrapCost
es una expresión falible que tendrá éxito porque MousetrapsForSale
es 5 (mayor que 0), Coins
es 30 y MousetrapCost
es 20 (30 es mayor que 20). Ambas expresiones tienen éxito por sí solas, por lo que toda la expresión tiene éxito.
MousetrapsForSale := 5
MousetrapCost := 20
Coins := 30
if (MousetrapsForSale > 0 and Coins >= MousetrapCost):
Print(“Puedes comprar trampas para ratones.”)
Expresiones de consulta
Las expresiones de consulta también son falibles. Utilizan el operador ?
para comprobar determinados valores, como comprobar si un valor logic
es true
. En el siguiente ejemplo, MousetrapStoreOpen?
es una expresión falible porque MousetrapStoreOpen
es false
.
var MousetrapStoreOpen : logic = false
if (MousetrapStoreOpen?):
Print(“¡Entra!”)
Contextos de fallo
En todos los ejemplos de código anteriores, la expresión if
era el contexto de fallo para las expresiones de fallo contenidas dentro de ()
. Los contextos de fallo proporcionan a las expresiones susceptibles de fallo un lugar seguro para fallar, porque determinan lo que ocurre en caso de fallo.
Ya sabes por una lección anterior que cuando falla una expresión en un if
, el código dentro del bloque de código if
no se ejecuta.
Como if
crea un contexto de fallo, puedes poner tantas expresiones de fallo en su bloque de código como quieras. Si alguna de esas expresiones falla, las expresiones anteriores del bloque de código se desharán o retrocederán.
Hay otra forma de escribir expresiones if
sin utilizar el ()
. Es más útil si necesitas escribir muchas expresiones. Aquí tienes un ejemplo:
MousetrapsSet:int = 5
var MiceCaught:int = 0
var BreakTime:logic = false
if:
MousetrapsSet > 0
set BreakTime = true
MiceCaught > 0
if (BreakTime?):
Print("¡Tómate un descanso!")
else:
Print("¡A cazar ratones!")
No es necesario que todas las expresiones de un contexto de fallo sean falibles, pero al menos una sí. En el ejemplo anterior, set BreakTime = true
no falla, pero las demás expresiones sí.
En el código anterior, cada expresión sangrada bajo if
está dentro del contexto de fallo. Se ejecutarán las tres expresiones.
MousetrapsSet > 0
lo hará correctamente.- La expresión
set BreakTime = true
se ejecutará. No es falible, por lo que no hay comprobación de fallo. - Sin embargo,
MiceCaught > 0
fallará.
Como se ha producido un fallo, se desharán todas las expresiones del bloque de código if
, incluido set BreakTime = true
. Será como si ese código nunca se hubiera ejecutado. Si ejecutas este código, verás que se imprime “¡A cazar ratones!”.
Al programar, verás que mucho código solo funciona si otro código se ejecuta correctamente. Esta es otra razón por la que los contextos de fallo son tan útiles. Si agrupas el código dependiente en contextos de fallo, puedes evitar algunos errores comunes. ¿Recuerdas el código que utilizaste en la Lección 4 para decidir si ibas al cine? Ahora que has decidido ir con tus amigos, ¡tienes que conseguirles las entradas, las bebidas y los aperitivos!
var Drinks:int = 4
var Snacks:int = 4
var Tickets:int = 3
var FriendsAvailable:int = 4
if:
Drinks >= FriendsAvailable
set Drinks -= FriendsAvailable
Snacks >= FriendsAvailable
set Snacks -= FriendsAvailable
Tickets >= FriendsAvailable
set Tickets -= FriendsAvailable
Print("Bebidas restantes: { Drinks }")
Print("Aperitivos restantes: { Snacks }")
Print("Entradas restantes: { Tickets }")
El operador -=
es un atajo para combinar la resta y la asignación. En el ejemplo anterior, set Tickets -= FriendsAvailable
equivale a set Tickets = Tickets - FriendsAvailable
. Esto también funciona con la suma (+=
), la multiplicación (*=
) y la división (/=
).
Tienes suficientes bebidas y aperitivos para tus amigos, pero no suficientes entradas. Eso significa que todos no podréis ver la película. Podrías escribir algún código para manejar esa situación, pero probablemente no quieras dar tus bebidas y aperitivos.
Por suerte, cuando se ejecute la expresión Tickets >= FriendsAvailable
, fallará y todo el código del bloqueo if
se revertirá. Esto significa que las variables Drinks
y Snacks
volverán a tener el valor 4
.
Resumen
- En Verse, los fallos son una forma de controlar tu programa.
- Las expresiones de fallo pueden tener éxito o fallar, y deben escribirse en un contexto de fallo. Lo que ocurre tras un éxito o un fracaso depende de cómo esté escrito tu código.
- Los contextos de fallo dan a las expresiones falibles un lugar seguro para fallar. Cualquier fallo dentro de un contexto de fallo hace que todo el código dentro de ese contexto se revierta, como si nunca se hubiera ejecutado.