Variables y constantes en Zig

En el lenguaje Zig, las variables son contenedores para almacenar datos.

En Zig, la definición y el uso de variables es muy intuitivo y potente.

Este artículo explicará en detalle cómo definir y usar variables en Zig, incluyendo constantes, variables, inferencia de tipos, ámbito, etc.

En Zig, las constantes se definen usandoconstla palabra clave `const`, mientras que las variables se definen usandovarla palabra clave `var`.


Variables

En Zig, las variables se definen usandovarla palabra clave `var`.

Las variables deben tener un tipo especificado explícitamente en su definición, o permitir que el compilador infiera el tipo mediante el valor de inicialización.

Declaración de variables

En Zig, la declaración de variables requiere especificar el tipo. La sintaxis de declaración de variables es la siguiente:

var variable_name: type = value;

variable_name`variable` es el nombre de la variable,type`T` es el tipo,value`valor` es el valor de la variable.

Por ejemplo:

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

El valor de una variable se puede modificar durante la ejecución del programa:

Ejemplo

const std = @import("std");

pub fn main() void {
    var b: i32 = 20; // Define una variable entera b con valor inicial 20
    b = 30; // Modifica el valor de la variable b
    std.debug.print("b: {}\n", .{b});
}

Características de las variables

1. El tipo debe ser explícito:

  • Zig es un lenguaje de tipado fuerte; el tipo de una variable debe especificarse explícitamente en su definición o inferirse a partir del valor de inicialización.

  • Si no hay un valor de inicialización, se debe especificar explícitamente el tipo.

Ejemplo

var x: i32 = 10; // Especifica el tipo explícitamente
var y = 20;      // El compilador infiere el tipo como comptime_int

2. Mutabilidad:

  • Usandovarla palabra clave `var`, las variables definidas son mutables y su valor se puede modificar en el código posterior.

Ejemplo

var x: i32 = 10;
x = 20; // Modifica el valor de x

3. Ámbito:

  • El ámbito de una variable es el ámbito de bloque (block scope), es decir, es válida dentro del bloque de código donde se define.

Ejemplo

{
    var x: i32 = 10;
    std.debug.print("x = {}\n", .{x}); // Salida: x = 10
}
// Aquí x ya está fuera del ámbito y no se puede acceder a ella

4. Variables no inicializadas:

  • Zig no permite usar variables no inicializadas. Si una variable no está inicializada, el compilador mostrará un error.

Ejemplo

var x: i32; // Error: la variable x no está inicializada
x = 10;    // Debe inicializarse primero

Tipos de variables

Zig admite múltiples tipos de datos, incluyendo, entre otros:

  • Tipos básicos: enteros (i32, i64etc.), enteros sin signo (u32, u64etc.), números de coma flotante (f32, f64etc.), booleano (bool), carácter (char)。
  • Tipos compuestos: arreglos ([]T), estructuras (struct), enumeraciones (enum), uniones (union), tuplas ([]const T)。
  • Punteros y referencias: punteros (*T), referencias (&T), tipos opcionales (?T)。
  • Tipos de función:fn(...) -> R。

Reglas de nomenclatura de variables

La nomenclatura de variables en Zig sigue algunas reglas básicas, entre ellas:

  • El nombre de una variable debe comenzar con una letra o un guion bajo.

  • El nombre de una variable puede contener letras, números y guiones bajos.

  • Los nombres de variables distinguen entre mayúsculas y minúsculas.

  • El nombre de una variable no puede ser una palabra clave de Zig (comovar、const、fnetc.).

Ejemplo

var my_var: i32 = 10; // Nombres de variables válidos
var _value: f64 = 3.14; // Nombre de variable válido
var 1var: i32 = 10; // Nombre de variable inválido

Inferencia de tipos

Zig admite la inferencia de tipos. Si una variable se inicializa en su definición, el compilador puede inferir el tipo de la variable a partir del valor inicial.

Ejemplo

var x = 10;      // El compilador infiere el tipo de x como comptime_int
var y = 3.14;    // El compilador infiere el tipo de y como comptime_float
var z = "Hello"; // El compilador infiere el tipo de z como *const [5:0]u8

Ámbito (scope)

El ámbito de una variable está determinado por el lugar donde se define.

En Zig, las variables pueden definirse en el ámbito global, en el ámbito local y en el ámbito de bloque.

Ámbito global- Se puede acceder a las variables globales desde cualquier parte del programa.

Ejemplo

const std = @import("std");

const g: i32 = 90; // Constante global

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

Ámbito local- Las variables locales solo son accesibles dentro de la función o bloque de código donde se definen.

Ejemplo

const std = @import("std");

pub fn main() void {
    var h: i32 = 100; // Variable local
    {
        var i: i32 = 110; // Variable de ámbito de bloque
        std.debug.print("i: {}\n", .{i});
    }
    // std.debug.print("i: {}\n", .{i}); // Esta línea causará un error de compilación porque i no está en el ámbito de la función main
    std.debug.print("h: {}\n", .{h});
}

Conversión de tipos

Zig proporciona funciones de conversión de tipos para convertir un tipo en otro.

Ejemplo

const std = @import("std");

pub fn main() void {
    const j: i32 = 120;
    const k: f64 = @intToFloat(f64, j); // Convierte el entero j al número de coma flotante k
    std.debug.print("j: {}, k: {}\n", .{j, k});
}

Valores por defecto

Las variables deben inicializarse en su definición; de lo contrario, se producirá un error de compilación.

Zig no permite usar variables no inicializadas.

Ejemplo

const std = @import("std");

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

Ejemplo de uso de variables

A continuación se muestra un programa completo en Zig que demuestra la definición y el uso de variables:

Ejemplo

const std = @import("std");

pub fn main() void {
    // Define una variable
    var x: i32 = 10;
    var y = 20; // El tipo se infiere como comptime_int

    // Modifica el valor de la variable
    x = 30;
    y = 40;

    // Imprime el valor de la variable
    std.debug.print("x = {}\n", .{x}); // Salida: x = 30
    std.debug.print("y = {}\n", .{y}); // Salida: y = 40

    // Ámbito de bloque
    {
        var z: i32 = 50;
        std.debug.print("z = {}\n", .{z}); // Salida: z = 50
    }
    // Aquí z ya está fuera del ámbito y no se puede acceder a ella
}

Constantes

En Zig, las constantes se definen usandoconstla palabra clave `const`.

Una vez definida una constante, su valor no se puede modificar.

Ejemplo

const std = @import("std");

pub fn main() void {
    const a: i32 = 10; // Define una constante entera a con valor 10
    std.debug.print("a: {}\n", .{a});
}

Características de las constantes:

  • Inmutabilidad: el valor de una constante no se puede modificar después de su definición.

  • Determinada en tiempo de compilación: el valor de una constante debe determinarse en tiempo de compilación; no puede ser el resultado de un cálculo en tiempo de ejecución.

  • Inferencia de tipos: si el tipo de la constante no se especifica explícitamente, el compilador infiere el tipo a partir del valor inicial.

  • Convención de nomenclatura: la nomenclatura de las constantes suele usar letras mayúsculas y guiones bajos (por ejemplo,MAX_SIZE), para distinguirlas de las variables.


Constantes en tiempo de compilación

Zig admite constantes en tiempo de compilación (comptime constants). El valor de estas constantes se calcula en tiempo de compilación y puede usarse para lógica en tiempo de compilación.

Definición de constantes en tiempo de compilación

Utiliza la palabra clave `comptime` para definir constantes en tiempo de compilación.

Sintaxis:

comptime const constant_name: type = value;

Por ejemplo:

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

Características

  • Cálculo en tiempo de compilación:El valor de las constantes en tiempo de compilación se calcula durante la compilación y puede usarse para lógica en tiempo de compilación (como tamaño de arreglos, cálculo de tipos, etc.).
  • Seguridad de tipos:El tipo de las constantes en tiempo de compilación debe determinarse en tiempo de compilación.
  • Optimización del rendimiento:El uso de constantes en tiempo de compilación evita la sobrecarga de cálculo en tiempo de ejecución.

Ejemplo

const std = @import("std");

pub fn main() void {
    comptime const SIZE: usize = 10; // Constante en tiempo de compilación
    var arr: [SIZE]i32 = undefined;  // Usa una constante en tiempo de compilación para definir el tamaño del arreglo
    std.debug.print("Array size = {}\n", .{SIZE}); // Salida: Array size = 10
}

Diferencias entre variables y constantes

PropiedadVariable (`var`)var)Constante (`const`)const)Constante en tiempo de compilación (`comptime`)comptime const)
MutabilidadMutableInmutableInmutable
Palabra clave de definiciónvarconstcomptime const
Requisito de inicializaciónDebe inicializarseDebe inicializarseDebe inicializarse
Inferencia de tiposAdmiteAdmiteAdmite
ÁmbitoÁmbito de bloqueÁmbito de bloqueÁmbito de bloque
Casos de usoValores que necesitan modificaciónValores que no necesitan modificaciónValores calculados en tiempo de compilación

Ejemplo

const std = @import("std");

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

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

    // constante de tiempo de compilación
    comptime const SIZE: usize = 5;
    var arr: [SIZE]i32 = undefined;
    std.debug.print("Array size = {}\n", .{SIZE}); // salida: Array size = 5
}
Otras extensiones