Los fallos pueden dar miedo, pero son 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 = “nothing”
if (Tired?):
set WhatToWatch = “your eyelids”
else:
set WhatToWatch = “cartoons”
Print(“Deberías mirar {WhatToWatch}”)
# Deberías mirar 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 entre 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("¡Oye!")
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 por sí o no, 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 exitosa. 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 nunca se mostrará.”)
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 (delimitado 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(“¡Necesitamos 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 and 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í mismas, 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. Se utiliza el operador ?
para comprobar ciertos valores, por ejemplo 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(“¡Adelante!”)
Contexto de fallo
En todos los ejemplos de código anteriores, la expresión if
era el contexto de fallo para las expresiones falibles contenidas dentro de `() Los contextos de fallo son, para las expresiones falibles, un lugar seguro para fallar porque determinan lo que ocurre en caso de fallo.
Ya sabes de una lección anterior que cuando una expresión en un if
falla, el código dentro del bloque de código if
no se ejecuta.
Como if
crea un contexto de fallo, puedes poner la cantidad de expresiones de fallo que desees en su bloque de código. Si alguna de esas expresiones falla, las expresiones anteriores en el bloque de código se desharán o revertirán.
Existe otra forma de escribir expresiones if
sin usar ()
. Es más útil si necesitas escribir muchas expresiones. Mira el siguiente ejemplo:
MousetrapsSet:int = 5
var MiceCaught:int = 0
var BreakTime:logic = false
if:
MousetrapsSet > 0
set BreakTime = true
MiceCaught > 0
if (BreakTime?):
Print("¡Descansa un poco!")
else:
Print("¡Atrapa ratones!")
En un contexto de fallo, no todas las expresiones tienen que ser falibles, pero al menos una sí. En el ejemplo anterior, set BreakTime = true
no es falible, pero las otras expresiones sí.
En el código anterior, cada expresión delimitada bajo if
está dentro del contexto de fallo. Las tres expresiones se ejecutarán.
MousetrapsSet > 0
tendrá éxito.- 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á.
Dado que hubo un fallo, cada expresión en el bloque de código if
será revertida, incluso set BreakTime = true
. Será como si el código nunca se hubiera ejecutado. Si ejecutas este código, verás en la pantalla "Atrapa algunos ratones".
Al programar, verás que a menudo hay código que solo funciona si otro fragmento de código se ejecuta de forma correcta. Esta es otra razón por la que los contextos de fallo son tan útiles. Si agrupas 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 decidiste ir con tus amigos, ¡tienes que conseguirles las entradas, las bebidas y la comida!
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("Comida restante: { Snacks }")
Print("Boletos restantes: { Tickets }")
El operador -=
es un atajo para combinar resta y asignación. En el ejemplo anterior, set Tickets -= FriendsAvailable
equivale a set Tickets = Tickets - FriendsAvailable
. También funciona con la suma (+=
), la multiplicación (*=
) y la división (/=
).
Tienes suficientes bebidas y aperitivos para tus amigos disponibles, pero no suficientes entradas. Eso significa que tú y todos tus amigos no podrán ver la película. Podrías escribir algún código para arreglar esa situación, pero es probable que no quieras repartir tus bebidas y comida.
Por suerte, cuando la expresión Tickets >= FriendsAvailable
se ejecute, fallará y todo el código del bloque if
se revertirá. Esto significa que las variables Drinks
y Snacks
volverán a tener el valor 4
.
Resumen
- En Verse, el fallo es 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 sucede después de un éxito o un fallo depende de cómo está escrito tu código. Los * contextos de fallo son un lugar seguro para que las expresiones de fallo puedan fallar. Cualquier fallo dentro de un contexto de fallo provoca que todo el código dentro de ese contexto se revierta, como si nunca se hubiera ejecutado.