Zig-Grundsyntax

Zig ist eine neue Programmiersprache, einfach und effizient im Design und direkt kompatibel mit der C-Sprache.

Im Folgenden finden Sie eine Einführung in einige grundlegende Zig-Syntax, um Ihnen einen schnellen Einstieg zu ermöglichen.

Die Dateiendung für Zig-Codedateien ist.zig。

---

Erstes Zig-Programm

Werfen wir zunächst einen Blick auf Zigs "Hello, World!"-Programm.

Initialisieren wir zunächst ein Zig-Projekt:

mkdir hello-world
cd hello-world
zig init

Erstellen Sie dann die Datei hello.zig in diesem Projekt mit dem folgenden Code:

Codeanalyse:

1. Die Standardbibliothek importieren:

const std = @import("std");

Diese Codezeile importiert Zigs Standardbibliothek, ähnlich wie in der Sprache C.#include <stdio.h>。

2. Die main-Funktion definieren:

pub fn main() !void

pubDas Schlüsselwort gibt an, dass diese Funktion öffentlich ist,fnDas Schlüsselwort wird verwendet, um eine Funktion zu definieren,mainist der Einstiegspunkt der Funktion. Der Rückgabetyp!voidgibt an, dass die Funktion keinen Wert zurückgibt, aber einen Fehler zurückgeben kann (!Präfix gibt einen Error-Union-Typ an).

3. Standardausgabe abrufen:

const stdout = std.io.getStdOut().writer();

Rufen Sie den Standardausgabe-Writer über die Standardbibliothek ab und rufen Sie dann seine Methoden auf, um Inhalte zu schreiben.

4. Geben Sie "Hello, World!" aus:

try stdout.print("Hello, World!\n", .{});

printDie Methode schreibt die formatierte Zeichenkette auf die Standardausgabe,.{}ist eine leere Parameterliste.tryDas Schlüsselwort reicht bei einem Fehler Fehler nach oben an den Aufrufer weiter.

Dieses Programm demonstriert einige grundlegende Merkmale der Sprache Zig, wie Funktionsdefinition, Verwendung der Standardbibliothek und Fehlerbehandlung.

Wenn Sie nur eine einzelne Datei ausführen möchten, können Sie direkt Folgendes verwenden:

zig run hello.zig

Wenn Sie es in eine ausführbare Datei kompilieren möchten, verwenden Sie:

zig build-exe hello.zig

Führen Sie es nach der Kompilierung im Terminal aus:

./hello

Dies gibt aus:

Hello, World!

Bezeichner

In Zig sind Bezeichner Namen, die verwendet werden, um Variablen, Funktionen, Typen usw. zu benennen.

Hier sind einige Regeln und Merkmale bezüglich Zig-Bezeichnern:

1. Buchstaben und Ziffern: Bezeichner können Buchstaben (A-Z und a-z), Ziffern (0-9) und Unterstriche (_) enthalten.

2. Startzeichen: Bezeichner müssen mit einem Buchstaben oder Unterstrich beginnen und dürfen nicht mit einer Ziffer beginnen.

3. Groß-/Kleinschreibung: Zig ist eine Sprache, bei der Groß- und Kleinschreibung unterschieden wird, was bedeutetVariableundvariablesind zwei verschiedene Bezeichner.

4. Schlüsselwörter und reservierte Wörter: Einige bestimmte Wörter sind in Zig reserviert und können nicht als Bezeichner verwendet werden. Zum Beispielfn(Funktion),struct(struct),if(bedingte Anweisung), usw.

5. Namenskonventionen: Zig empfiehlt offiziell die folgenden Konventionen:

   • camelCase: Wird für Variablennamen und Funktionsnamen verwendet. Zum BeispielmyVariable、calculateSum。
   • PascalCase: Wird für Typnamen und Namensräume verwendet. Zum BeispielPoint、ArrayList。
   • SCREAMING_SNAKE_CASE: Wird für Konstanten verwendet, die zur Kompilierzeit bekannt sind (comptime-Konstanten). Zum BeispielMAX_SIZE。

6. Optionaler Typ: Zig hat einen speziellen Typ?T, der einen optionalen Wert vom TypT. Dies ist sehr nützlich im Umgang mit Werten, die null sein können.

7. Kompilierzeitkonstanten: Die Verwendung descomptime-Schlüsselworts vor einem Bezeichner zeigt an, dass der Bezeichner eine Kompilierzeitkonstante ist.

8. Fehlertypen: Die Verwendung deserror-Schlüsselworts definiert Fehlertypen, zum Beispiel:

   pub fn openFile(path: []const u8) !void {
       // ...
   }

9. Typ-Suffix: Das Anhängen des_t-Suffixes an Typnamen ist eine C-Sprachgewohnheit; in Zig können Sie dasselbe tun, aber es ist nicht erforderlich.

Reservierte Schlüsselwörter

Die folgenden sind einige reservierte Schlüsselwörter in Zig:

Schlüsselwörter	Beschreibung
align	Gibt die Anzahl der Ausrichtungsbytes für eine Variable oder einen Typ an
allowzero	Ermöglicht Zeigern, auf null zu zeigen
and	Logische AND-Operation
asm	Inline-Assembly-Block
break	Aus der nächstgelegenen Schleife oder dem nächstgelegenen Gültigkeitsbereich ausbrechen
callconv	Aufrufkonvention
const	Definiert eine Konstante
continue	Mit der nächsten Schleifeniteration fortfahren
defer	Verzögert die Ausführung einer Anweisung bis zum Verlassen des Gültigkeitsbereichs
else	Der negative Zweig einer bedingten Anweisung
enum	Enum-Typ
errdefer	Anweisung zur verzögerten Ausführung, wenn ein Fehler auftritt
error	Fehlertypdefinition
export	Symbole für die Verwendung durch C usw. exportieren
fn	Funktionsdefinition
for	Durchlaufschleife
if	Bedingte Anweisung
inline	Inline-Funktion oder Inline-Schleife
linksection	Gibt den Linker-Abschnitt an
noalias	Zeiger darf nicht durch andere Zeiger aliast werden
noinline	Verhindert Funktions-Inlining
null	Nullwert für optionale Typen
or	Logische OR-Operation
packed	Entfernt Struct-Padding, bitweise dicht gepackt
pub	Öffentliche Zugriffsebene
return	Rückgabe aus einer Funktion
struct	Struct-Typdefinition
switch	Mehrzweig-Auswahlanweisung
test	Test-Codeblock
threadlocal	Thread-lokale Variable
try	Versucht, einen Ausdruck auszuführen, und leitet Fehler bei Fehlschlag nach oben weiter
union	Definition eines Union-Typs
usingnamespace	Alle öffentlichen Mitglieder eines Namespace in den aktuellen Gültigkeitsbereich bringen
var	Eine veränderliche Variable definieren
void	Kein Typ, wird oft verwendet, wenn eine Funktion keinen Rückgabewert hat
while	Schleifenanweisung

Grundlegende Syntax

1. Variablen und Konstanten

In Zig verwenden Variablen dasvarSchlüsselwort zur Definition, Konstanten verwenden dasconstSchlüsselwort zur Definition.

const x: i32 = 10;  // 定义一个整数常量 x，值为 10
var y: f64 = 3.14;  // 定义一个浮点数变量 y，值为 3.14

2. Funktionen

Funktionen verwenden dasfnSchlüsselwort zur Definition und geben einen Rückgabetyp an.

const std = @import("std");

fn add(a: i32, b: i32) i32 {
    return a + b;
}

pub fn main() !void {
    const result = add(3, 4);
    const stdout = std.io.getStdOut().writer();
    try stdout.print("Result: {}\n", .{result});
}

3. Bedingte Anweisungen

Verwenden Sieifundelseum bedingte Logik zu implementieren.

const std = @import("std");

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    const number = 10;
    if (number > 0) {
        try stdout.print("Number is positive\n", .{});
    } else {
        try stdout.print("Number is not positive\n", .{});
    }
}

4. Schleifen

Zig unterstütztwhileundforSchleifen.

const std = @import("std");

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();

    // while 循环，: (i += 1) 是每次迭代后执行的更新表达式
    var i: i32 = 0;
    while (i < 5) : (i += 1) {
        try stdout.print("i: {}\n", .{i});
    }

    // for 循环，遍历数组
    const array = [5]i32{ 1, 2, 3, 4, 5 };
    for (array) |item| {
        try stdout.print("item: {}\n", .{item});
    }
}

5. Strukturen

Zig verwendetstructum Strukturen zu definieren.

const std = @import("std");

const Point = struct {
    x: i32,
    y: i32,
};

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    const p = Point{ .x = 10, .y = 20 };
    try stdout.print("Point: ({}, {})\n", .{ p.x, p.y });
}

6. Fehlerbehandlung

Zig verwendet Fehler-Enum-Typen und dastry / catchSchlüsselwort für die Fehlerbehandlung.

const std = @import("std");

const FileError = error{
    FileNotFound,
};

fn readFile(path: []const u8) !void {
    // 模拟一个可能失败的操作
    if (std.mem.eql(u8, path, "invalid")) {
        return FileError.FileNotFound;
    }
    // 其他操作...
}

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();

    readFile("invalid") catch |err| {
        switch (err) {
            FileError.FileNotFound => {
                try stdout.print("Error: File not found\n", .{});
            },
            else => return err,
        }
        return;
    };

    try stdout.print("File read successfully\n", .{});
}

Codeanalyse:

• catch |err|: Den Fehler abfangen und an eine Variable bindenerr。
• switch (err): Den Fehlertyp abgleichen und verschiedene Fehlerfälle getrennt behandeln.
• else => return err: Unerwartete Fehler direkt nach oben weitergeben, ohne sie stillschweigend zu ignorieren.
• WennreadFilewird erfolgreich ausgeführt (ohne catch auszulösen), dann wird die nachfolgende print-Anweisung weiter ausgeführt.

Andere Erweiterungen