O que é Regex de Endereço MAC?

Um endereço MAC (Media Access Control) é um identificador único atribuído a interfaces de rede. Ele tipicamente aparece no formato 00:1A:2B:3C:4D:5E ou 00-1A-2B-3C-4D-5E, usando dígitos hexadecimais separados por dois-pontos ou hífens.

Em JavaScript, podemos usar expressões regulares (regex) para verificar se uma string segue essa estrutura antes de usá-la em redes, identificação de dispositivos ou filtragem de acesso.

Padrão Regex de Endereço MAC

O regex comumente usado para validar endereços MAC é:

^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$

Este padrão corresponde a:

• Seis grupos de dois caracteres hexadecimais

• Separados por : ou -

• Sem distinção de maiúsculas/minúsculas (graças a [A-Fa-f])

Como validar endereço MAC usando regex em JavaScript

Aqui está um exemplo completo em JavaScript:

function isValidMacAddress(mac) {
  const macRegex = /^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/;
  return macRegex.test(mac);
}
console.log(isValidMacAddress("00:1A:2B:3C:4D:5E")); // true
console.log(isValidMacAddress("00-1A-2B-3C-4D-5E")); // true
console.log(isValidMacAddress("001A.2B3C.4D5E"));    // false

Validando Endereços MAC em Python

Prefere trabalhar em Python? Você também pode usar expressões regulares para validação de endereço MAC. Veja uma abordagem concisa e amigável para desenvolvedores:

import re
def is_valid_mac(mac):
"""
Verifica se a string fornecida é um endereço MAC válido
(suporta notação com dois-pontos, hífen e ponto no estilo Cisco)
"""
mac_regex = re.compile(
r"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$"   # Corresponde a 00:1A:2B:3C:4D:5E ou 00-1A-2B-3C-4D-5E
r"^([0-9A-Fa-f]{4}.){2}[0-9A-Fa-f]{4}$"      # Corresponde ao formato Cisco como 001A.2B3C.4D5E
)
return bool(mac_regex.match(mac.strip()))
Exemplo de uso:
test_cases = [
"01-23-45-67-89-AB",      # True
"01:23:45:67:89:AB",      # True
"0123.4567.89AB",         # True
"01-23-45-67-89-AH",      # False (H não é hex)
"01-23-45-67-AH",         # False (grupos ausentes)
]
for mac in test_cases:
print(f"{mac}: {is_valid_mac(mac)}")

Validando Endereços MAC com Regex em Java

Se você trabalha em Java e precisa garantir que seus endereços MAC estejam formatados corretamente, expressões regulares oferecem uma solução confiável, muito semelhante ao JavaScript. A abordagem é bastante similar: defina o regex, compile-o e verifique sua string alvo.

Veja um exemplo conciso:

import java.util.regex.Pattern;
public class MacAddressValidator {
// Padrão regex aceita formatos com dois-pontos, hífen e ponto
private static final Pattern MAC_REGEX = Pattern.compile(
"^([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})$"
);
public static boolean isValidMac(String input) {
    return input != null && MAC_REGEX.matcher(input).matches();
}

}

Exemplo de uso

Teste rapidamente sua implementação com amostras do mundo real:

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("01-23-45-67-AH"));    // false

Como funciona:

• O regex corresponde a:

  • 6 grupos de dois caracteres hexadecimais, separados por dois-pontos ou hífens (ex.: AB:CD:EF:01:23:45)

  • Ou notação com ponto no estilo Cisco (ABCD.EF01.2345)

• Letras maiúsculas e minúsculas são aceitas.

Isso permite usar Java para validação robusta de entrada de endereço MAC, seja construindo ferramentas server-side ou utilitários de rede.

Validando Endereços MAC em C# com Expressões Regulares

Se você precisa validar endereços MAC fora do JavaScript, como em um backend C# ou app desktop, o processo é bastante similar. Expressões regulares em C# funcionam tão bem para correspondência de padrões e validação de entrada.

Veja como verificar se uma string é um formato válido de endereço MAC em C#:

using System.Text.RegularExpressions;
bool IsValidMacAddress(string input)
{
// Regex corresponde a formatos como 01-23-45-67-89-AB, 01:23:45:67:89:AB, ou 0123.4567.89AB
var macRegex = new Regex(
@"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$^([0-9A-Fa-f]{4}.){2}[0-9A-Fa-f]{4}$"
);
return !string.IsNullOrEmpty(input) && macRegex.IsMatch(input);
}

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("01-23-45-67-AH"));    // false

Esta função considera os formatos comuns de endereço MAC (separados por dois-pontos, hífen ou ponto). É perfeita para validar entrada de usuários, atualizar configurações de rede ou filtrar listas de dispositivos em qualquer aplicação .NET.

Validação de Endereço MAC com Regex em C++

Se você trabalha em C++ e precisa realizar validação de endereço MAC, expressões regulares oferecem uma solução eficiente, semelhante em princípio ao JavaScript, mas com bibliotecas diferentes.

Veja uma função C++ simples que verifica se uma string é um endereço MAC válido:

#include
#include
#include
// Retorna true se 'mac' corresponder a formatos comuns de endereço MAC.
Bool isValidMacAddress(const std::string& mac) {
std::regex macPattern(
"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$"     // Padrão: 01:23:45:67:89:AB ou 01-23-45-67-89-AB
"^([0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4})$" // Estilo Cisco: 0123.4567.89AB
);
return std::regex_match(mac, macPattern);
}

Exemplo de uso

Veja como usar esta função em um app C++ básico:

#include
int main() {
std::vector testMacs = {
"01-23-45-67-89-AB",
"01:23:45:67:89:AB",
"0123.4567.89AB",
"01-23-45-67-89-AH", // Inválido: 'H' não é hexadecimal
"01-23-45-67-AH"     // Inválido: grupos insuficientes
};
for (const auto& mac : testMacs) {
    std::cout << mac << " => " << (isValidMacAddress(mac) ? "Válido" : "Inválido") << std::endl;
}

}

Essa configuração vai imprimir se cada endereço MAC de teste é válido ou não, seguindo os formatos típicos usados em redes.

Com essa abordagem, você pode garantir que suas ferramentas de rede C++, scripts de gerenciamento de dispositivos ou serviços de backend filtrem de forma confiável endereços MAC malformados antes de qualquer processamento adicional.

Complexidade de tempo e espaço na validação de regex de endereço MAC

Quando você verifica se um endereço MAC corresponde à expressão regular, a eficiência importa, especialmente quando você processa dados de rede em escala. O mecanismo de regex examina cada caractere da string de entrada uma vez, tornando o processo de validação linear em relação ao comprimento da entrada. Portanto, para um endereço MAC de comprimento N, a operação é executada em tempo O(N).

Quanto ao espaço, independentemente do tamanho da entrada, a validação com regex em JavaScript usa uma quantidade fixa de memória adicional. Não há necessidade de alocar espaço que escale com a entrada, então a complexidade de espaço permanece em O(1). Isso significa que seu app permanece leve, mesmo ao lidar com muitos endereços.

Casos de uso no mundo real

• Configuração de rede: Valide endereços MAC antes de armazená-los ou usá-los em ferramentas de configuração de roteador ou servidor.

• Gerenciamento de dispositivos: Identifique e verifique dispositivos em ecossistemas IoT.

• Controle de acesso: Permita ou bloqueie MACs específicos em sistemas sensíveis à segurança.

• Validação de entrada em formulários: Certifique-se de que os usuários não insiram formatos MAC inválidos em aplicações web.

Dicas profissionais

• Sempre remova espaços em branco das strings de entrada antes da validação.

• Regex é para verificação de formato, não de legitimidade. Um endereço MAC sintaticamente válido pode não existir.

• Suporte tanto : quanto - se sua aplicação lida com diferentes fontes.

• Considere usar o Codificador Base64 para armazenamento ou transmissão segura.

• Use em combinação com o Gerador de Token para atribuir tokens únicos a dispositivos após a validação.

Metacaracteres JavaScript usados

• ^: Ancora o regex no início da string.

• $: Ancora o regex no final da string.

• [0-9A-Fa-f]: Corresponde a um único caractere hexadecimal (sem distinção de maiúsculas/minúsculas).

• {2}: Quantificador - exatamente 2 caracteres.

• [:-]: Corresponde a ':' ou '-'.

• {5}: Quantificador - corresponde ao grupo 5 vezes.

• (...): Grupo de captura.

Exemplos de entradas regex

1. "01:23:45:67:89:AB" - Válido

2. "01-23-45-67-89-AB" - Válido

3. "0123.4567.89AB" - Inválido

4. "G1:23:45:67:89:ZZ" - Inválido

Combine com estas ferramentas

Use este Validador de Endereço MAC junto com:

• Validador Regex de Endereço IP em JavaScript: Para validar a identidade completa de rede do dispositivo.

• Validador Regex de UUID em JavaScript: Para validar IDs únicos atribuídos pelo sistema.

• Decodificador Base64: Decodifique payloads de dados de rede após criptografia.