¿Qué es el Regex de Dirección MAC?

Una dirección MAC (Media Access Control) es un identificador único asignado a interfaces de red. Aparece típicamente en el formato 00:1A:2B:3C:4D:5E o 00-1A-2B-3C-4D-5E, usando dígitos hexadecimales separados por dos puntos o guiones.

En JavaScript, podemos usar expresiones regulares (regex) para verificar si una cadena sigue esta estructura antes de usarla en redes, identificación de dispositivos o filtrado de acceso.

Patrón Regex de Dirección MAC

El regex comúnmente usado para validar direcciones MAC es:

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

Este coincide con:

• Seis grupos de dos caracteres hexadecimales

• Separados por : o -

• Sin distinción de mayúsculas (gracias a [A-Fa-f])

Cómo Validar una Dirección MAC usando Regex en JavaScript

Aquí hay un ejemplo completo en 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

Validación de Direcciones MAC en Python

¿Prefiere trabajar en Python? También puede usar expresiones regulares allí para la validación de direcciones MAC. Aquí hay un enfoque conciso y amigable para desarrolladores:

import re
def is_valid_mac(mac):
"""
Verifica si la cadena proporcionada es una dirección MAC válida
(admite notación con dos puntos, guiones y puntos estilo Cisco)
"""
mac_regex = re.compile(
r"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$"   # Coincide con 00:1A:2B:3C:4D:5E o 00-1A-2B-3C-4D-5E
r"^([0-9A-Fa-f]{4}.){2}[0-9A-Fa-f]{4}$"      # Coincide con el formato Cisco como 001A.2B3C.4D5E
)
return bool(mac_regex.match(mac.strip()))
Ejemplo 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 no es hex)
"01-23-45-67-AH",         # False (faltan grupos)
]
for mac in test_cases:
print(f"{mac}: {is_valid_mac(mac)}")

Validación de Direcciones MAC con Regex en Java

Si trabaja en Java y necesita garantizar que sus direcciones MAC estén correctamente formateadas, las expresiones regulares ofrecen una solución confiable, igual que en JavaScript. El enfoque es muy similar: defina el regex, compílelo y verifique la cadena objetivo.

Aquí hay un ejemplo conciso:

import java.util.regex.Pattern;
public class MacAddressValidator {
// El patrón regex acepta formatos con dos puntos, guiones y puntos
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();
}

}

Ejemplo de Uso

Pruebe rápidamente su implementación con muestras del 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

Cómo funciona:

• El regex coincide con:

  • 6 grupos de dos caracteres hexadecimales, separados por dos puntos o guiones (por ejemplo, AB:CD:EF:01:23:45)

  • O bien, la notación con puntos estilo Cisco (ABCD.EF01.2345)

• Se aceptan tanto letras mayúsculas como minúsculas.

Esto le permite usar Java para una validación robusta de entradas de dirección MAC, ya sea que esté construyendo herramientas del lado del servidor o utilidades de red.

Validación de Direcciones MAC en C# con Expresiones Regulares

Si necesita validar direcciones MAC fuera de JavaScript, por ejemplo en un backend C# o una aplicación de escritorio, el proceso es bastante similar. Las expresiones regulares en C# funcionan igual de bien para la coincidencia de patrones y la validación de entradas.

Aquí se explica cómo verificar si una cadena es un formato de dirección MAC válido en C#:

using System.Text.RegularExpressions;
bool IsValidMacAddress(string input)
{
// El regex coincide con formatos como 01-23-45-67-89-AB, 01:23:45:67:89:AB o 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);
}

Ejemplo 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 función considera ambos formatos comunes de dirección MAC (separados por dos puntos, guiones o puntos). Es perfecta para validar la entrada de usuarios, actualizar configuraciones de red o filtrar listas de dispositivos en cualquier aplicación basada en .NET.

Validación de Dirección MAC con Regex en C++

Si trabaja en C++ y necesita realizar la validación de direcciones MAC, las expresiones regulares (regex) ofrecen una solución eficiente, similar en principio a JavaScript, solo con algunas bibliotecas diferentes.

Aquí hay una función C++ simple que verifica si una cadena dada es una dirección MAC válida:

#include
#include
#include
// Devuelve true si 'mac' coincide con los formatos comunes de dirección MAC.
Bool isValidMacAddress(const std::string& mac) {
std::regex macPattern(
"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$"     // Estándar: 01:23:45:67:89:AB o 01-23-45-67-89-AB
"^([0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4}\.[0-9A-Fa-f]{4})$" // Cisco: 0123.4567.89AB
);
return std::regex_match(mac, macPattern);
}

Ejemplo de Uso

Aquí se muestra cómo usar esta función en una aplicación C++ básica:

#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' no es hexadecimal
"01-23-45-67-AH"     // Inválido: no hay suficientes grupos
};
for (const auto& mac : testMacs) {
    std::cout << mac << " => " << (isValidMacAddress(mac) ? "Valid" : "Invalid") << std::endl;
}

}

Esta configuración imprimirá si cada dirección MAC de prueba es válida o no, siguiendo los formatos típicos usados en redes.

Con este enfoque, puede garantizar que sus herramientas de red C++, scripts de gestión de dispositivos o servicios backend filtren de manera confiable las direcciones MAC malformadas antes de seguir procesando.

Complejidad de Tiempo y Espacio de la Validación Regex de Dirección MAC

Cuando verifica si una dirección MAC coincide con la expresión regular, la eficiencia importa, especialmente si está procesando datos de red a escala. El motor regex examina cada carácter de la cadena de entrada una vez, lo que hace que el proceso de validación sea lineal con respecto a la longitud de la entrada. Entonces, para una dirección MAC de longitud N, la operación se ejecuta en tiempo O(N).

En cuanto al espacio, sin importar el tamaño de la entrada, la validación regex en JavaScript utiliza una cantidad fija de memoria adicional. No es necesario asignar espacio que escale con la entrada, por lo que la complejidad de espacio se mantiene en O(1). Esto significa que su aplicación permanece ligera, incluso al manejar muchas direcciones.

Casos de Uso Reales

• Configuración de red: Valide direcciones MAC antes de almacenarlas o usarlas en herramientas de configuración de router o servidor.

• Gestión de dispositivos: Identifique y verifique dispositivos en ecosistemas IoT.

• Control de acceso: Permita o bloquee MACs específicas en sistemas sensibles a la seguridad.

• Validación de entrada en formularios: Asegúrese de que los usuarios no ingresen formatos de MAC inválidos en aplicaciones web.

Consejos Profesionales

• Siempre elimine los espacios en blanco de las cadenas de entrada antes de validar.

• Regex es para verificación de formato, no de legitimidad. Una dirección MAC sintácticamente válida puede no existir en realidad.

• Admita tanto los formatos con : como con - si su aplicación maneja diferentes fuentes.

• Considere usar el Codificador Base64 para almacenamiento o transmisión seguros.

• Use esto en combinación con el Generador de token para asignar tokens únicos a dispositivos después de la validación.

Metacaracteres JavaScript Utilizados

• ^: Ancla el regex al inicio de la cadena.

• $: Ancla el regex al final de la cadena.

• [0-9A-Fa-f]: Coincide con un único carácter hexadecimal (sin distinción de mayúsculas).

• {2}: Cuantificador - exactamente 2 caracteres.

• [:-]: Coincide con ':' o '-'.

• {5}: Cuantificador - coincide con el grupo 5 veces.

• (...): Grupo de captura.

Entradas de Ejemplo para 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 con Estas Herramientas

Use este Validador de Dirección MAC junto con:

• Validador Regex de Dirección IP en JavaScript: Para validar la identidad completa de red del dispositivo.

• Validador Regex UUID en JavaScript: Para validar IDs únicos asignados por el sistema.

• Decodificador Base64: Decodifique cargas útiles de datos de red después del cifrado.