Juros são interessantes

Um laço é uma estrutura de controle que permite executar código repetidamente com base em uma determinada condição.

Laços while

Um laço while é uma estrutura de controle que permite executar código repetidamente com base em uma determinada condição. O código dentro de um laço while continua sendo executado enquanto a condição for avaliada como verdadeira. Laços while costumam ser usados quando o número de iterações é desconhecido de antemão. Eles podem ser usados em qualquer situação em que um laço seja necessário.

A condição é avaliada antes de o código dentro do laço ser executado. Isso significa que, se a condição for falsa, o código dentro do laço nunca será executado.

i = 0
while i < 3
  puts i
  i += 1
end

# Output:
# 0
# 1
# 2

Quando você quer iterar sobre uma string, pode fazer um laço sobre o comprimento dela.

str = "Hello"
i = 0
while i < str.size
  puts str[i]
  i += 1
end

# Output:
# H
# e
# l
# l
# o

Laços until

Laços until funcionam da mesma forma que os laços while, exceto que o código dentro do laço continua sendo executado até que a condição seja avaliada como verdadeira. É a mesma diferença que existe entre if e unless.

i = 0
until i == 3
  puts i
  i += 1
end

Laços infinitos

Um erro comum com laços while é entrar em um "laço infinito", que nunca termina. Um laço infinito pode ser causado por uma condição que nunca é avaliada como verdadeira ou falsa. Isso geralmente acontece por erro do programador, por exemplo, esquecer de incrementar a variável do laço. Mas às vezes um laço infinito é a forma mais clara de implementar a lógica do programa. Ou é essencial repetir para sempre. Por exemplo, um servidor HTTP espera por uma conexão de entrada, trata essa conexão e depois espera pela próxima.

Break

A palavra-chave break pode ser usada para sair de um laço antes do fim. Isso pode ser conveniente quando você quer sair de um laço antes do fim em determinadas condições.

i = 0
while i <= 3
  puts i
  i += 1
  if i == 2
    break
  end
end

# Output:
# 0
# 1

Next

A palavra-chave next pode ser usada para pular para a próxima iteração de um laço. Isso pode ser conveniente quando você quer pular iterações específicas de um laço.

i = 0
while i <= 3
  i += 1
  if i == 2
    next
  end
  puts i
end

# Output:
# 1
# 3

Tipos dentro de laços

O tipo da variável pode ser diferente dentro de um laço. No exemplo a seguir, o tipo de a é Int32 | String porque pode ser Int32 ou String na primeira parte do laço. A variável a só carrega o tipo Int32 | String na primeira parte do laço, já que, quando o laço começa, ela contém Int32 e, na segunda iteração, contém uma String. Esse sistema de múltiplos tipos será explicado em detalhes mais adiante. Mas, como temos certeza de que a segunda parte do laço só conterá String, o tipo de a é String na segunda parte do laço. Em tempo de execução, ela nunca conterá Int32 e String ao mesmo tempo.

i = 0
a = 4
while i < 3
  p typeof(a)
  # => Int32 | String
  a = "4"
  p typeof(a)
  # => String
  i += 1
end

Em Crystal, a última expressão de um método retorna seu valor. No entanto, às vezes você precisa retornar um valor antes da última expressão. Para isso, você pode usar a palavra-chave return, que retorna o valor da expressão seguinte. O código escrito depois de uma palavra-chave return não será executado.

def speed_limit(road_number)
    if road_number == 1
        return 50
        puts "This will not be executed"
    elsif road_number == 2
        return 80
        puts "This will not be executed"
    end
    100
end

p speed_limit(1) # => 50
p speed_limit(2) # => 80
p speed_limit(3) # => 100