SEO-Descrição: Saiba como a falha é usada para controlar o fluxo do seu programa no Verse. Parent: learn-the-basics-of-writing-code-in-verse Order: 17 Type: tutorial Tags: programa Tags: falha Tags: condicionais Tags: fluxo de controle Tags: if Tags: verse Hero-image:lesson-hero.png Topic-image:lesson-topic.png Social-image:lesson-social.png Prereq: learn-code-basics-8-input-parameters-arguments-in-verse
Falhas podem ser assustadoras, mas são uma parte importante da programação. Você pode usar suas falhas para aprender a depurar, descobrir os limites de um programa ou ver rapidamente o que não deve ser feito!
Não há nada de errado em falhar
Em Verse, falha significa algo específico. Nem sempre significa que algo não funcionou. É uma maneira de controlar o que o programa faz.
Você se lembra que na Aula 4 quando você aprendeu que poderia escrever código para fazer uma pergunta sim ou não?
var Tired: logic = false
var WhatToWatch: string = “nada”
if (Tired?):
set WhatToWatch = “suas pálpebras”
else:
set WhatToWatch = “assistir a desenhos animados”
Print(“Você deve {WhatToWatch}”)
# Você deve assistir a desenhos animados
~~~
O código que faz a pergunta é escrito como uma **expressão falível**. No exemplo acima, `Tired?` é uma expressão falível.
Expressões falíveis são usadas para evitar erros que podem fazer o programa parar de funcionar completamente. Por exemplo, talvez você saiba que a divisão por zero é impossível. Se tentar fazer isso no código, ele poderá travar! Porém, o código Verse a seguir funcionará perfeitamente.
~~~(verse)
if (5/0):
Print("Pera aí!")
else:
Print("Você não pode fazer isso!")
Para evitar esses tipos de erros, o Verse exige que você escreva expressões falíveis em um contexto de falha. Contextos de falha fornecem a expressões falíveis um local seguro para falhar. No exemplo acima, 5/0 era a expressão falível e if() era o contexto de falha. Continue lendo para saber mais sobre esses dois conceitos do Verse.
Expressões falíveis
Existem muitas maneiras de escrever expressões falíveis em Verse. Se uma expressão está fazendo uma pergunta sim ou não, provavelmente ela é falível.
Aqui estão alguns tipos de perguntas feitas pelas expressões falíveis:
- Essas duas variáveis são maiores, menores ou iguais entre si?
- Essa variável está definida como
true? - Essa variável está definida como um valor?
- Essa expressão causa erros?
Se a resposta a qualquer uma dessas perguntas for sim, a expressão terá êxito. Se a resposta for não, a expressão terá uma falha. O que acontece após um êxito ou falha depende de como você escreve o código.
Expressões de comparação
Expressões de comparação, que usam operadores de comparação como < (menor que), > (maior que) ou <> (diferente), são falíveis. No exemplo a seguir, 5 < 4 é uma expressão falível que falhará:
~~~(verse) if (5 < 4): Print("Isso nunca será gerado.") ~~~
A expressão 5 < 4 é como perguntar "5 é menor que 4?". A resposta é não, a expressão falha e o bloco de código (recuado sob a expressão if) não é executado.
Vejamos esse próximo exemplo e a expressão falível MousetrapsSet <> MiceCaught. Ela está perguntando "Os valores de MousetrapsSet e MiceCaught não são iguais?".
~~~(verse) MousetrapsSet := 3 MiceCaught := 0
if (MousetrapsSet<>MiceCaught): Print("Precisa de mais queijo!")
Dessa vez, a resposta para a pergunta é **sim** porque `MousetrapsSet` é 3 e `MiceCaught` é 0, então a expressão é bem-sucedida, e o bloco de código **é executado*.
### Expressões de decisão
Expressões de decisão, que usam os operadores `and`, `or` e `not`, são falíveis. No exemplo a seguir, `MousetrapsForSale > 0 and Coins >= MousetrapCost` é uma expressão falível que será bem-sucedida porque `MousetrapsForSale` é 5 (maior que 0), `Coins` é 30 e `MousetrapCost` é 20 (30 é maior que 20). Ambas as expressões são bem-sucedidas por si só e, portanto, toda a expressão é bem-sucedida.
~~~(verse)
MousetrapsForSale := 5
MousetrapCost := 20
Coins := 30
if (MousetrapsForSale > 0 and Coins >= MousetrapCost):
Print("Você pode comprar ratoeiras.")
Expressões de consulta
Expressões de consulta também são falíveis. Elas usam o operador ? para verificar certos valores, por exemplo, se um valor logic é true. No exemplo a seguir, MousetrapStoreOpen? é uma expressão falível porque MousetrapStoreOpen é false.
~~~(verse) var MousetrapStoreOpen : logic = false
if (MousetrapStoreOpen?): Print("Pode entrar!")
## Contextos de falha
Em todos os exemplos de código acima, a expressão `if` era o contexto de falha para as expressões passíveis de falha contidas em `()`. Contextos de falha fornecem às expressões falíveis um local seguro para falhar, pois determinam o que acontece no caso de uma falha.
Você já aprendeu em uma lição anterior que, quando uma expressão em `if` falha, o código dentro do bloco de código `if` não é executado.
Como `if` cria um contexto de falha, você pode colocar quantas expressões falíveis desejar no bloco de código. Se alguma dessas expressões falhar, as expressões anteriores nesse bloco de código serão desfeitas ou **revertidas**.
Existe outra maneira de escrever expressões `if` sem usar `()`. Ela é mais útil quando você precisa escrever muitas expressões. Aqui está um exemplo:
~~~(verse)
MousetrapsSet:int = 5
var MiceCaught:int = 0
var BreakTime:logic = false
if:
MousetrapsSet > 0
set BreakTime = true
MiceCaught > 0
if (BreakTime?):
Print("Faça uma pausa!")
else:
Print("Capture alguns ratos!")
Nem todas as expressões em um contexto de falha precisam ser falíveis, mas pelo menos uma precisa. No exemplo acima, set BreakTime = true não é falível, mas as outras expressões sim.
No código acima, cada expressão recuada em if está dentro do contexto de falha. Todas as três expressões serão executadas.
MousetrapsSet > 0terá êxito.- A expressão
set BreakTime = trueserá executada. Ela não é falível e, portanto, não há verificação de falha. - No entanto,
MiceCaught > 0falhará.
Como houve uma falha, todas as expressões no bloco de código if serão revertidas, incluindo set BreakTime = true. Será como se o código nunca tivesse sido executado. Se você executar esse código, verá a mensagem "Capture alguns ratos!".
Ao programar, você verá que muitos códigos só funcionarão se outros códigos forem executados com êxito. Esta é outra razão pela qual contextos de falha são tão úteis. Se você agrupar um código dependente em contextos de falha, poderá evitar alguns bugs comuns. Você se lembra do código que usou na Aula 4 para decidir se iria ou não ao cinema? Agora que você decidiu ir com seus amigos, precisa comprar ingressos, bebidas e lanches!
~~~(verse) 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("Lanches restantes: { Snacks}") Print("Ingressos restantes: { Tickets}") ~~~
O operador -= é um atalho para combinar subtração e atribuição. No exemplo acima, set Tickets -= FriendsAvailable é equivalente a set Tickets = Tickets - FriendsAvailable. Isso também funciona com adição (+=), multiplicação (*=) e divisão (/=).
Você tem bebidas e lanches suficientes para seus amigos, mas não tem ingressos suficientes. Ou seja, você e todos os seus amigos não podem assistir ao filme. Você pode escrever um código para lidar com essa situação, mas provavelmente não quer distribuir suas bebidas e lanches.
Felizmente, quando a expressão Tickets >= FriendsAvailable for executada, ela falhará, e todo o código no bloco if será revertido. Ou seja, as variáveis Drinks e Snacks voltarão a ter o valor 4.
Resumo
- Em Verse, uma falha é uma forma de controlar o programa.
- Expressões de falha podem ser bem-sucedidas ou falhar e devem ser escritas em um contexto de falha. O que acontece após um sucesso ou falha depende de como o código é escrito.
- Contextos de falha dão às expressões falíveis um lugar seguro para falhar. Qualquer falha dentro de um contexto de falha faz com que todo o código dentro desse contexto seja revertido, como se nunca tivesse sido executado.