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
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 y = 20; // El compilador infiere el tipo como comptime_int
2. Mutabilidad:
-
Usando
varla palabra clave `var`, las variables definidas son mutables y su valor se puede modificar en el código posterior.
Ejemplo
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
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 (como
var、const、fnetc.).
Ejemplo
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 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 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
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
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
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
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
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
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
| Propiedad | Variable (`var`)var) | Constante (`const`)const) | Constante en tiempo de compilación (`comptime`)comptime const) |
|---|---|---|---|
| Mutabilidad | Mutable | Inmutable | Inmutable |
| Palabra clave de definición | var | const | comptime const |
| Requisito de inicialización | Debe inicializarse | Debe inicializarse | Debe inicializarse |
| Inferencia de tipos | Admite | Admite | Admite |
| Ámbito | Ámbito de bloque | Ámbito de bloque | Ámbito de bloque |
| Casos de uso | Valores que necesitan modificación | Valores que no necesitan modificación | Valores calculados en tiempo de compilación |
Ejemplo
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
}