Boucles Zig

En Zig, les structures de boucle incluentwhileboucles etforboucles. Chaque boucle a sa syntaxe et son utilisation spécifiques. Ce qui suit détaille les deux structures de boucle, y compris leur syntaxe, leur description et des exemples.

1, whileBoucles

Syntaxe

while (condition) : (increment) {
    // code block
}
  • condition: une expression booléenne. Tant qu'elle esttrue, la boucle continuera à s'exécuter.
  • increment(facultatif) : une expression exécutée après la fin de chaque itération de la boucle.

Description

whileLa boucle vérifie la condition avant chaque itération. Si la condition esttrue, elle exécute le code dans le corps de la boucle. Une fois le corps de la boucle terminé, exécutez l'incrementexpression (le cas échéant). Vérifiez ensuite la condition à nouveau jusqu'à ce qu'elle soitfalse。

Exemple

Exemple

const std = @import("std");

pub fn main() void {
    var i: i32 = 0;
    while (i < 5) : (i += 1) {
        std.debug.print("i: {}\n", .{i});
    }
}

Analyse :

  • Initialiser la variableià 0.
  • Tant queiest inférieur à 5, le corps de la boucle s'exécutera.
  • Après chaque itération de boucle,iest incrémenté de 1.

Le résultat d'exécution compilé est :

i: 0
i: 1
i: 2
i: 3
i: 4

2, forBoucle

Syntaxe

for (collection) |item, index| {
    // code block
}
  • collection: un tableau, une slice, ou une autre collection itérable.
  • item: l'élément courant de la collection à chaque itération.
  • index(facultatif): l'index de l'élément courant.

Description

forLa boucle est utilisée pour parcourir chaque élément d'une collection. À chaque itération, l'élément courant est affecté àitem, et le code dans le corps de la boucle est exécuté.

Exemple

Exemple

const std = @import("std");

pub fn main() void {
    const array = [5]i32{ 1, 2, 3, 4, 5 };
    var index: usize = 0; // La variable index doit avoir un type déclaré
    for (array) |item| {
        std.debug.print("indice : {}, élément : {}\n", .{ index, item });
        index += 1; // Mettre à jour l'index
    }
}

Analyse :

  • Définit un tableau contenant 5 entiers.
  • Utilisationforboucle pour parcourir chaque élément du tableau, en affectant la valeur de l'élément àitem, et l'index àindex。
  • Dans le corps de la boucle, afficher la valeur et l'index de chaque élément.

Le résultat d'exécution compilé est :

index: 0, item: 1
index: 1, item: 2
index: 2, item: 3
index: 3, item: 4
index: 4, item: 5

3, continueetbreak

Syntaxe

  • continue: ignore l'itération en cours et passe à la suivante.
  • break: termine la boucle.

Description

continueest utilisé pour ignorer le code restant dans l'itération en cours et démarrer immédiatement l'itération suivante.breakest utilisé pour terminer toute la boucle.

Exemple

Exemple

const std = @import("std");

pub fn main() void {
    var i: i32 = 0;
    while (i < 10) : (i += 1) {
        if (i == 5) {
            continue; // Ignorer l'itération où i vaut 5
        }
        if (i == 8) {
            break; // Terminer la boucle
        }
        std.debug.print("i: {}\n", .{i});
    }
}

Analyse :

  • QuandiLorsqu'il vaut 5,continuesaute cette itération.
  • QuandiLorsqu'il est égal à 8,breakmet fin à la boucle.

Le résultat d'exécution compilé est :

i: 0
i: 1
i: 2
i: 3
i: 4
i: 6
i: 7

5. Boucles imbriquées

Syntaxe

for (outer_collection) |outer_item| {
    for (inner_collection) |inner_item| {
        // code block
    }
}

Description

Une boucle contenant une autre boucle dans son corps est appelée boucle imbriquée. La boucle interne est exécutée à chaque itération de la boucle externe.

Exemple

Exemple

const std = @import("std");

pub fn main() void {
    // Déclare un tableau contenant trois chaînes de caractères
    const letters = [_][]const u8{ "A", "B", "C" };
    // Parcourir le tableau
    for (letters) |letter| {
        var count: i32 = 0; // Déclare un compteur
        // Utiliser une boucle while pour afficher chaque lettre et le compteur
        while (count < 3) : (count += 1) {
            std.debug.print("{s} - {}\n", .{ letter, count });
        }
    }
}

Analyse :

  • La boucle externeforparcourt le tableau de lettres.
  • La boucle internewhiles'exécute 3 fois, en imprimant la lettre et le compteur.

Le résultat d'exécution compilé est :

A - 0
A - 1
A - 2
B - 0
B - 1
B - 2
C - 0
C - 1
C - 2

6. Plus de boucles

Boucle infinie

Vous pouvez créer une boucle infinie à l'aide d'une boucle while, tant que la condition est toujours vraie :

Exemple

pub fn main() void {
    while (true) {
        // Bloc de code
        // Doit contenir un mécanisme de sortie, sinon le programme s'exécutera indéfiniment
    }
}

Boucle sur une plage

Zig permet également de boucler sur des plages, ce qui peut simplifier le code dans certains cas :

Exemple

pub fn main() void {
    for (0..10) |i| {
        std.debug.print("i: {}\n", .{i});
    }
}

Boucle étiquetée

Zig prend en charge les boucles étiquetées, vous permettant de nommer les boucles, ce qui est très utile dans les boucles imbriquées :

Exemple

pub fn main() void {
    loop: while (true) {
        while (true) {
            std.debug.print("À l'intérieur de la boucle imbriquée\n");
            break :loop; // Quitter la boucle externe
        }
    }
}
Autres extensions