Apprenez à coder un jeu simple en Zig

Écrire la même application dans plusieurs langues est un excellent moyen d’apprendre de nouvelles façons de programmer. La plupart des langages de programmation ont certaines choses en commun, telles que :

• variables
• Expressions
• Déclarations

Ces concepts sont à la base de la plupart des langages de programmation. Une fois que vous les comprenez, vous pouvez prendre le temps dont vous avez besoin pour comprendre le reste.

De plus, les langages de programmation partagent généralement certaines similitudes. Une fois que vous connaissez un langage de programmation, vous pouvez apprendre les bases d’un autre en reconnaissant ses différences.

Un bon outil pour apprendre une nouvelle langue est de pratiquer avec un programme standard.
Cela vous permet de vous concentrer sur le langage, pas sur la logique du programme. Je le fais dans cette série d’articles en utilisant un programme “deviner le nombre”, dans lequel l’ordinateur choisit un nombre entre 1 et 100 et vous demande de le deviner. Le programme boucle jusqu’à ce que vous deviniez correctement le nombre.

Ce programme exerce plusieurs concepts dans les langages de programmation :

• variables
• Contribution
• Sortir
• Évaluation conditionnelle
• Boucles

C’est une excellente expérience pratique pour apprendre un nouveau langage de programmation.

Devinez le nombre en Zig basic

Zig est encore au stade alpha, et sujet à changement. Cet article est correct à partir de la version zig 0.11. Installer zig en allant au téléchargements répertoire et en téléchargeant la version appropriée pour votre système d’exploitation et votre architecture :

const std = @import("std");

fn ask_user() !i64 {
    const stdin = std.io.getStdIn().reader();
    const stdout = std.io.getStdOut().writer();

    var buf: [10]u8 = undefined;

    try stdout.print("Guess a number between 1 and 100: ", .{});

    if (try stdin.readUntilDelimiterOrEof(buf[0..], '\n')) |user_input| {
        return std.fmt.parseInt(i64, user_input, 10);
    } else {
        return error.InvalidParam;
    }
}

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    var prng = std.rand.DefaultPrng.init(blk: {
        var seed: u64 = undefined;
        try std.os.getrandom(std.mem.asBytes(&seed));
        break :blk seed;
    });
    const value = prng.random().intRangeAtMost(i64, 1, 100);
    while (true) {
        const guess = try ask_user();
        if (guess == value) {
            break;
        }
        const message =
            if (guess < value)
            "low"
        else
            "high";
        try stdout.print("Too {s}\n", .{message});
    }
    try stdout.print("That's right\n", .{});
}

La première ligne const std = @import("std"); importe le Zig bibliothèque standard.
Presque tous les programmes en auront besoin.

La fonction ask_user dans Zig

La fonction ask_user() renvoie un entier 64 bits ou alors une erreur. C’est ce que le ! (point d’exclamation) notes. Cela signifie que s’il y a un problème d’E/S ou si l’utilisateur saisit une entrée non valide, la fonction renvoie une erreur.

Les try L’opérateur appelle une fonction et renvoie sa valeur. S’il renvoie une erreur, il revient immédiatement du appel fonction avec une erreur. Cela permet une propagation explicite, mais facile, des erreurs. Les deux premières lignes de ask_user alias contient des constantes de std.
Cela simplifie le code d’E/S suivant.

Cette ligne imprime l’invite :

try stdout.print("Guess a number between 1 and 100: ", .{});

Il renvoie automatiquement un échec si l’impression échoue (par exemple, écriture sur un terminal fermé).

Cette ligne définit le tampon dans lequel l’entrée utilisateur est lue :

var buf: [10]u8 = undefined;

L’expression à l’intérieur de la clause if lit l’entrée de l’utilisateur dans le tampon :

(try stdin.readUntilDelimiterOrEof(buf[0..], '\n')) |user_input|

L’expression renvoie la tranche du tampon qui a été lue. Celle-ci est affectée à la variable user_inputqui n’est valable qu’à l’intérieur du if bloc.

La fonction std.fmt.parseInt renvoie une erreur si le nombre ne peut pas être analysé.
Cette erreur est propagée à l’appelant. Si aucun octet n’a été lu, la fonction renvoie immédiatement une erreur.

La fonction principale

La fonction commence par obtenir un nombre aléatoire. Il utilise std.rand.DefaultPrng.

La fonction initialise le générateur de nombres aléatoires avec std.os.getrandom. Il utilise ensuite le générateur pour obtenir un nombre dans la plage de 1 pour 100.

Les while la boucle continue pendant que true est vrai, c’est-à-dire pour toujours. La seule issue est avec le breakce qui se produit lorsque l’estimation est égale à la valeur aléatoire.

Quand le guess n’est pas égal, le if l’instruction renvoie la chaîne low ou alors high en fonction de la supposition. Ceci est interpolé dans le message à l’utilisateur.

Noter que main est défini comme !void, ce qui signifie qu’il peut également renvoyer une erreur. Cela permet d’utiliser le try opérateur à l’intérieur main.

Exemple de sortie

Un exemple d’exécution, après avoir mis le programme dans main.zig:

$ zig run main.zig 
Guess a number between 1 and 100: 50
Too high
Guess a number between 1 and 100: 25
Too low
Guess a number between 1 and 100: 37
Too low
Guess a number between 1 and 100: 42
Too high
Guess a number between 1 and 100: 40
That's right

Résumé

Ce jeu “devinez le nombre” est un excellent programme d’introduction pour apprendre un nouveau langage de programmation car il exerce plusieurs concepts de programmation courants d’une manière assez simple. En implémentant ce jeu simple dans différents langages de programmation, vous pouvez démontrer certains concepts de base des langages et comparer leurs détails.

Avez-vous un langage de programmation préféré ? Comment écririez-vous le jeu “devinez le nombre” ? Suivez cette série d’articles pour voir des exemples d’autres langages de programmation qui pourraient vous intéresser !