Validador Regex de Dirección MAC en Go

Una dirección MAC (Media Access Control) es un identificador único utilizado para etiquetar dispositivos en una red. Validar estas direcciones es fundamental en sistemas que rastrean, autorizan o se comunican con componentes de hardware. El Validador Regex de Dirección MAC en Go de Qodex ayuda a los desarrolladores y testers a confirmar rápidamente si una cadena sigue el formato MAC válido usando el paquete regexp de Go.

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

En Go, puede usar expresiones regulares para hacer coincidir patrones de dirección MAC. Una dirección MAC típica se ve así:

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

Las direcciones MAC están compuestas por seis grupos de dos dígitos hexadecimales separados por dos puntos o guiones. El regex debe garantizar este formato sin permitir caracteres extra ni segmentos faltantes.

Patrón Regex para Direcciones MAC

Aquí está el regex recomendado en Go para hacer coincidir direcciones MAC estándar:

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

Qué significa:

• ^ - Inicio de cadena

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

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

• $ - Fin de cadena

Esto garantiza que la cadena tenga exactamente 6 pares y use separadores consistentes.

Consideraciones de Rendimiento

Al usar una expresión regular para validar una dirección MAC en Go, el proceso es generalmente muy eficiente. El motor regex examina cada carácter de la cadena de entrada exactamente una vez, lo que resulta en una complejidad temporal de O(N), donde N es la longitud de la cadena de dirección MAC que se verifica.

El uso de memoria es mínimo; la expresión regular requiere solo una cantidad constante de espacio adicional para realizar la coincidencia (O(1) de espacio auxiliar), independientemente de la longitud de la entrada. Esto hace que la validación de direcciones MAC basada en regex sea rápida y ligera, incluso al manejar múltiples entradas o integrar verificaciones en flujos de trabajo de API.

Cómo Funciona

1. Ingrese o pegue su regex (o use el predeterminado).

2. Ingrese una dirección MAC de prueba.

3. Vea instantáneamente si coincide o falla.

4. Ajuste su patrón según sea necesario y valide de nuevo.

Ejemplo: Validador Básico

Use el Tester de Regex en Go para experimentar con variaciones.

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"
Salida: true
Explicación: Esta cadena coincide con el formato esperado de dirección MAC con seis grupos de dos dígitos hexadecimales separados por guiones.

Entrada: "00:1A:2B:3C:4D:5E"
Salida: true
Explicación: Los dos puntos también son separadores válidos, por lo que este formato es aceptado.

Entrada: "001A.2B3C.4D5E"
Salida: false
Explicación: Los puntos no son separadores válidos en este patrón, por lo que no se reconoce como una dirección MAC válida.

Entrada: "01-23-45-67-89-AH"
Salida: false
Explicación: 'H' no es un dígito hexadecimal válido (debe ser 0-9, a-f o A-F).

Entrada: "01-23-45-67-AH"
Salida: false
Explicación: Esta cadena solo tiene cinco grupos en lugar de seis.

Mediante una expresión regular concisa, este enfoque valida eficientemente los formatos estándar de dirección MAC, garantizando que solo las direcciones correctamente estructuradas devuelvan un resultado positivo.

¿Cuándo Debe Usar Validación Regex de MAC?

• Sistemas de registro de dispositivos: Valide IDs de MAC durante la incorporación.

• Herramientas de red: Garantice entradas de MAC limpias y utilizables antes de configurar la conexión.

• Sistemas IoT y embebidos: Identifique dispositivos con consistencia en los registros.

• Software de seguridad: Filtre MACs en listas blancas usando filtrado basado en regex.

Validación de Direcciones MAC en JavaScript

Si prefiere validar direcciones MAC con JavaScript, una expresión regular ofrece una solución concisa y eficiente. Ya sea que esté analizando entradas para la incorporación de dispositivos o verificando configuraciones de red, así puede abordar la validación de direcciones MAC en sus scripts.

Expresión Regular de Muestra para Direcciones MAC

Una dirección MAC aparece típicamente en formatos como 01:23:45:67:89:AB, 01-23-45-67-89-AB o 0123.4567.89AB. Para acomodar estos formatos, puede usar el siguiente patrón 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})$/;

Función de Validación en JavaScript

Aquí hay una función sencilla para verificar si una cadena es una dirección MAC válida:

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

Ejemplo de Uso

Puede usar esta función para validar diferentes formatos de dirección 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

Con este enfoque, puede validar rápidamente las direcciones MAC enviadas por usuarios, aplicar el formato correcto en sus aplicaciones o construir utilidades de prueba personalizadas para agilizar su proceso de QA.

Validación de Direcciones MAC en Python

Si prefiere Python sobre Go para sus tareas de validación, puede aprovechar el poder de las expresiones regulares para confirmar el formato correcto de dirección MAC. Esto es útil si su stack es principalmente Python pero requiere una validación de entrada robusta, como en APIs Flask, herramientas de CLI o scripts de automatización.

Aquí hay un ejemplo sencillo en Python que verifica direcciones MAC válidas en formatos con dos puntos (:) y guiones (-):

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))
Ejemplos 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

Notas importantes:

• El regex refleja el patrón de Go para consistencia, aceptando solo seis grupos de dos dígitos hexadecimales (mayúsculas o minúsculas).

• Separa estrictamente los grupos por dos puntos o guiones (no una mezcla).

• Sin soporte para la notación con puntos estilo Cisco (por ejemplo, 0123.4567.89AB). Si su sistema lo requiere, deberá extender el patrón.

Cómo Validar Direcciones MAC en Java

¿Desea validar direcciones MAC en Java? Puede usar expresiones regulares para verificar los formatos estándar, como 01:23:45:67:89:AB, 01-23-45-67-89-AB o incluso 0123.4567.89AB. La clave es hacer coincidir la estructura de estas direcciones usando las capacidades regex integradas de Java.

Aquí hay un enfoque sencillo:

1. Elija un regex que cubra los formatos comunes de dirección MAC:

   • Pares hexadecimales separados por dos puntos (:) o guiones (-):
     01:23:45:67:89:AB o 01-23-45-67-89-AB

   • Tres grupos de cuatro dígitos hexadecimales separados por puntos (.):
     0123.4567.89AB

2. Patrón Regex de Muestra

   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. Implemente un método de validación:

   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. Ejemplo 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 le proporciona una solución rápida y flexible para validar direcciones MAC en proyectos Java, ya sea que esté construyendo utilidades de red o herramientas robustas de gestión de dispositivos.

Cómo Validar una Dirección MAC en C# Usando Regex

¿Desea lograr la misma validación de dirección MAC en C#? No hay problema, es igualmente accesible, usando la clase Regex integrada de .NET. El proceso implica crear una expresión regular que capture el patrón correcto y verificar si la cadena coincide. Aquí se explica cómo implementarlo:

Ejemplo de Código en C#

A continuación hay una función C# simple que verifica si una cadena es un formato de dirección MAC válido, incluido soporte para formatos separados por dos puntos, guiones y puntos estilo Cisco.

using System.Text.RegularExpressions;
public static bool IsValidMacAddress(string input)
{
if (string.IsNullOrWhiteSpace(input))
return false;
// Coincide con 01:23:45:67:89:AB, 01-23-45-67-89-AB o 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);

}

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("random-string"));     // false

Notas Rápidas

• El regex admite tanto los formatos comunes de dirección MAC como la notación con puntos estilo Cisco.

• Verifica exactamente seis pares (formatos con dos puntos/guiones) o tres grupos de cuatro dígitos hex (formato con puntos).

• Cualquier desviación, como caracteres inválidos o segmentos faltantes, fallará la verificación.

Ejemplo: Validación de Dirección MAC en C++

¿Necesita validar direcciones MAC en C++ en lugar de Go? Puede usar el encabezado <regex> de la biblioteca estándar de C++ para crear un validador simple y robusto. Aquí se explica cómo verificar si una cadena es una dirección MAC válida usando expresiones regulares en C++:

#include
#include
#include
// Devuelve true si la entrada es un formato de dirección MAC válido
bool isValidMACAddress(const std::string& mac) {
// El regex cubre las notaciones con dos puntos y guiones (por ejemplo, 01:23:45:67:89:AB y 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;
}

Cómo funciona:

• El patrón garantiza que cada segmento contenga dos dígitos hexadecimales ([0-9A-Fa-f]{2}), con segmentos separados por dos puntos o guiones.

• La función devuelve true solo cuando la entrada coincide exactamente con el formato de dirección MAC, sin caracteres extraños, delimitadores adicionales o bytes faltantes.

Consejo: Si necesita aceptar MACs separadas por puntos (como se ve en algunos hardware Cisco, por ejemplo, 0123.4567.89AB), el regex debe expandirse. De lo contrario, el patrón estándar funciona para casi todos los propósitos generales.

Consejos Profesionales para una Mejor Validación Regex de MAC

• Use [0-9a-fA-F] para cubrir tanto mayúsculas como minúsculas.

• Cíñase a un estilo de separador (dos puntos o guiones) dentro de un regex para mantener los patrones estrictos.

• Evite patrones que permitan caracteres al final o longitudes de segmento incorrectas.

• Si compara múltiples atributos de dispositivos, pruebe combinarlo con el Generador de Dirección IP o el Generador UUID.

Metacaracteres Útiles para Regex de MAC

• ^: Inicio de cadena

• $: Fin de cadena

• [0-9a-fA-F]: Cualquier dígito hex (sin distinción de mayúsculas)

• {2}: Exactamente dos caracteres

• [:-]: Separador de dos puntos o guión

• {5}: Repetir 5 veces

Puede copiar este patrón directamente en el Tester de Regex en Go para probar su lógica en vivo.

Combine con Estas Herramientas

• Generador de Dirección IP - Simule configuraciones de IP + MAC

• Generador de Nombre de Usuario - Combine MACs con IDs de usuario en paneles de dispositivos

• Generador de Contraseña - Proteja el acceso a dispositivos vinculados a MACs

• Generador de Número de Teléfono - Agregue metadatos móviles a los registros de dispositivos

• Tester de Regex en Go - Depure rápidamente cualquier patrón regex complejo en Go