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 datosEjemplo de tipo de datosDescripción
Tipos de enterosi8, i16, i32, i64, isizeTipo entero con signo,isizees un tamaño dependiente de la plataforma.
Entero sin signou8, u16, u32, u64, usizeTipo entero sin signo,usizees un tamaño dependiente de la plataforma.
Punto flotantef16, f32, f64, f128Tipo de número de punto flotante IEEE.
Tipo booleanoboolTipo booleano, cuyo valor estrueofalse。
Tipo caráctercharValor escalar Unicode.
Tipo compuestoarray, vectorArrays de tamaño fijo y arrays de tamaño variable.
Tipo puntero*T, *const T, *mut Tapuntando aTpuntero a un valor de tipo,*constde solo lectura,*mutmutable.
Tipo de referencia&T, &const T, &mut TSobreTreferencia 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?Tpuede sernulloTun valor de tipo.
Tipo de conjunto de erroreserror{...}Tipo enumerado que contiene valores de error.
Tipo de funciónfn(T1, T2, ...) -> RTipo de función que acepta parámetros y devuelve un resultado.
Tipo de estructurastruct { ... }Tipo de datos compuesto que contiene varios campos.
Tipo de enumeraciónenum { ... }Conjunto de un número fijo de valores con nombre.
Tipo de uniónunion { ... }Tipo que puede almacenar valores de diferentes tipos, pero solo uno a la vez.
Tipo aliasalias T = UTSí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

const std = @import("std");

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});
}
2. Tipos de punto flotante

Zig admite dos tipos de punto flotante: f32 y f64.

Ejemplo

const std = @import("std");

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

const std = @import("std");

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

const std = @import("std");

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

const std = @import("std");

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 std = @import("std");

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 std = @import("std");

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 std = @import("std");

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

const std = @import("std");

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.*});
}
Otras extensiones