Question

验证用户输入的MAC地址的最佳方法是什么？

格式为HH:HH:HH:HH:HH:HH，其中每个H都是十六进制字符。

例如，00:29:15:80:4E:4A有效，而00:29:804E4A无效。

Answer 1

如果你只是语法，那么这个正则表达式应该适合你

import re
...
if re.match("[0-9a-f]{2}([-:]?)[0-9a-f]{2}(\\1[0-9a-f]{2}){4}$", x.lower()):
    ...

它接受带有:或-的12个十六进制数字，或者不作为对之间的分隔符（但分隔符必须是统一的...要么所有分隔符都是:，要么全部为{ {1}}或没有分隔符。）

这是解释：

-表示十六进制数字
[0-9a-f]表示我们想要其中两个
{2}表示短划线或冒号，但可选。请注意，短划线第一个字符不表示范围，而只表示自身。此子表达式括在括号中，以便以后可以重用作后向引用。
[-:]?是另一对十六进制数字
[0-9a-f]{2}这意味着我们希望将之前匹配的相同表达式匹配为分隔符。这就是保证一致性的原因。请注意，regexp语法是\\1，但我使用的是常规字符串，因此反斜杠必须通过加倍来转义。
\1另一对十六进制数字
[0-9a-f]{2}上一个带括号的块必须重复4次，总共有6对数字：{4}
<pair> [<sep>] <pair> ( <same-sep> <pair> ) * 4字符串必须在它们之后结束

请注意，在Python $中，只检查从字符串的开头开始，因此不需要在开头re.match。

Answer 2

我讨厌强迫用户思考计算机的程序。

通过接受任何有效格式使其更友好。

剥离分隔符，无论它是什么，然后获取剩下的十六进制值。这样，如果用户输入破折号或空格，它也可以。

import string
allchars = "".join(chr(a) for a in range(256))
delchars = set(allchars) - set(string.hexdigits)

def checkMAC(s):
  mac = s.translate("".join(allchars),"".join(delchars))
  if len(mac) != 12:
      raise ValueError, "Ethernet MACs are always 12 hex characters, you entered %s" % mac 
  return mac.upper()


checkMAC("AA:BB:CC:DD:EE:FF")
checkMAC("00-11-22-33-44-66")
checkMAC("1 2 3 4 5 6 7 8 9 a b c")
checkMAC("This is not a mac")

Answer 3

如果你想确保整个但不是两者都有' - '或'：'，你可以在Python中使用以下内容：

import re

def is_valid_macaddr802(value):
    allowed = re.compile(r"""
                         (
                             ^([0-9A-F]{2}[-]){5}([0-9A-F]{2})$
                            |^([0-9A-F]{2}[:]){5}([0-9A-F]{2})$
                         )
                         """,
                         re.VERBOSE|re.IGNORECASE)

    if allowed.match(value) is None:
        return False
    else:
        return True

Answer 4

这就像一个魅力。

def isMAC48Address(inputString):
    if inputString.count(":")!=5:
        return False
    for i in inputString.split(":"):
        for j in i:
            if j>"F" or (j<"A" and not j.isdigit()) or len(i)!=2:
                return False
    return True

Answer 5

private static final String MAC_PATTERN = "^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$";

private boolean validateMAC(final String mac){          
          Pattern pattern = Pattern.compile(MAC_PATTERN);
          Matcher matcher = pattern.matcher(mac);
          return matcher.matches();             
    }

Answer 6

短划分的MAC地址还可以包含＆＃39; 01 - ＆＃39; prefix，指定它是以太网MAC地址（不是令牌环，例如......谁使用令牌环？）。

这里的内容有些完整且易于以合乎逻辑的步进方式阅读：

def IsMac(S):
  digits = S.split(':')
  if len(digits) == 1:
    digits = S.split('-')
    if len(digits) == 7:
      if digits[0] != '01':
        return False
      digits.pop(0)
  if len(digits) != 6:
    return False
  for digit in digits:
    if len(digit) != 2:
      return False
    try:
      int(digit, 16)
    except ValueError:
      return False
  return True


for test in ('01-07-09-07-b4-ff-a7',  # True
                '07:09:07:b4:ff:a7',  # True
                '07-09-07-b4-GG-a7',  # False
                 '7-9-7-b4-F-a7',     # False
                 '7-9-7-b4-0xF-a7'):  # False
  print test, IsMac(test)

Answer 7

import re

def MacValidator(inputMacList):
    def MacParser(mac):
        octets = re.split('[\:\-]', mac)
        if len(octets) != 6:
            return False
        for i in octets:
            try:
                if int(i, 16) > 255:
                    return False
            except:
                return False
        return mac

    return [i.upper() for i in inputMacList if MacParser(i) != False]

macList = ["00-15-F2-20-4D-6B", "Kozel", "00:13:aa:00:00:01",
           "00:13:AA:00:tr:01", "00-01-01-20-55-55", "00-01-01-20abc-55"]

validMacList = MacValidator(macList)

Answer 8

我作弊并使用了其他人提交的多个答案的组合。我认为这是非常明确和直接的一个班轮。 mac_validation应该返回True或False。

import re
mac_validation = bool(re.match('^' + '[\:\-]'.join(['([0-9a-f]{2})']*6) + '$', mac_input.lower()))

Answer 9

此正则表达式验证以下MAC格式

"Ae:Bd:00:00:00:00"
"00-00-00-00-00-00"
"aaaa.bbbb.cccc"

private static final String MAC_PATTERN = "(([0-9A-Fa-f]{2}[-:.]){5}[0-9A-Fa-f]{2})|(([0-9A-Fa-f]{4}\\.){2}[0-9A-Fa-f]{4})";

public class MacRegExp {

    private static final String MAC_PATTERN = "(([0-9A-Fa-f]{2}[-:.]){5}[0-9A-Fa-f]{2})|(([0-9A-Fa-f]{4}\\.){2}[0-9A-Fa-f]{4})";

    static boolean validateMAC(final String mac){          
        Pattern pattern = Pattern.compile(MAC_PATTERN);
        Matcher matcher = pattern.matcher(mac);
        return matcher.matches();             
    }

}

希望这有帮助

Answer 10

#Just works Perfect
#validate the MAC addr

#!/usr/bin/python
import re

mac = "01-3e-4f-ee-23-af"

result = re.match(r"([0-9a-fA-F]{2}[-:]){5}[0-9a-fA-F]{2}$",mac)

if result:
    print ("Correct MAC")
else:
    print ("Incorrect MAC")

Answer 11

let globalReaction;
// DOMSubtreeModified fired, globalReaction is set

let spam;
spam = setInterval(() => {
    if (globalReaction) {
        globalReaction.click();
    }
}, 50);

如何验证MAC地址的格式？

11 个答案: