Zig Tutorial für Anfänger: So installieren und verwenden Sie Zig

Zig ist eine moderne, universelle Programmiersprache, die robust, optimal und wartbar sein soll. Mit dem Fokus auf Einfachheit und Klarheit bietet Zig Low-Level-Kontrolle und vermeidet gleichzeitig versteckte Kontrollflüsse und Allokationen. Dieses Tutorial führt Sie durch den Installationsprozess, die Erstellung Ihres ersten Zig-Programms und das Ausführen von Tests. Am Ende haben Sie eine solide Grundlage, um diese leistungsstarke Sprache weiter zu erkunden.

Während wir leistungsstarke Entwickler-Tools erkunden, lohnt es sich, Apidog zu erwähnen – die ultimative Alternative zu Postman für die API-Entwicklung und -Tests. Apidog kombiniert API-Dokumentation, Design, Mock, Testing und Debugging in einer einzigen, optimierten Plattform.

Mit seiner intuitiven Benutzeroberfläche, den kollaborativen Funktionen und der nahtlosen Versionskontrollintegration verbessert Apidog die Workflow-Effizienz für Entwickler, die mit APIs arbeiten, drastisch. Sein umfassender Funktionsumfang umfasst automatisiertes Testen, Umgebungswaltung, Request-Chaining und intelligente Response-Validierung, was es zu einem unverzichtbaren Werkzeug für moderne Entwicklungsteams macht.

Bevor Sie sich in die Zig-Programmierung stürzen, sollten Sie Apidog zu Ihrem Entwickler-Toolkit hinzufügen, um Ihre Gesamtproduktivität bei der Arbeit mit APIs und Webdiensten zu steigern.

Part 1: Installing Zig

Bevor Sie mit der Programmierung in Zig beginnen können, müssen Sie den Compiler und die Tools installieren. Der Installationsprozess variiert je nach Betriebssystem.

Installing on Linux

Sie haben zwei Hauptoptionen für die Installation von Zig unter Linux:

Option 1: Using your distribution's package manager

Die meisten gängigen Linux-Distributionen packen die neueste Zig-Version. Dies ist oft der einfachste Ansatz:

# For Debian/Ubuntu
sudo apt install zig

# For Fedora
sudo dnf install zig

# For Arch Linux
sudo pacman -S zig

Option 2: Installing manually

Wenn Ihre Distribution kein Zig hat oder Sie eine bestimmte Version benötigen:

Laden Sie eine vorgefertigte Version von Zig von der offiziellen Website herunter, die zu Ihrer CPU-Architektur passt

Um Ihre Architektur zu überprüfen, verwenden Sie:

uname -m

Entpacken Sie das Archiv mit tar:

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

Fügen Sie die Zig-Binärdatei zu Ihrem PATH hinzu:

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

Übernehmen Sie die Änderungen:

source ~/.bashrc

Installing on Windows

Windows-Benutzer haben mehrere Optionen:

Option 1: Using package managers

# Using Chocolatey
choco install zig

# Using Winget
winget install zig.zig

# Using Scoop
scoop install zig

Option 2: Manual installation

Laden Sie eine vorgefertigte Version von Zig für Windows herunter, die zu Ihrer CPU-Architektur passt (die meisten Windows-Systeme verwenden x86_64/AMD64)

Überprüfen Sie Ihre Architektur mit:

$Env:PROCESSOR_ARCHITECTURE

Entpacken Sie die ZIP-Datei

Fügen Sie Zig zu Ihrem PATH hinzu:

For Current User:

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

For System Wide:

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

Schließen Sie Ihr Terminal und öffnen Sie es erneut

Installing on macOS

Der einfachste Weg, Zig unter macOS zu installieren, ist die Verwendung von Homebrew:

brew install zig

Verifying Your Installation

Überprüfen Sie nach der Installation, ob Zig korrekt installiert ist, indem Sie Folgendes ausführen:

zig version

Sie sollten eine Ausgabe wie diese sehen:

0.13.0

Part 2: Hello, World! in Zig

Nachdem Zig installiert ist, erstellen wir Ihr erstes Zig-Programm: das traditionelle "Hello, World!" Beispiel.

Creating the Program File

1. Erstellen Sie eine neue Datei mit dem Namen main.zig
2. Öffnen Sie sie in Ihrem bevorzugten Texteditor
3. Fügen Sie den folgenden Code hinzu:

const std = @import("std");

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

Lassen Sie uns aufschlüsseln, was dieser Code tut:

• const std = @import("std"); importiert die Standardbibliothek von Zig
• pub fn main() void { deklariert die Hauptfunktion, die als Einstiegspunkt Ihres Programms fungiert
• std.debug.print("Hello, {s}!\\\\n", .{"World"}); gibt "Hello, World!" auf den Standardfehlerstrom (stderr) aus
• Das {s} ist ein Formatbezeichner für Strings, und .{"World"} ist die Art und Weise, wie Zig Argumente an Formatbezeichner übergibt

Running the Program

Um Ihr Programm zu erstellen und auszuführen, verwenden Sie den folgenden Befehl:

zig run main.zig

Dadurch wird Ihr Code kompiliert und sofort ausgeführt. Sie sollten die Ausgabe sehen:

Hello, World!

Important Note on File Encoding

Zig benötigt UTF-8-Codierung für Quelldateien. Wenn ein Fehler wie invalid bytes auftritt, hat Ihre Datei möglicherweise eine andere Codierung. Um dies zu beheben:

zig fmt main.zig

Dadurch wird Ihre Datei als UTF-8 neu codiert. Öffnen Sie dann die Datei in Ihrem Editor erneut.

Part 3: Running Tests in Zig

Zig verfügt über ein integriertes Testframework, mit dem Sie Tests einfach schreiben und ausführen können. Das Verständnis der Verwendung von Tests ist entscheidend, wenn Sie Zig lernen, insbesondere da viele Beispiele in der Zig-Dokumentation als Tests bereitgestellt werden.

Creating a Simple Test That Passes

Erstellen wir eine einfache Testdatei:

1. Erstellen Sie eine neue Datei mit dem Namen test_pass.zig
2. Fügen Sie den folgenden Code hinzu:

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

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

Dieser Code importiert das Testmodul und definiert dann einen Test namens "always succeeds", der erwartet, dass true wahr ist (was er immer ist).

Um diesen Test auszuführen:

zig test test_pass.zig

Sie sollten eine ähnliche Ausgabe sehen:

All 1 tests passed.

Creating a Test That Fails

Erstellen wir nun einen Test, der fehlschlägt, um zu verstehen, wie Zig Testfehler behandelt:

1. Erstellen Sie eine Datei mit dem Namen test_fail.zig
2. Fügen Sie den folgenden Code hinzu:

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

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

Dieser Test erwartet, dass false wahr ist, was offensichtlich fehlschlägt.

Wenn Sie ausführen:

zig test test_fail.zig

Sie sehen eine Fehlerausgabe wie:

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.

Understanding Error Handling in Tests

Das Schlüsselwort try ist in Zig-Tests entscheidend. Es versucht, eine Funktion auszuführen, die einen Fehler zurückgeben kann. Wenn ein Fehler zurückgegeben wird, wird dieser Fehler an den Aufrufer weitergegeben.

Versuchen Sie, denselben Test ohne das Schlüsselwort try auszuführen:

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

Sie erhalten einen Compilerfehler, da Sie den potenziellen Fehler, den expect() zurückgeben könnte, nicht behandeln.

Part 4: Zig Basics for Beginners

Variables and Constants

In Zig definieren Sie Variablen und Konstanten wie folgt:

const std = @import("std");

pub fn main() void {
    // Constant (cannot be changed)
    const fixed_value = 42;

    // Variable (can be changed)
    var changeable_value = 10;
    changeable_value = 20; // This is allowed

    // You can specify types explicitly
    const explicit_integer: i32 = 1234;
    var explicit_float: f64 = 3.14159;

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

Basic Data Types

Zig hat mehrere integrierte Datentypen:

const std = @import("std");

pub fn main() void {
    // Integers
    const i: i32 = -42;       // Signed 32-bit integer
    const u: u32 = 42;        // Unsigned 32-bit integer

    // Floats
    const f: f32 = 3.14;      // 32-bit float
    const d: f64 = 2.71828;   // 64-bit float

    // Boolean
    const b: bool = true;

    // Characters and strings
    const c: u8 = 'A';                    // Character (as integer)
    const s: []const u8 = "Hello, Zig!";  // String (a slice of u8)

    // Arrays with fixed size known at compile time
    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});
}

Functions

Funktionen in Zig werden mit dem Schlüsselwort fn definiert:

const std = @import("std");

// Basic function with parameters and return value
fn add(a: i32, b: i32) i32 {
    return a + b;
}

// Function that may return an error
fn divide(a: f32, b: f32) !f32 {
    if (b == 0) {
        return error.DivisionByZero;
    }
    return a / b;
}

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

    // Call a function that may return an error
    if (divide(10, 2)) |result| {
        std.debug.print("10 / 2 = {d}\\\\n", .{result});
    } else |err| {
        std.debug.print("Error: {}\\\\n", .{err});
    }

    // Another way to handle errors
    const division_result = divide(10, 0) catch |err| {
        std.debug.print("Division failed: {}\\\\n", .{err});
        0; // Default value in case of error
    };
    std.debug.print("Result (or default): {d}\\\\n", .{division_result});
}

Conclusion

Dieses Tutorial hat die Grundlagen für den Einstieg in Zig behandelt – die Installation auf verschiedenen Betriebssystemen, das Erstellen und Ausführen Ihres ersten Programms und die Arbeit mit dem Testframework von Zig. Wir haben auch einige grundlegende Konzepte wie Variablen, Datentypen und Funktionen vorgestellt.

Zig ist eine leistungsstarke Sprache, die Low-Level-Kontrolle bietet und gleichzeitig Sicherheit, Klarheit und Wartbarkeit betont. Sein Ansatz zur Fehlerbehandlung und Speicherverwaltung macht es zu einer interessanten Alternative zu Sprachen wie C, C++ und Rust.

Um Ihre Zig-Reise fortzusetzen, sollten Sie Folgendes in Betracht ziehen:

• Erkunden Sie die offizielle Zig-Dokumentation
• Treten Sie der Zig-Community auf Discord oder im Ziggit-Forum bei
• Installieren Sie den Zig Language Server für eine bessere IDE-Integration
• Versuchen Sie, kleine Projekte zu erstellen, um praktische Erfahrungen zu sammeln

Denken Sie daran, dass sich Zig noch in der Entwicklung befindet, sodass sich einige Funktionen ändern können, wenn die Sprache auf Version 1.0 zusteuert. Viel Spaß beim Codieren!