Tutoriel Zig pour débutants : Comment installer et utiliser Zig

Zig est un langage de programmation moderne et polyvalent, conçu pour être robuste, optimal et maintenable. En mettant l'accent sur la simplicité et la clarté, Zig offre un contrôle de bas niveau tout en évitant les flux de contrôle et les allocations cachés. Ce tutoriel vous guidera à travers le processus d'installation, la création de votre premier programme Zig et l'exécution de tests. À la fin, vous aurez une base solide pour explorer plus en détail ce langage puissant.

Alors que nous explorons des outils de développement puissants, il convient de mentionner Apidog – l'alternative ultime à Postman pour le développement et les tests d'API. Apidog combine la documentation, la conception, la simulation, les tests et le débogage d'API en une seule plateforme rationalisée.

button

Grâce à son interface intuitive, ses fonctionnalités collaboratives et son intégration transparente du contrôle de version, Apidog améliore considérablement l'efficacité du flux de travail pour les développeurs travaillant avec des API. Son ensemble complet de fonctionnalités comprend des tests automatisés, la gestion des environnements, l'enchaînement des requêtes et la validation intelligente des réponses, ce qui en fait un outil essentiel pour les équipes de développement modernes.

button

Avant de vous lancer dans la programmation Zig, pensez à ajouter Apidog à votre boîte à outils de développeur pour améliorer votre productivité globale lorsque vous travaillez avec des API et des services web.

Partie 1 : Installation de Zig

Avant de pouvoir commencer à programmer en Zig, vous devez installer le compilateur et les outils. Le processus d'installation varie en fonction de votre système d'exploitation.

Installation sur Linux

Vous avez deux options principales pour installer Zig sur Linux :

Option 1 : Utilisation du gestionnaire de paquets de votre distribution

La plupart des principales distributions Linux empaquettent la dernière version de Zig. C'est souvent l'approche la plus simple :

# Pour Debian/Ubuntu
sudo apt install zig

# Pour Fedora
sudo dnf install zig

# Pour Arch Linux
sudo pacman -S zig

Option 2 : Installation manuelle

Si votre distribution n'a pas Zig ou si vous avez besoin d'une version spécifique :

Téléchargez une version pré-construite de Zig sur le site officiel qui correspond à votre architecture CPU

Pour vérifier votre architecture, utilisez :

uname -m

Extrayez l'archive à l'aide de tar :

tar xf zig-linux-x86_64-0.13.0.tar.xz

Ajoutez le binaire Zig à votre PATH :

echo 'export PATH="$HOME/zig-linux-x86_64-0.13.0:$PATH"' >> ~/.bashrc

Appliquez les modifications :

source ~/.bashrc

Installation sur Windows

Les utilisateurs de Windows ont plusieurs options :

Option 1 : Utilisation des gestionnaires de paquets

# Using Chocolatey
choco install zig

# Using Winget
winget install zig.zig

# Using Scoop
scoop install zig

Option 2 : Installation manuelle

Téléchargez une version pré-construite de Zig pour Windows qui correspond à votre architecture CPU (la plupart des systèmes Windows utilisent x86_64/AMD64)

Vérifiez votre architecture avec :

$Env:PROCESSOR_ARCHITECTURE

Extrayez le fichier ZIP

Ajoutez Zig à votre PATH :

Pour l'utilisateur actuel :

[Environment]::SetEnvironmentVariable(
    "Path",
    [Environment]::GetEnvironmentVariable("Path", "User") + ";C:\\\\path\\\\to\\\\zig-windows-x86_64",
    "User"
)

Pour l'ensemble du système :

[Environment]::SetEnvironmentVariable(
    "Path",
    [Environment]::GetEnvironmentVariable("Path", "Machine") + ";C:\\\\path\\\\to\\\\zig-windows-x86_64",
    "Machine"
)

Fermez et rouvrez votre terminal

Installation sur macOS

Le moyen le plus simple d'installer Zig sur macOS est d'utiliser Homebrew :

brew install zig

Vérification de votre installation

Après l'installation, vérifiez que Zig est correctement installé en exécutant :

zig version

Vous devriez voir une sortie comme :

0.13.0

Partie 2 : Hello, World ! en Zig

Maintenant que Zig est installé, créons votre premier programme Zig : l'exemple traditionnel « Hello, World ! ».

Création du fichier programme

Créez un nouveau fichier nommé main.zig
Ouvrez-le dans votre éditeur de texte préféré
Ajoutez le code suivant :

const std = @import("std");

pub fn main() void {
    std.debug.print("Hello, {s}!\\\\n", .{"World"});
}

Décomposons ce que fait ce code :

const std = @import("std"); importe la bibliothèque standard de Zig
pub fn main() void { déclare la fonction principale qui sert de point d'entrée de votre programme
std.debug.print("Hello, {s}!\\\\n", .{"World"}); affiche « Hello, World ! » dans le flux d'erreur standard (stderr)
Le {s} est un spécificateur de format pour les chaînes, et .{"World"} est la façon dont Zig passe les arguments aux spécificateurs de format

Exécution du programme

Pour construire et exécuter votre programme, utilisez la commande suivante :

zig run main.zig

Cela compile votre code et l'exécute immédiatement. Vous devriez voir la sortie :

Hello, World!

Remarque importante sur l'encodage des fichiers

Zig nécessite un encodage UTF-8 pour les fichiers sources. Si vous rencontrez une erreur telle que invalid bytes, votre fichier peut avoir un encodage différent. Pour corriger cela :

zig fmt main.zig

Cela ré-encodera votre fichier en UTF-8. Ensuite, rouvrez le fichier dans votre éditeur.

Partie 3 : Exécution de tests en Zig

Zig dispose d'un framework de test intégré qui facilite l'écriture et l'exécution de tests. Comprendre comment utiliser les tests est crucial lorsque vous apprenez Zig, d'autant plus que de nombreux exemples dans la documentation Zig sont fournis sous forme de tests.

Création d'un test simple qui réussit

Créons un fichier de test de base :

Créez un nouveau fichier nommé test_pass.zig
Ajoutez le code suivant :

const std = @import("std");
const expect = std.testing.expect;

test "always succeeds" {
    try expect(true);
}

Ce code importe le module de test, puis définit un test nommé « always succeeds » qui attend que true soit vrai (ce qui est toujours le cas).

Pour exécuter ce test :

zig test test_pass.zig

Vous devriez voir une sortie similaire à :

All 1 tests passed.

Création d'un test qui échoue

Maintenant, créons un test qui échoue pour comprendre comment Zig gère les échecs de test :

Créez un fichier nommé test_fail.zig
Ajoutez le code suivant :

const std = @import("std");
const expect = std.testing.expect;

test "always fails" {
    try expect(false);
}

Ce test attend que false soit vrai, ce qui échoue évidemment.

Lorsque vous exécutez :

zig test test_fail.zig

Vous verrez une sortie d'erreur comme :

Test [1/1] test.always fails... FAIL (TestUnexpectedResult)
/usr/lib/zig/std/testing.zig:515:14: 0x2241ef in expect (test)
if (!ok) return error.TestUnexpectedResult;
^
[...]/test_fail:5:5: 0x224305 in test.always fails (test)
try expect(false);
^
0 passed; 0 skipped; 1 failed.

Comprendre la gestion des erreurs dans les tests

Le mot-clé try est crucial dans les tests Zig. Il tente d'exécuter une fonction qui peut renvoyer une erreur. Si une erreur est renvoyée, elle propage cette erreur à l'appelant.

Essayez d'exécuter le même test sans le mot-clé try :

test "will not compile correctly" {
    expect(false);
}

Vous obtiendrez une erreur du compilateur car vous ne gérez pas l'erreur potentielle que expect() pourrait renvoyer.

Partie 4 : Notions de base de Zig pour les débutants

Variables et constantes

En Zig, vous définissez les variables et les constantes comme suit :

const std = @import("std");

pub fn main() void {
    // Constante (ne peut pas être modifiée)
    const fixed_value = 42;

    // Variable (peut être modifiée)
    var changeable_value = 10;
    changeable_value = 20; // Ceci est autorisé

    // Vous pouvez spécifier les types explicitement
    const explicit_integer: i32 = 1234;
    var explicit_float: f64 = 3.14159;

    std.debug.print("Fixed: {d}, Changeable: {d}\\\\n",
        .{fixed_value, changeable_value});
}

Types de données de base

Zig possède plusieurs types de données intégrés :

const std = @import("std");

pub fn main() void {
    // Entiers
    const i: i32 = -42;       // Entier signé 32 bits
    const u: u32 = 42;        // Entier non signé 32 bits

    // Flottants
    const f: f32 = 3.14;      // Flottant 32 bits
    const d: f64 = 2.71828;   // Flottant 64 bits

    // Booléen
    const b: bool = true;

    // Caractères et chaînes
    const c: u8 = 'A';                    // Caractère (en tant qu'entier)
    const s: []const u8 = "Hello, Zig!";  // Chaîne (une tranche de u8)

    // Tableaux de taille fixe connue au moment de la compilation
    const arr = [5]u8{1, 2, 3, 4, 5};

    std.debug.print("Integer: {d}, Float: {d}\\\\n", .{i, f});
    std.debug.print("String: {s}\\\\n", .{s});
}

Fonctions

Les fonctions en Zig sont définies à l'aide du mot-clé fn :

const std = @import("std");

// Fonction de base avec paramètres et valeur de retour
fn add(a: i32, b: i32) i32 {
    return a + b;
}

// Fonction qui peut renvoyer une erreur
fn divide(a: f32, b: f32) !f32 {
    if (b == 0) {
        return error.DivisionByZero;
    }
    return a / b;
}

pub fn main() void {
    // Appeler une fonction simple
    const sum = add(5, 3);
    std.debug.print("5 + 3 = {d}\\\\n", .{sum});

    // Appeler une fonction qui peut renvoyer une erreur
    if (divide(10, 2)) |result| {
        std.debug.print("10 / 2 = {d}\\\\n", .{result});
    } else |err| {
        std.debug.print("Error: {}\\\\n", .{err});
    }

    // Une autre façon de gérer les erreurs
    const division_result = divide(10, 0) catch |err| {
        std.debug.print("Division failed: {}\\\\n", .{err});
        0; // Valeur par défaut en cas d'erreur
    };
    std.debug.print("Result (or default): {d}\\\\n", .{division_result});
}

Conclusion

Ce tutoriel a couvert l'essentiel pour démarrer avec Zig - l'installation sur différents systèmes d'exploitation, la création et l'exécution de votre premier programme et l'utilisation du framework de test de Zig. Nous avons également présenté des concepts fondamentaux tels que les variables, les types de données et les fonctions.

Zig est un langage puissant qui offre un contrôle de bas niveau tout en mettant l'accent sur la sécurité, la clarté et la maintenabilité. Son approche de la gestion des erreurs et de la gestion de la mémoire en fait une alternative intéressante aux langages comme C, C++ et Rust.

Pour poursuivre votre parcours Zig, pensez à :

Explorer la documentation officielle de Zig
Rejoindre la communauté Zig sur Discord ou le forum Ziggit
Installer le Zig Language Server pour une meilleure intégration IDE
Essayer de créer de petits projets pour acquérir une expérience pratique

N'oubliez pas que Zig est toujours en évolution, donc certaines fonctionnalités peuvent changer à mesure que le langage arrive à la version 1.0. Bon codage !