Variables et constantes Zig

Dans le langage Zig, les variables sont des conteneurs pour stocker des données.

En Zig, la définition et l'utilisation des variables sont très intuitives et puissantes.

Cet article détaillera comment définir et utiliser les variables en Zig, y compris les constantes, les variables, l'inférence de type, la portée et d'autres aspects.

En Zig, les constantes sont définies à l'aide du mot-cléconst, tandis que les variables sont définies à l'aide du mot-clévar.


Variables

En Zig, les variables sont définies à l'aide du mot-clévar.

Le type des variables doit être explicitement spécifié lors de la définition, ou le compilateur peut déduire le type à partir de la valeur d'initialisation.

Déclaration de variable

En Zig, la déclaration de variable nécessite de spécifier un type. La syntaxe de déclaration de variable est la suivante :

var variable_name: type = value;

variable_nameest le nom de la variable,typeest le type,valueest la valeur de la variable.

Par exemple :

var x: i32 = 42; // 定义一个 i32 类型的变量 x,初始值为 42
var y = 10;      // 编译器推断 y 的类型为 comptime_int

La valeur d'une variable peut être modifiée pendant l'exécution du programme :

Exemple

const std = @import("std");

pub fn main() void {
    var b: i32 = 20; // Définir une variable entière b avec une valeur initiale de 20
    b = 30; // Modifier la valeur de la variable b
    std.debug.print("b: {}\n", .{b});
}

Caractéristiques des variables

1. Le type doit être explicite:

  • Zig est un langage fortement typé. Le type d'une variable doit être explicitement spécifié lors de la définition, ou inféré à partir de la valeur d'initialisation.

  • S'il n'y a pas de valeur d'initialisation, le type doit être explicitement spécifié.

Exemple

var x: i32 = 10; // Spécifier explicitement le type
var y = 20;      // Le compilateur infère le type comme comptime_int

2. Mutabilité:

  • Les variables définies à l'aide duvarmot-clé sont mutables, et leurs valeurs peuvent être modifiées dans le code ultérieur.

Exemple

var x: i32 = 10;
x = 20; // Modifier la valeur de x

3. Portée:

  • La portée d'une variable est la portée de bloc, ce qui signifie qu'elle est valide dans le bloc de code où elle est définie.

Exemple

{
    var x: i32 = 10;
    std.debug.print("x = {}\n", .{x}); // Sortie : x = 10
}
// Ici, x est hors de portée et n'est pas accessible

4. Variables non initialisées:

  • Zig n'autorise pas l'utilisation de variables non initialisées. Si une variable n'est pas initialisée, le compilateur signalera une erreur.

Exemple

var x: i32; // Erreur : la variable x n'est pas initialisée
x = 10;    // Doit d'abord être initialisée

Types de variables

Zig prend en charge plusieurs types de données, y compris, mais sans s'y limiter :

  • Types de base : entiers (i32, i64etc.), entiers non signés (u32, u64etc.), nombres à virgule flottante (f32, f64etc.), booléens (bool), caractères (char)。
  • Types composites : tableaux ([]T), structures (struct), énumérations (enum), unions (union), tuples ([]const T)。
  • Pointeurs et références : pointeurs (*T), références (&T), types optionnels (?T)。
  • Types de fonctions :fn(...) -> R。

Règles de nommage des variables

Le nommage des variables Zig suit quelques règles de base, notamment :

  • Les noms de variables doivent commencer par une lettre ou un trait de soulignement.

  • Les noms de variables peuvent contenir des lettres, des chiffres et des traits de soulignement.

  • Les noms de variables sont sensibles à la casse.

  • Les noms de variables ne peuvent pas être des mots-clés Zig (tels quevar、const、fnetc.).

Exemple

var my_var: i32 = 10; // Nom de variable valide
var _value: f64 = 3.14; // Nom de variable valide
var 1var: i32 = 10; // Nom de variable non valide

Inférence de type

Zig prend en charge l'inférence de type. Si une variable est initialisée lors de sa définition, le compilateur peut déduire le type de la variable à partir de la valeur initiale.

Exemple

var x = 10;      // Le compilateur déduit le type de x comme comptime_int
var y = 3.14;    // Le compilateur déduit le type de y comme comptime_float
var z = "Hello"; // Le compilateur déduit le type de z comme *const [5:0]u8

Portée

La portée d'une variable est déterminée par l'endroit où elle est définie.

En Zig, les variables peuvent être définies dans la portée globale, la portée locale et la portée de bloc.

Portée globale- Les variables globales sont accessibles n'importe où dans le programme.

Exemple

const std = @import("std");

const g: i32 = 90; // Constante globale

pub fn main() void {
    std.debug.print("g: {}\n", .{g});
}

Portée locale- Les variables locales ne sont accessibles qu'au sein de la fonction ou du bloc de code où elles sont définies.

Exemple

const std = @import("std");

pub fn main() void {
    var h: i32 = 100; // Variable locale
    {
        var i: i32 = 110; // Variable de portée de bloc
        std.debug.print("i: {}\n", .{i});
    }
    // std.debug.print("i: {}\n", .{i}); // Cette ligne de code provoquera une erreur de compilation car i n'est pas dans la portée de la fonction main
    std.debug.print("h: {}\n", .{h});
}

Conversion de type

Zig fournit des fonctions de conversion de type pour convertir un type en un autre.

Exemple

const std = @import("std");

pub fn main() void {
    const j: i32 = 120;
    const k: f64 = @intToFloat(f64, j); // Convertir l'entier j en nombre à virgule flottante k
    std.debug.print("j: {}, k: {}\n", .{j, k});
}

Valeurs par défaut

Les variables doivent être initialisées lors de leur définition, sinon cela provoquera une erreur de compilation.

Zig n'autorise pas l'utilisation de variables non initialisées.

Exemple

const std = @import("std");

pub fn main() void {
    var l: i32 = 0; // Initialiser la variable l
    std.debug.print("l: {}\n", .{l});
}

Exemples d'utilisation de variables

Ce qui suit est un programme Zig complet qui démontre la définition et l'utilisation de variables :

Exemple

const std = @import("std");

pub fn main() void {
    // Définir la variable
    var x: i32 = 10;
    var y = 20; // Type déduit comme comptime_int

    // Modifier la valeur de la variable
    x = 30;
    y = 40;

    // Afficher la valeur de la variable
    std.debug.print("x = {}\n", .{x}); // Sortie : x = 30
    std.debug.print("y = {}\n", .{y}); // Sortie : y = 40

    // Portée au niveau du bloc
    {
        var z: i32 = 50;
        std.debug.print("z = {}\n", .{z}); // Sortie : z = 50
    }
    // Ici, z est hors de portée et on ne peut pas y accéder
}

Constantes

En Zig, les constantes sont définies à l'aide du mot-cléconst.

Une fois qu'une constante est définie, sa valeur ne peut pas être modifiée.

Exemple

const std = @import("std");

pub fn main() void {
    const a: i32 = 10; // Définir une constante entière a avec une valeur de 10
    std.debug.print("a: {}\n", .{a});
}

Caractéristiques des constantes :

  • Immutabilité: La valeur d'une constante ne peut pas être modifiée après sa définition.

  • Déterminée à la compilation: La valeur d'une constante doit être déterminée à la compilation et ne peut pas être le résultat d'un calcul à l'exécution.

  • Inférence de type: Si le type d'une constante n'est pas explicitement spécifié, le compilateur déduira le type à partir de la valeur initiale.

  • Convention de nommage: Les constantes sont généralement nommées en utilisant des lettres majuscules et des tirets bas (commeMAX_SIZE) pour les distinguer des variables.


Constantes de compilation

Zig prend en charge les constantes de compilation (constantes comptime). Les valeurs de ces constantes sont calculées à la compilation et peuvent être utilisées pour la logique de compilation.

Définition des constantes de compilation

Utilisez le mot-clé comptime pour définir des constantes de compilation.

Syntaxe :

comptime const constant_name: type = value;

Par exemple :

comptime const MAX_SIZE: usize = 100; // 编译时常量

Caractéristiques

  • Calcul à la compilation :Les valeurs des constantes de compilation sont calculées à la compilation et peuvent être utilisées pour la logique de compilation (comme les tailles de tableaux, les calculs de types, etc.).
  • Sûreté de typage :Le type d'une constante de compilation doit être déterminé à la compilation.
  • Optimisation des performances :L'utilisation de constantes de compilation permet d'éviter les surcoûts de calcul à l'exécution.

Exemple

const std = @import("std");

pub fn main() void {
    comptime const SIZE: usize = 10; // Constante à la compilation
    var arr: [SIZE]i32 = undefined;  // Utiliser une constante à la compilation pour définir la taille du tableau
    std.debug.print("Array size = {}\n", .{SIZE}); // Sortie : Array size = 10
}

Différences entre les variables et les constantes

FonctionnalitéVariable (var)Constante (const)Constante à la compilation (comptime const)
MutabilitéMutableImmuableImmuable
Mot-clé de définitionvarconstcomptime const
Exigence d'initialisationDoit être initialiséeDoit être initialiséeDoit être initialisée
Inférence de typePris en chargePris en chargePris en charge
PortéePortée de blocPortée de blocPortée de bloc
Scénarios d'utilisationValeurs à modifierValeurs qui n'ont pas besoin de modificationValeurs calculées à la compilation

Exemple

const std = @import("std");

pub fn main() void {
    // variable
    var x: i32 = 10;
    x = 20;
    std.debug.print("x = {}\n", .{x}); // Sortie : x = 20

    // constante
    const PI: f64 = 3.14159;
    std.debug.print("PI = {}\n", .{PI}); // Sortie : PI = 3.14159

    // constante de compilation
    comptime const SIZE: usize = 5;
    var arr: [SIZE]i32 = undefined;
    std.debug.print("Array size = {}\n", .{SIZE}); // Sortie : Taille du tableau = 5
}
Autres extensions