L'intérêt est intéressant

Une boucle est une structure de contrôle qui permet d'exécuter du code de façon répétée en fonction d'une condition donnée.

Les boucles While

Une boucle while est une structure de contrôle qui permet d'exécuter du code de façon répétée en fonction d'une condition donnée. Le code à l'intérieur d'une boucle while continue de s'exécuter tant que la condition est évaluée comme vraie (truthy). On utilise souvent les boucles while quand le nombre d'itérations n'est pas connu à l'avance, mais elles peuvent servir dans toute situation où une boucle est nécessaire.

La condition est évaluée avant l'exécution du code de la boucle, ce qui signifie que si la condition est fausse, le code de la boucle ne sera jamais exécuté.

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

# Output:
# 0
# 1
# 2

Pour parcourir une chaîne de caractères, tu peux boucler sur la longueur de la chaîne.

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

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

Les boucles Until

Les boucles until fonctionnent comme les boucles while, sauf que le code de la boucle continue de s'exécuter jusqu'à ce que la condition soit évaluée comme vraie (truthy). C'est la même différence qu'entre if et unless.

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

Les boucles infinies

Une erreur fréquente avec les boucles while est de tomber dans une « boucle infinie », qui ne se termine jamais. Une boucle infinie peut être causée par une condition qui n'est jamais évaluée comme vraie (truthy) ou fausse (falsey). C'est souvent dû à une erreur du programmeur, par exemple l'oubli d'incrémenter la variable de la boucle. Mais parfois, une boucle infinie est la façon la plus claire d'implémenter la logique du programme. Il arrive aussi qu'il soit indispensable de boucler indéfiniment : par exemple, un serveur HTTP attend une connexion entrante, la traite, puis attend la connexion suivante.

Break

Le mot-clé break permet de quitter une boucle plus tôt que prévu. C'est pratique quand on veut sortir d'une boucle avant la fin sous certaines conditions.

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

# Output:
# 0
# 1

Next

Le mot-clé next permet de passer directement à l'itération suivante d'une boucle. C'est pratique quand on veut sauter certaines itérations d'une boucle.

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

# Output:
# 1
# 3

Les types au sein d'une boucle

Le type d'une variable peut changer au fil d'une boucle. Dans l'exemple suivant, le type de a est Int32 | String, car elle peut être un Int32 ou une String dans la première partie de la boucle. La variable a ne porte le type Int32 | String que dans la première partie de la boucle : quand la boucle démarre, elle contient un Int32, et à la deuxième itération, elle contient une String. Ce système à types multiples sera expliqué en détail plus tard. Mais comme on est certain que la seconde partie de la boucle ne contiendra que String, le type de a est String dans la seconde partie de la boucle. À l'exécution, elle ne contiendra jamais simultanément Int32 et String.

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

En Crystal, la dernière expression d'une méthode renvoie sa valeur. Cependant, il arrive qu'on doive renvoyer une valeur avant la dernière expression. Pour cela, tu peux utiliser le mot-clé return, qui renvoie la valeur de l'expression qui le suit. Le code écrit après un mot-clé return ne sera pas exécuté.

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