@hasField em Zig
O @hasField verifica se um tipo (struct, union ou enum) possui um campo com o nome especificado. Retorna true ou false em tempo de compilação. É essencial para escrever código genérico robusto que precisa se adaptar a diferentes tipos sem causar erros de compilação.
Sintaxe
@hasField(comptime T: type, comptime nome: []const u8) bool
O que faz
O @hasField consulta a definição do tipo fornecido para verificar se ele contém um campo com o nome especificado. A verificação é realizada em tempo de compilação, sem nenhum custo em tempo de execução. Retorna true se o campo existir, false caso contrário.
Parâmetros
- T (
type, comptime): O tipo a ser inspecionado. Deve ser uma struct, union ou enum. - nome (
[]const u8, comptime): O nome do campo a ser verificado, como string.
Valor de retorno
Retorna bool (comptime) — true se o campo existir no tipo, false caso contrário.
Exemplos práticos
Exemplo 1: Verificação básica de campos
const std = @import("std");
const Pessoa = struct {
nome: []const u8,
idade: u32,
email: []const u8,
};
test "verificar existência de campos" {
try std.testing.expect(@hasField(Pessoa, "nome") == true);
try std.testing.expect(@hasField(Pessoa, "idade") == true);
try std.testing.expect(@hasField(Pessoa, "email") == true);
try std.testing.expect(@hasField(Pessoa, "telefone") == false);
try std.testing.expect(@hasField(Pessoa, "cpf") == false);
}
Exemplo 2: Mapeamento adaptativo entre tipos
const std = @import("std");
fn copiarCamposComuns(comptime Destino: type, comptime Origem: type, origem: Origem) Destino {
var resultado: Destino = undefined;
const campos_destino = @typeInfo(Destino).@"struct".fields;
inline for (campos_destino) |campo| {
if (@hasField(Origem, campo.name)) {
@field(resultado, campo.name) = @field(origem, campo.name);
} else {
// Usar valor padrão se disponível, ou zero
if (campo.default_value) |default_ptr| {
const ptr: *const campo.type = @ptrCast(@alignCast(default_ptr));
@field(resultado, campo.name) = ptr.*;
} else {
@field(resultado, campo.name) = std.mem.zeroes(campo.type);
}
}
}
return resultado;
}
const UsuarioDb = struct {
id: u64,
nome: []const u8,
email: []const u8,
hash_senha: []const u8,
};
const UsuarioDto = struct {
id: u64,
nome: []const u8,
email: []const u8,
// Sem hash_senha — dados sensíveis não são expostos
};
test "copiar campos comuns" {
const db = UsuarioDb{
.id = 1,
.nome = "João",
.email = "joao@ex.com",
.hash_senha = "abc123",
};
const dto = copiarCamposComuns(UsuarioDto, UsuarioDb, db);
try std.testing.expect(dto.id == 1);
try std.testing.expectEqualStrings("João", dto.nome);
try std.testing.expectEqualStrings("joao@ex.com", dto.email);
}
Exemplo 3: Interface baseada em duck typing
const std = @import("std");
fn tamanho(valor: anytype) usize {
const T = @TypeOf(valor);
// Verificar diferentes formas de obter o "tamanho"
if (@hasField(T, "len")) {
return @field(valor, "len");
} else if (@hasField(T, "count")) {
return @field(valor, "count");
} else if (@hasField(T, "tamanho")) {
return @field(valor, "tamanho");
} else {
@compileError("Tipo " ++ @typeName(T) ++ " não possui campo de tamanho");
}
}
test "duck typing para tamanho" {
const ComLen = struct { len: usize, dados: u32 };
const ComCount = struct { count: usize, tipo: u8 };
const a = ComLen{ .len = 10, .dados = 0 };
const b = ComCount{ .count = 5, .tipo = 1 };
try std.testing.expect(tamanho(a) == 10);
try std.testing.expect(tamanho(b) == 5);
}
Casos de uso comuns
- Mapeamento entre tipos: Copiar campos comuns entre structs de tipos diferentes (ex: DTO para modelo de banco).
- Duck typing em comptime: Verificar se um tipo implementa uma “interface” baseada na presença de campos.
- Código genérico adaptativo: Escrever funções que se adaptam a diferentes tipos sem exigir que todos tenham os mesmos campos.
- Deserialização tolerante: Ignorar campos do JSON/dados que não existem na struct de destino.
- Validação de schemas: Verificar que tipos de configuração possuem os campos obrigatórios.
Builtins relacionados
- @field — Acessa o campo após verificar sua existência
- @hasDecl — Verifica existência de declarações (funções, constantes)
- @typeInfo — Informações completas sobre o tipo
- @compileError — Gera erro quando campo obrigatório está ausente