Zig Tipos de datos
Zig admite múltiples tipos de datos, que incluyen enteros, números de punto flotante, valores booleanos, caracteres, arrays, slices, estructuras, enumeraciones, uniones y punteros, entre otros.
La siguiente tabla describe los distintos tipos de datos en Zig:
| Categoría de tipo de datos | Ejemplo de tipo de datos | Descripción |
|---|---|---|
| Tipos de enteros | i8, i16, i32, i64, isize | Tipo entero con signo,isizees un tamaño dependiente de la plataforma. |
| Entero sin signo | u8, u16, u32, u64, usize | Tipo entero sin signo,usizees un tamaño dependiente de la plataforma. |
| Punto flotante | f16, f32, f64, f128 | Tipo de número de punto flotante IEEE. |
| Tipo booleano | bool | Tipo booleano, cuyo valor estrueofalse。 |
| Tipo carácter | char | Valor escalar Unicode. |
| Tipo compuesto | array, vector | Arrays de tamaño fijo y arrays de tamaño variable. |
| Tipo puntero | *T, *const T, *mut T | apuntando aTpuntero a un valor de tipo,*constde solo lectura,*mutmutable. |
| Tipo de referencia | &T, &const T, &mut T | SobreTreferencia a un valor de tipo,&constde solo lectura,&mutmutable. |
| Tipo tupla | (T1, T2, ...) | Colección ordenada de valores con una cantidad y tipos fijos. |
| Tipo opcional | ?T | puede sernulloTun valor de tipo. |
| Tipo de conjunto de errores | error{...} | Tipo enumerado que contiene valores de error. |
| Tipo de función | fn(T1, T2, ...) -> R | Tipo de función que acepta parámetros y devuelve un resultado. |
| Tipo de estructura | struct { ... } | Tipo de datos compuesto que contiene varios campos. |
| Tipo de enumeración | enum { ... } | Conjunto de un número fijo de valores con nombre. |
| Tipo de unión | union { ... } | Tipo que puede almacenar valores de diferentes tipos, pero solo uno a la vez. |
| Tipo alias | alias T = U | TSíUalias de. |
1. Tipos de enteros
Zig ofrece varios tipos de enteros, incluidos enteros con signo y sin signo, con tamaños que van de 8 a 64 bits.
Ejemplo
pub fn main() void {
const a: i8 = -128; // 8-bit signed integer
const b: u8 = 255; // 8-bit unsigned integer
const c: i32 = -2147483648; // 32-bit signed integer
const d: u64 = 18446744073709551615; // 64-bit unsigned integer
std.debug.print("a: {}, b: {}, c: {}, d: {}\n", .{a, b, c, d});
}
Zig admite dos tipos de punto flotante: f32 y f64.
Ejemplo
pub fn main() void {
const pi: f32 = 3.14; // 32-bit floating point
const e: f64 = 2.71828; // 64-bit floating point
std.debug.print("pi: {}, e: {}\n", .{pi, e});
}
3. Tipo booleano
El tipo booleano se representa con bool y sus valores pueden ser true o false.
Ejemplo
pub fn main() void {
const is_true: bool = true;
const is_false: bool = false;
std.debug.print("is_true: {}, is_false: {}\n", .{is_true, is_false});
}
4. Tipo carácter
El tipo carácter utiliza u8 para representar un solo carácter.
Ejemplo
pub fn main() void {
const letter: u8 = 'A';
std.debug.print("letter: {}\n", .{letter});
}
5. Arrays y slices
Los arrays son de tamaño fijo, mientras que los slices son arrays de tamaño dinámico.
Ejemplo
pub fn main() void {
const array: [5]i32 = [5]i32{1, 2, 3, 4, 5}; // array de tamaño fijo
const slice: []const i32 = array[1..4]; // slice
std.debug.print("array: {}, slice: {}\n", .{array, slice});
}
6. Estructuras
Las estructuras se definen con struct, lo que te permite crear tipos de datos complejos.
Ejemplo
const Point = struct {
x: i32,
y: i32,
};
pub fn main() void {
const p = Point{ .x = 10, .y = 20 };
std.debug.print("Point: ({}, {})\n", .{p.x, p.y});
}
7. Enumeraciones
Las enumeraciones se definen con enum, lo que te permite crear tipos con valores con nombre.
Ejemplo
const Color = enum {
Red,
Green,
Blue,
};
pub fn main() void {
const color: Color = Color.Green;
std.debug.print("Color: {}\n", .{color});
}
8. Uniones
Las uniones se definen con union, lo que te permite crear una variable que puede almacenar valores de diferentes tipos.
Ejemplo
const Number = union(enum) {
Int: i32,
Float: f32,
};
pub fn main() void {
const num: Number = Number{ .Int = 10 };
switch (num) {
Number.Int => std.debug.print("Integer: {}\n", .{num.Int}),
Number.Float => std.debug.print("Float: {}\n", .{num.Float}),
}
}
9. Punteros
Los punteros se definen con*definición, pueden apuntar a variables de un tipo específico.
Ejemplo
pub fn main() void {
var a: i32 = 10;
const p: *i32 = &a; // puntero que apunta a a
std.debug.print("Value: {}, Pointer: {}\n", .{a, p.*});
}