用 RegEx 重写 IsHexString 方法

Question

我有一个方法检查 字符串是否 有效的十六进制字符串：

public bool IsHex(string value)
{
  if (string.IsNullOrEmpty(value) || value.Length % 2 != 0)
    return false;

  return 
    value.Substring(0, 2) == "0x" &&
    value.Substring(2)
      .All(c => (c >= '0' && c <= '9') ||
                (c >= 'a' && c <= 'f') ||
                (c >= 'A' && c <= 'F'));
}

规则是：
表达式必须由偶数个十六进制数字（0-9、AF、af）组成。
字符0x必须是前两个表达式中的字符。

我确信它可以用正则表达式重写，以更简洁、更有效的方式。
你能帮我解决这个问题吗？

Answer 1

所以，基本上你想检查数字是否以0x 开头并以0-9 和/或A-F 的（非空）序列继续。这可以很容易地指定为正则表达式：

return RegEx.IsMatch(value, "^0x[0-9A-Fa-f]+$")

我不知道你为什么要检查value.Length % 2 != 0...“0x1”不是一个有效的十六进制数字吗？此外，我的函数在"0x" 上返回false，而您的函数将返回true。如果您想更改它，请将正则表达式中的 +（= 一个或多个）替换为 *（= 零个或多个）。

编辑：既然您已经证明了您的“偶数”要求，我建议您使用 Abel 的 RegEx。如果你这样做，我建议你调用你的方法IsMsSqlHex 或类似的东西来证明它不遵循“通常的”十六进制规则。

Answer 2

更新问题后，适合您的新正则表达式应该是：

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

我使用(?: 进行非捕获分组以提高效率。 {2} 表示您想要两个前面的表达式（即两个十六进制字符），+ 表示您想要一个或多个十六进制字符。请注意，这不允许将 0x 作为有效值。

效率

“Oded”提到了效率。我不知道你的要求，所以我认为这比其他任何事情都更能锻炼大脑。只要最小的匹配正则表达式，正则表达式就会飞跃。例如，在 10,000 个大小为 50-5000 个字符的可变输入字符串上尝试我自己的正则表达式，全部正确，它在 1.1 秒内运行。

当我尝试以下正则表达式时：

^0x(?:[0-9A-Fa-f]{32})+(?:[0-9A-Fa-f]{2})+$

在 0.67 秒内，它的运行速度提高了约 40%。但小心点。了解您的输入就是了解如何编写高效的正则表达式。例如，如果正则表达式失败，它将进行大量回溯。如果我的一半输入字符串的长度不正确，对于相同的输入，运行时间会激增到大约 34 秒或 3000% (!)。

如果大多数输入字符串都很大，这将变得更加棘手。如果 99% 的输入都是有效长度，那么所有字符都是 > 4130 个字符，只有少数不是，写

^0x(?:[0-9A-Fa-f]{4096})+^0x(?:[0-9A-Fa-f]{32})+(?:[0-9A-Fa-f]{2})+$

效率更高，更能节省时间。但是，如果许多人的length % 2 = 0 不正确，则由于回溯，这会适得其反。

最后，如果你的大多数字符串都满足偶数规则，并且只有部分或多个字符串包含错误字符，那么速度就会提高：包含错误字符的输入越多，性能就越好。也就是说，因为当它发现一个无效字符时，它可以立即爆发。

结论：如果您的输入混合了小、大、错误字符、错误计数，您最快的方法是使用检查字符串长度（在 .NET 中为瞬时）和使用高效正则表达式的组合。

Answer 3

谩骂：如果您完全关心速度，请忘记正则表达式。正则表达式是 NFA，因此在大多数情况下，它比 DFA 或手写解析器慢。

忽略您在这里要求使用正则表达式可能会更有效（即使您的实现可能很好 - 它确实分配了字符串）：

static bool IsHex(string value)
{
    if (string.IsNullOrEmpty(value) || value.Length < 3)
        return false;

    const byte State_Zero = 0;
    const byte State_X = 1;
    const byte State_Value = 2;

    var state = State_Zero;

    for (var i = 0; i < value.Length; i++)
    {
        switch (value[i])
        {
            case '0': 
                {
                    // Can be used in either Value or Zero.
                    switch (state)
                    {
                        case State_Zero: state = State_X; break;
                        case State_X: return false;
                        case State_Value: break;
                    }
                }
                break;
            case 'X': case 'x': 
                {
                    // Only valid in X.
                    switch (state)
                    {
                        case State_Zero: return false;
                        case State_X: state = State_Value; break;
                        case State_Value: return false;
                    }
                }
                break;
            case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
            case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
            case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
                {
                    // Only valid in Value.
                    switch (state)
                    {
                        case State_Zero: return false;
                        case State_X: return false;
                        case State_Value: break;
                    }
                }
                break;
            default: return false;
        }
    }

    return state == State_Value;
}

如果我能正确了解您想要实现的目标，那么此功能可能会更好地满足您的需求：

static bool ParseNumber(string value, out int result)
{
    if (string.IsNullOrEmpty(value))
    {
        result = 0;
        return false;
    }

    if (value.StartsWith("0x"))
        return int.TryParse(value.Substring(2), NumberStyles.AllowHexSpecifier, null, out result);
    else
        return int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
}

只是为了好玩I went and profiled:

• Abel's Regex 没有 static readonly 缓存为 I described on Heinzi's answer。
• 带有static readonly 缓存的Abel 正则表达式。
• 我的实现。

我的笔记本电脑上的结果（发布/无调试器）：

• 没有编译/缓存的正则表达式 正则表达式耗时 8137 毫秒（2 倍缓存，20 倍手写）
• 带有已编译/缓存的 Regex 的 Regex 耗时 3463 毫秒（8 倍手写）
• 手写耗时 397 毫秒 (1x)