Validador Regex de Endereço MAC em Go

Um endereço MAC (Media Access Control) é um identificador único usado para rotular dispositivos em uma rede. Validar esses endereços é fundamental em sistemas que rastreiam, autorizam ou se comunicam com componentes de hardware. O Validador Regex de Endereço MAC em Go do Qodex ajuda desenvolvedores e testadores a confirmar rapidamente se uma string segue a formatação MAC válida usando o pacote regexp do Go.

O que é um regex de endereço MAC?

Em Go, você pode usar expressões regulares para corresponder padrões de endereço MAC. Um endereço MAC típico tem a seguinte aparência:

01:23:45:67:89:AB
ou
01-23-45-67-89-AB

Endereços MAC são compostos por seis grupos de dois dígitos hexadecimais separados por dois-pontos ou hífens. O regex deve garantir esse formato sem permitir caracteres extras ou segmentos ausentes.

Padrão Regex para Endereços MAC

Aqui está o regex Go recomendado para corresponder endereços MAC padrão:

^([0-9a-fA-F]{2}[:-]){5}[0-9a-fA-F]{2}$

O que significa:

• ^ - Início da string

• ([0-9a-fA-F]{2}[:-]){5} - Cinco pares de dígitos hex seguidos de : ou -

• [0-9a-fA-F]{2} - Par final sem separador

• $ - Fim da string

Isso garante que a string tenha exatamente 6 pares e use separadores consistentes.

Considerações de desempenho

Ao usar uma expressão regular para validar um endereço MAC em Go, o processo é geralmente bastante eficiente. O mecanismo de regex examina cada caractere da string de entrada exatamente uma vez, resultando em uma complexidade de tempo O(N), onde N é o comprimento da string do endereço MAC sendo verificado.

O uso de memória é mínimo. A expressão regular requer apenas uma quantidade constante de espaço adicional para realizar a correspondência (espaço auxiliar O(1)), independente do tamanho da entrada. Isso torna a validação de endereço MAC baseada em regex rápida e leve, mesmo ao lidar com múltiplas entradas ou integrar verificações em fluxos de trabalho de API.

Como funciona

1. Insira ou cole seu regex (ou use o padrão).

2. Digite um endereço MAC de teste.

3. Veja instantaneamente se ele corresponde ou falha.

4. Ajuste seu padrão conforme necessário e valide novamente.

Exemplo: Validador básico

Use o Testador Regex Go para experimentar variações.

package main
import (
"fmt"
"regexp"
)
func isValidMAC(mac string) bool {
pattern := ^([0-9a-fA-F]{2}[:-]){5}[0-9a-fA-F]{2}$
macRegex := regexp.MustCompile(pattern)
return macRegex.MatchString(mac)
}
func main() {
fmt.Println(isValidMAC("00:1A:2B:3C:4D:5E"))  // true
fmt.Println(isValidMAC("00-1A-2B-3C-4D-5E"))  // true
fmt.Println(isValidMAC("001A.2B3C.4D5E"))     // false
fmt.Println(isValidMAC("01-23-45-67-89-AH"))    // false
fmt.Println(isValidMAC("01-23-45-67-AH"))       // false
}

Entrada: "00-1A-2B-3C-4D-5E"
Saída: true
Explicação: Esta string corresponde ao formato esperado de endereço MAC com seis grupos de dois dígitos hexadecimais separados por hífens.

Entrada: "00:1A:2B:3C:4D:5E"
Saída: true
Explicação: Dois-pontos também são separadores válidos, portanto este formato é aceito.

Entrada: "001A.2B3C.4D5E"
Saída: false
Explicação: Pontos não são separadores válidos neste padrão, portanto não é reconhecido como endereço MAC válido.

Entrada: "01-23-45-67-89-AH"
Saída: false
Explicação: 'H' não é um dígito hexadecimal válido (deve ser 0-9, a-f ou A-F).

Entrada: "01-23-45-67-AH"
Saída: false
Explicação: Esta string tem apenas cinco grupos em vez de seis.

Usando uma expressão regular concisa, essa abordagem valida eficientemente formatos padrão de endereço MAC, garantindo que apenas endereços corretamente estruturados retornem positivo.

Quando usar a validação de regex MAC?

• Sistemas de registro de dispositivos: Valide IDs MAC durante o onboarding.

• Ferramentas de rede: Garanta entrada MAC limpa e utilizável antes de configurar conexões.

• Sistemas IoT e embarcados: Identifique dispositivos com consistência em logs.

• Software de segurança: Crie listas de permissões de MACs usando filtragem baseada em regex.

Validando Endereços MAC em JavaScript

Se você prefere validar endereços MAC com JavaScript, uma expressão regular oferece uma solução concisa e eficiente. Seja para processar entrada em onboarding de dispositivos ou verificar configurações de rede, veja como lidar com a validação de endereço MAC em seus scripts.

Expressão Regular para Endereços MAC em JavaScript

Um endereço MAC tipicamente aparece nos formatos 01:23:45:67:89:AB, 01-23-45-67-89-AB ou 0123.4567.89AB. Para acomodar esses formatos, você pode usar o seguinte padrão regex:

const macRegex = /^([0-9A-Fa-f]{2}([-:])){5}([0-9A-Fa-f]{2})$^([0-9A-Fa-f]{4}.[0-9A-Fa-f]{4}.[0-9A-Fa-f]{4})$/;

Função de Validação em JavaScript

Aqui está uma função direta para verificar se uma string é um endereço MAC válido:

function isValidMacAddress(mac) {
if (typeof mac !== 'string' !mac.length) return false;
return macRegex.test(mac);
}

Exemplo de uso

Você pode usar esta função para validar diferentes formatos de endereço MAC:

console.log(isValidMacAddress('01-23-45-67-89-AB')); // true
console.log(isValidMacAddress('01:23:45:67:89:AB')); // true
console.log(isValidMacAddress('0123.4567.89AB'));    // true
console.log(isValidMacAddress('01-23-45-67-89-AH')); // false
console.log(isValidMacAddress('01-23-45-67-AH'));    // false

Com essa abordagem, você pode validar rapidamente endereços MAC enviados por usuários, impor formatação adequada em seus apps ou criar utilitários de teste personalizados para agilizar seu processo de QA.

Validando Endereços MAC em Python

Se você prefere Python ao Go para suas tarefas de validação, ainda pode aproveitar o poder das expressões regulares para confirmar a formatação correta de endereços MAC. Isso é útil se sua stack é baseada em Python e exige validação robusta de entrada, como em APIs Flask, ferramentas CLI ou scripts de automação.

Aqui está um exemplo simples em Python que verifica endereços MAC válidos tanto no formato de dois-pontos (:) quanto de hífen (-):

import re
def is_valid_mac(mac):
pattern = r"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$"
return bool(re.match(pattern, mac))
Exemplos de uso:
print(is_valid_mac("01-23-45-67-89-AB"))  # True
print(is_valid_mac("01:23:45:67:89:AB"))  # True
print(is_valid_mac("0123.4567.89AB"))     # False
print(is_valid_mac("01-23-45-67-89-AH"))  # False

O que observar:

• O regex espelha o padrão Go para consistência, aceitando apenas seis grupos de dois dígitos hexadecimais (maiúsculos ou minúsculos).

• Separa grupos estritamente por dois-pontos ou hífens (não uma mistura).

• Sem suporte para a notação com ponto no estilo Cisco (ex.: 0123.4567.89AB). Se seu sistema precisar disso, você precisará estender o padrão.

Para cenários mais avançados, você pode aprimorar o regex ou adicionar verificações para casos extremos de formatação conforme seus requisitos específicos.

Como validar endereços MAC em Java

Quer validar endereços MAC em Java? Você pode usar expressões regulares para verificar os formatos padrão, como 01:23:45:67:89:AB, 01-23-45-67-89-AB ou mesmo 0123.4567.89AB. A chave é corresponder a estrutura desses endereços usando as capacidades de regex embutidas do Java.

Aqui está uma abordagem direta:

1. Escolha um regex que cubra formatos comuns de endereço MAC:

   • Pares hexadecimais separados por dois-pontos (:) ou hífens (-):
     01:23:45:67:89:AB ou 01-23-45-67-89-AB

   • Três grupos de quatro dígitos hexadecimais separados por pontos (.):
     0123.4567.89AB

2. Padrão Regex de Exemplo

   String regex = "^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$"
   + "^([0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4})$";

3. Implementação de método validador:

   import java.util.regex.Pattern;
   public static boolean isValidMAC(String input) {
   if (input == null) return false;
   String regex = "^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$"
   + "^([0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4})$";
   return Pattern.matches(regex, input);
   }

4. Exemplo de uso:

   System.out.println(isValidMAC("01:23:45:67:89:AB")); // true
   System.out.println(isValidMAC("01-23-45-67-89-AB")); // true
   System.out.println(isValidMAC("0123.4567.89AB"));    // true
   System.out.println(isValidMAC("01-23-45-67-89-AH")); // false
   System.out.println(isValidMAC("not-a-mac"));         // false

Este método oferece uma solução rápida e flexível para validar endereços MAC em projetos Java, seja construindo utilitários de rede ou ferramentas robustas de gerenciamento de dispositivos.

Como validar um endereço MAC em C# usando Regex

Quer fazer a mesma validação de endereço MAC em C#? Usando a classe Regex embutida do .NET, o processo é igualmente acessível. Aqui está como implementá-lo:

Exemplo de código C#

Abaixo está uma função C# simples que verifica se uma string é um formato válido de endereço MAC, incluindo suporte para formatos separados por dois-pontos, hífen e ponto no estilo Cisco.

using System.Text.RegularExpressions;
public static bool IsValidMacAddress(string input)
{
if (string.IsNullOrWhiteSpace(input))
return false;
// Corresponde a 01:23:45:67:89:AB, 01-23-45-67-89-AB, ou 0123.4567.89AB
var pattern = @"^([0-9A-Fa-f]{2}([:-])){5}[0-9A-Fa-f]{2}$^([0-9A-Fa-f]{4}\.){2}[0-9A-Fa-f]{4}$";
return Regex.IsMatch(input, pattern);

}

Exemplo de uso

Console.WriteLine(IsValidMacAddress("01:23:45:67:89:AB")); // true
Console.WriteLine(IsValidMacAddress("01-23-45-67-89-AB")); // true
Console.WriteLine(IsValidMacAddress("0123.4567.89AB"));    // true
Console.WriteLine(IsValidMacAddress("01-23-45-67-89-AH")); // false
Console.WriteLine(IsValidMacAddress("random-string"));     // false

Notas rápidas

• O regex suporta formatos comuns de endereço MAC e a notação com ponto no estilo Cisco.

• Verifica exatamente seis pares (formatos com dois-pontos/hífen) ou três grupos de quatro dígitos hex (formato com ponto).

• Qualquer desvio, como caracteres inválidos ou segmentos ausentes, fará a verificação falhar.

Exemplo: Validação de endereço MAC em C++

Precisa validar endereços MAC em C++ em vez de Go? Você pode usar o header <regex> da biblioteca padrão C++ para criar um validador simples e robusto. Veja como verificar se uma string é um endereço MAC válido usando expressões regulares em C++:

#include
#include
#include
// Retorna true se o endereço MAC tiver o formato válido
bool isValidMACAddress(const std::string& mac) {
// Regex cobre as notações com dois-pontos e hífen (ex.: 01:23:45:67:89:AB e 01-23-45-67-89-AB)
std::regex macPattern("^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$");
return std::regex_match(mac, macPattern);
}
int main() {
std::cout << std::boolalpha;
std::cout << isValidMACAddress("01-23-45-67-89-AB") << std::endl; // true
std::cout << isValidMACAddress("01:23:45:67:89:AB") << std::endl; // true
std::cout << isValidMACAddress("0123.4567.89AB")   << std::endl;  // false
std::cout << isValidMACAddress("01-23-45-67-89-AH")<< std::endl; // false
std::cout << isValidMACAddress("01-23-45-67-AH")   << std::endl; // false
return 0;
}

Como funciona:

• O padrão garante que cada segmento contenha dois dígitos hexadecimais ([0-9A-Fa-f]{2}), com segmentos separados por dois-pontos ou hífens.

• A função retorna true somente quando a entrada corresponde exatamente ao formato de endereço MAC, sem caracteres extras, delimitadores adicionais ou bytes ausentes.

Dica: Se você precisar aceitar MACs com ponto (como em alguns hardwares Cisco, ex.: 0123.4567.89AB), o regex precisa ser expandido. Caso contrário, o padrão padrão funciona para quase todos os propósitos gerais.

Dicas profissionais para melhor validação com regex MAC

• Use [0-9a-fA-F] para cobrir maiúsculas e minúsculas.

• Mantenha um estilo de separador (dois-pontos ou hífen) dentro de um regex para manter os padrões estritos.

• Evite padrões que permitam caracteres no final ou comprimentos de segmento incorretos.

• Se comparar múltiplos atributos de dispositivos, experimente combinar com o Gerador de Endereço IP ou o Gerador de UUID.

Metacaracteres úteis para regex MAC

• ^: Início da string

• $: Fim da string

• [0-9a-fA-F]: Qualquer dígito hexadecimal (sem distinção de maiúsculas/minúsculas)

• {2}: Exatamente dois caracteres

• [:-]: Separador de dois-pontos ou hífen

• {5}: Repetir 5 vezes

Você pode copiar este padrão diretamente no Testador Regex Go para testar sua lógica ao vivo.

Combine com estas ferramentas

• Gerador de Endereço IP - Simule configurações IP + MAC

• Gerador de Nome de Usuário - Vincule MACs a IDs de usuário em dashboards de dispositivos

• Gerador de Senha - Proteja o acesso de dispositivos vinculados a MACs

• Gerador de Número de Telefone - Adicione metadados móveis a registros de dispositivos

• Testador Regex Go - Depure qualquer padrão regex Go complexo rapidamente