Introducción a std.fmt.parseInt

En Zig, la función std.fmt.parseInt se encarga de convertir cadenas de texto en valores numéricos de tipos enteros. Esta utilidad es esencial cuando trabajas con entrada de usuarios, archivos de configuración o cualquier otra fuente de datos textual que contenga números.

Definición de la función

La firma de std.fmt.parseInt es la siguiente:

fn parseInt(comptime T: type, str: []const u8) !T

Donde:

• T es el tipo entero que deseamos obtener (por ejemplo, i32, u64).
• str es la cadena de texto que contiene el número a analizar.
• El retorno es un valor de tipo T o un error en caso de que la conversión falle.

Reglas de análisis de texto

La función interpreta el contenido de str según las siguientes reglas:

• El número se interpreta como decimal por defecto.
• Si la cadena empieza por 0x, 0X se interpreta como hexadecimal.
• Prefijos 0b o 0B indican binario.
• Prefijos 0o o 0O indican octal.
• Un signo + o - al principio se acepta.
• Los caracteres que no pertenecen a la base indicada provocan un error.

Errores comunes

La función puede devolver varios errores, entre los cuales se encuentran:

• ParseIntError.EmptyString – Cadena vacía.
• ParseIntError.InvalidCharacter – Caracter no válido para la base.
• ParseIntError.Overflow – El valor excede la capacidad del tipo T.
• ParseIntError.SignOverflow – El signo provoca desbordamiento.

Ejemplo 1: Parseando un número decimal simple

Este ejemplo muestra cómo convertir la cadena "12345" en un entero de 32 bits con signo.

// Importamos el módulo de formato de Zig
const std = @import("std");

// Punto de entrada del programa
pub fn main() !void {
    // La cadena que queremos convertir
    const str = "12345";

    // Usamos parseInt para convertir a i32
    // La función devuelve un Result: ok o error
    const result = std.fmt.parseInt(i32, str);

    // Comprobamos si la conversión fue exitosa
    if (result) |num| {
        // Si es ok, imprimimos el número
        std.debug.print("El número es {d}\\n", .{num});
    } else |err| {
        // En caso de error, lo mostramos
        std.debug.print("Error al parsear: {s}\\n", .{@errorName(err)});
    }
}

Comentario línea por línea:

1. const std = @import("std"); – Importamos el paquete estándar de Zig, que contiene fmt.
2. pub fn main() !void { – Declaramos la función principal con retorno de tipo error-set (!void).
3. const str = "12345"; – Definimos la cadena a analizar.
4. const result = std.fmt.parseInt(i32, str); – Llamamos a parseInt solicitando un i32.
5. if (result) |num| { – Desestructuramos el Result: si es ok, entramos con el valor num.
6. std.debug.print("El número es {d}\\n", .{num}); – Imprimimos el número.
7. } else |err| { – Si hubo error, entramos con err.
8. std.debug.print("Error al parsear: {s}\\n", .{@errorName(err)}); – Mostramos el mensaje del error.

Ejemplo 2: Parseando números con prefijos de base

Aquí mostramos cómo analizar un número hexadecimal, binario y octal.

const std = @import("std");

pub fn main() !void {

    // Cadena hexadecimal (0x)

    const hex = "0x1A3F";

    const hexVal = try std.fmt.parseInt(u16, hex);

    std.debug.print("Hexadecimal 0x1A3F a u16: {x}\\n", .{hexVal});
    // Cadena binaria (0b)

    const bin = "0b101010";

    const binVal = try std.fmt.parseInt(i8, bin);

    std.debug.print("Binario 0b101010 a i8: {d}\\n", .{binVal});
    // Cadena octal (0o)

    const oct = "0o755";

    const octVal = try std.fmt.parseInt(u
		


							

					Share via:
				
			
			


								
		


							


					
						
						 
					
						
							

							
																Facebook
									
						

											
					
									
							


					
						
						 
					
						
							

							
																X (Twitter)
									
						

											
					
									
							


					
						
						 
					
						
							

							
																LinkedIn
									
						

											
					
									
			
			
				

					
						
							

														
																			More