正则表达式（特定单词除外）

Question

我的正则表达式有问题。 我需要制作正则表达式，但一组指定的单词除外，例如：苹果、橙子、果汁。 给出这些单词，它将匹配除上面单词之外的所有单词。

applejuice (match)
yummyjuice (match)
yummy-apple-juice (match)
orangeapplejuice (match)
orange-apple-juice (match)
apple-orange-aple (match)
juice-juice-juice (match)
orange-juice (match)

apple (should not match)
orange (should not match)
juice (should not match)

Answer 1

如果您确实想使用单个正则表达式来执行此操作，您可能会发现环视很有帮助（尤其是本示例中的负向前瞻）。为 Ruby 编写的正则表达式（某些实现具有不同的环视语法）：

rx = /^(?!apple$|orange$|juice$)/

Answer 2

我注意到 apple-juice 应该根据您的参数进行匹配，但是 apple-juice 呢？我假设如果您正在验证苹果汁，您仍然希望它失败。

因此，让我们构建一组算作“边界”的字符：

/[^-a-z0-9A-Z_]/        // Will match any character that is <NOT> - _ or 
                        // between a-z 0-9 A-Z 

/(?:^|[^-a-z0-9A-Z_])/  // Matches the beginning of the string, or one of those 
                        // non-word characters.

/(?:[^-a-z0-9A-Z_]|$)/  // Matches a non-word or the end of string

/(?:^|[^-a-z0-9A-Z_])(apple|orange|juice)(?:[^-a-z0-9A-Z_]|$)/ 
   // This should >match< apple/orange/juice ONLY when not preceded/followed by another
   // 'non-word' character just negate the result of the test to obtain your desired
   // result.

在大多数正则表达式风格中 \b 算作“单词边界”，但“单词字符”的标准列表不包括 < code>- 因此您需要创建一个自定义的。如果您不想捕获 - ，它也可以与 /\b(apple|orange|juice)\b/ 匹配...

如果您只是测试“单个单词”测试你可以使用更简单的方法：

/^(apple|orange|juice)$/ // and take the negation of this...

Answer 3

这得到了一些方法：

((?:apple|orange|juice)\S)|(\S(?:apple|orange|juice))|(\S(?:apple|orange|juice)\S)

Answer 4

\A(?!apple\Z|juice\Z|orange\Z).*\Z

将匹配整个字符串，除非它仅包含禁用单词之一。

或者，如果您不使用 Ruby，或者您确定您的字符串不包含换行符，或者您设置了 ^ 和 $ 在开头不匹配的选项/ 行尾

^(?!apple$|juice$|orange$).*$

也可以。

Answer 5

下面是一些简单的复制粘贴代码，它们不仅仅适用于精确单词异常。

复制/粘贴代码：

在以下正则表达式中，仅将全部大写部分替换为您的正则表达式。

Python regex

pattern = r"REGEX_BEFORE(?>(?P<exceptions_group_1>EXCEPTION_PATTERN)|YOUR_NORMAL_PATTERN)(?(exceptions_group_1)always(?<=fail)|)REGEX_AFTER"

Ruby regex

pattern = /REGEX_BEFORE(?>(?<exceptions_group_1>EXCEPTION_PATTERN)|YOUR_NORMAL_PATTERN)(?(<exceptions_group_1>)always(?<=fail)|)REGEX_AFTER/

PCRE regex

REGEX_BEFORE(?>(?<exceptions_group_1>EXCEPTION_PATTERN)|YOUR_NORMAL_PATTERN)(?(exceptions_group_1)always(?<=fail)|)REGEX_AFTER

JavaScript

截至 2020 年 6 月 17 日，这是不可能的，并且在不久的将来可能也不会实现。

完整示例

REGEX_BEFORE = \b
YOUR_NORMAL_PATTERN = \w+
REGEX_AFTER =
EXCEPTION_PATTERN = (苹果|橙子|果汁)

Python regex

pattern = r"\b(?>(?P<exceptions_group_1>(apple|orange|juice))|\w+)(?(exceptions_group_1)always(?<=fail)|)"

Ruby regex

pattern = /\b(?>(?<exceptions_group_1>(apple|orange|juice))|\w+)(?(<exceptions_group_1>)always(?<=fail)|)/

PCRE regex

\b(?>(?<exceptions_group_1>(apple|orange|juice))|\w+)(?(exceptions_group_1)always(?<=fail)|)

它是如何工作的？

它使用相当复杂的正则表达式，即原子组、条件、后向查找和命名组。

1. (?> 是原子组的开始，这意味着它不允许回溯：这意味着，如果该组匹配一次，但随后由于回溯失败而失效，那么整个组将无法匹配。（在这种情况下我们希望这种行为）。

2. 。 exceptions_group_1> 创建一个命名捕获组。请注意，该模式首先尝试查找异常，如果找不到异常，则返回到正常模式。

3. 请注意，原子模式首先尝试查找异常，如果找不到异常，则返回到正常模式。

   请注意，

4. 真正的魔力在于(?(exceptions_group_1)。这是一个条件询问exceptions_group_1是否成功匹配。如果是，那么它会尝试查找always(? <=fail)。该模式（正如它所说的）总是会失败，因为它寻找单词“always”，然后检查“does“ways”==“fail””，而它永远不会失败。 .

5. 因为条件失败，这意味着原子组失败，并且因为它是原子的，这意味着它不允许回溯（尝试寻找正常模式），因为它已经匹配了异常。

这绝对不是这些工具的预期用途，但它应该可靠且高效地工作。

Ruby 中原始问题的准确答案

/\b(?>(?<exceptions_group_1>(apple|orange|juice))|\w+)(?(<exceptions_group_1>)always(?<=fail)|)/

与其他方法不同，可以修改此方法以拒绝任何模式，例如不包含子字符串“apple”、“orange”或“juice”的任何单词。

/\b(?>(?<exceptions_group_1>\w*(apple|orange|juice))|\w+)(?(<exceptions_group_1>)always(?<=fail)|)/

Answer 6

类似（PHP）的东西

$input = "The orange apple gave juice";
if(preg_match("your regex for validating") && !preg_match("/apple|orange|juice/", $input))
{
  // it's ok;
}
else
{
  //throw validation error
}