Validateur regex JavaScript pour adresses MAC

Qu'est-ce que le regex pour adresses MAC ?

Une adresse MAC (Media Access Control) est un identifiant unique attribué aux interfaces réseau. Elle apparaît généralement au format 00:1A:2B:3C:4D:5E ou 00-1A-2B-3C-4D-5E, avec des chiffres hexadécimaux séparés par des deux-points ou des tirets.

En JavaScript, nous pouvons utiliser des expressions régulières (regex) pour vérifier si une chaîne respecte cette structure avant de l'utiliser dans la mise en réseau, l'identification d'appareils ou le filtrage des accès.

Pattern regex pour les adresses MAC

Le regex couramment utilisé pour valider les adresses MAC est :

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

Ce pattern accepte :

• Six groupes de deux caractères hexadécimaux

• Séparés par : ou -

• Insensible à la casse (grâce à [A-Fa-f])

Comment valider une adresse MAC avec regex en JavaScript

Voici un exemple JavaScript complet :

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

Validation des adresses MAC en Python

Si vous préférez travailler en Python, voici une approche concise :

import re
def is_valid_mac(mac):
"""
Vérifie si la chaîne fournie est une adresse MAC valide
(supporte les notations deux-points et tiret)
"""
mac_regex = re.compile(
r"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$"
)
return bool(mac_regex.match(mac.strip()))
test_cases = [
"01-23-45-67-89-AB",      # True
"01:23:45:67:89:AB",      # True
"0123.4567.89AB",         # False
"01-23-45-67-89-AH",      # False (H n'est pas hexadécimal)
"01-23-45-67-AH",         # False (groupes manquants)
]
for mac in test_cases:
print(f"{mac}: {is_valid_mac(mac)}")

Validation des adresses MAC avec regex en Java

Si vous travaillez en Java, les expressions régulières offrent une solution fiable, similaire à JavaScript. Voici un exemple concis :

import java.util.regex.Pattern;
public class MacAddressValidator {
private static final Pattern MAC_REGEX = Pattern.compile(
"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$"
);
public static boolean isValidMac(String input) {
    return input != null && MAC_REGEX.matcher(input).matches();
}

}
// Exemple d'utilisation :
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

Validation des adresses MAC en C# avec des expressions régulières

Si vous avez besoin de valider des adresses MAC en C#, le processus est très similaire. Voici comment vérifier si une chaîne est une adresse MAC valide :

using System.Text.RegularExpressions;
bool IsValidMacAddress(string input)
{
var macRegex = new Regex(
@"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$"
);
return !string.IsNullOrEmpty(input) && macRegex.IsMatch(input);
}
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

Complexité temporelle et spatiale de la validation regex

Lorsque vous vérifiez si une adresse MAC correspond à l'expression régulière, le moteur regex examine chaque caractère de la chaîne d'entrée une seule fois, ce qui rend la validation linéaire par rapport à la longueur de l'entrée : O(N). Quant à l'espace, quelle que soit la taille de l'entrée, la validation regex JavaScript utilise une quantité fixe de mémoire supplémentaire. La complexité spatiale reste donc O(1), ce qui garantit des performances légères même pour un grand volume d'adresses.

Cas d'utilisation réels

• Configuration réseau : Validez les adresses MAC avant de les stocker ou de les utiliser dans des outils de configuration de routeurs ou de serveurs.

• Gestion d'appareils : Identifiez et vérifiez les appareils dans les écosystèmes IoT.

• Contrôle d'accès : Autorisez ou bloquez des adresses MAC spécifiques dans les systèmes sensibles à la sécurité.

• Validation des entrées de formulaires : Assurez-vous que les utilisateurs ne saisissent pas de formats MAC invalides dans les applications web.

Conseils pratiques

• Supprimez toujours les espaces en début et fin de chaîne avant la validation.

• Le regex sert à vérifier le format, pas la légitimité. Une adresse MAC syntaxiquement valide peut ne pas exister réellement.

• Prenez en charge les formats : et - si votre application gère différentes sources.

• Envisagez d'utiliser l'Encodeur base64 pour le stockage ou la transmission sécurisée.

• Utilisez-le en combinaison avec le Générateur de tokens pour attribuer des tokens d'appareils uniques après validation.

Métacaractères JavaScript utilisés

• ^ : Ancre le regex au début de la chaîne.

• $ : Ancre le regex à la fin de la chaîne.

• [0-9A-Fa-f] : Fait correspondre un seul caractère hexadécimal (insensible à la casse).

• {2} : Quantificateur : exactement 2 caractères.

• [:-] : Correspond à ':' ou '-'.

• {5} : Quantificateur : fait correspondre le groupe 5 fois.

• (...) : Groupe capturant.

Exemples d'entrées regex

1. "01:23:45:67:89:AB" : Valide

2. "01-23-45-67-89-AB" : Valide

3. "0123.4567.89AB" : Invalide

4. "G1:23:45:67:89:ZZ" : Invalide

Combinez avec ces outils

• Validateur regex JavaScript pour adresses IP : Pour valider l'identité réseau complète d'un appareil.

• Validateur regex JavaScript pour UUID : Pour valider les identifiants uniques attribués par le système.

• Décodeur base64 : Pour décoder les payloads de données réseau après chiffrement.