Regex 处理数字序列的复杂正则表达式

您好，我已经达到了一个困难的正则表达式来处理，我有非常有限的知识。如果有人能让我理解如何解释这样的问题，那就太好了：

说明： 给定一个数字串，如

1234567

，我必须拿出一个正则表达式，将结果输出为：

12
23
34
45
56
67

---

我不是要一个直接的解决方案，而是要一个指导方针。regex不会输出任何东西，它会找到匹配的文本。我猜你的“输出”实际上是所有匹配项的列表

---

因此，您需要一个正则表达式来查找搜索文本中的所有数字对

正则表达式不会输出任何东西，它会找到匹配的文本。我猜你的“输出”实际上是所有匹配项的列表

---

因此，您需要一个正则表达式来查找搜索文本中的所有数字对

正则表达式不会输出任何东西，它会找到匹配的文本。我猜你的“输出”实际上是所有匹配项的列表

---

因此，您需要一个正则表达式来查找搜索文本中的所有数字对

正则表达式不会输出任何东西，它会找到匹配的文本。我猜你的“输出”实际上是所有匹配项的列表

---

因此，您需要一个正则表达式来查找搜索文本中的所有数字对

您没有说明您使用的是哪种语言，但我假设它支持正向前瞻-大多数都支持

下面是一个Java解决方案：

public static void main(final String[] args) throws Exception {
    final String in = "1234567";
    final Pattern patt = Pattern.compile("(?=(\\d{2})).");
    final Matcher matcher = patt.matcher(in);
    while (matcher.find()) {
        System.out.println(matcher.group(1));
    }
}

输出：

12
23
34
45
56
67

模式是

（？=（\d{2}））。

（出于语言语法原因，您需要Java中的

\\

）

说明：

• （？=（\d{2}））

  这是解决方案的核心，而且有点棘手，它是一个正向前瞻断言，用于检查输入

  字符串中当前点之后的两位数字。然后它抓取这两个数字——这就是“输出”的来源

• 这匹配任何字符（也可以是

  \d

  ，但这不是必需的）。这确保了正则表达式引擎一次只能沿一个空间移动

因此，最初引擎作为

字符串的开始。断言捕获
12
，
捕获并使用
1
。现在引擎在
1
之后，断言捕获
23
，而
捕获并消耗
2
。等等

诀窍在于断言一次捕获两个字符，而模式一次只前进一个字符

此一行程序进行替换而不是搜索-在Java中，
字符串
是不可变的，因此结果实际上是不同的
字符串
-操作不会修改

中的

字符串：

public static void main(final String[] args) throws Exception {
    System.out.println("1234567".replaceAll("(?=(\\d{2})).(?=\\d{2})", "$1\n"));
}

这里我们需要添加另一个断言，即在这个数字之后至少还有两个数字需要使用。输出：

12
23
34
45
56
67

您没有说明您使用的是哪种语言，但我假设它支持积极的前瞻性—大多数都支持

下面是一个Java解决方案：

public static void main(final String[] args) throws Exception {
    final String in = "1234567";
    final Pattern patt = Pattern.compile("(?=(\\d{2})).");
    final Matcher matcher = patt.matcher(in);
    while (matcher.find()) {
        System.out.println(matcher.group(1));
    }
}

输出：

12
23
34
45
56
67

模式是
（？=（\d{2}））。
（出于语言语法原因，您需要Java中的
\\
）

说明：


（？=（\d{2}））
这是解决方案的核心，而且有点棘手，它是一个正向前瞻断言，用于检查输入
字符串中当前点之后的两位数字。然后它抓取这两个数字——这就是“输出”的来源

这匹配任何字符（也可以是
\d
，但这不是必需的）。这确保了正则表达式引擎一次只能沿一个空间移动

因此，最初引擎作为
字符串的开始。断言捕获
12
，
捕获并使用
1
。现在引擎在
1
之后，断言捕获
23
，而
捕获并消耗
2
。等等

诀窍在于断言一次捕获两个字符，而模式一次只前进一个字符

此一行程序进行替换而不是搜索-在Java中，
字符串
是不可变的，因此结果实际上是不同的
字符串
-操作不会修改
中的
字符串：

public static void main(final String[] args) throws Exception {
    System.out.println("1234567".replaceAll("(?=(\\d{2})).(?=\\d{2})", "$1\n"));
}

这里我们需要添加另一个断言，即在这个数字之后至少还有两个数字需要使用。输出：

12
23
34
45
56
67

您没有说明您使用的是哪种语言，但我假设它支持积极的前瞻性—大多数都支持

下面是一个Java解决方案：

public static void main(final String[] args) throws Exception {
    final String in = "1234567";
    final Pattern patt = Pattern.compile("(?=(\\d{2})).");
    final Matcher matcher = patt.matcher(in);
    while (matcher.find()) {
        System.out.println(matcher.group(1));
    }
}

输出：

12
23
34
45
56
67

模式是
（？=（\d{2}））。
（出于语言语法原因，您需要Java中的
\\
）

说明：


（？=（\d{2}））
这是解决方案的核心，而且有点棘手，它是一个正向前瞻断言，用于检查输入
字符串中当前点之后的两位数字。然后它抓取这两个数字——这就是“输出”的来源

这匹配任何字符（也可以是
\d
，但这不是必需的）。这确保了正则表达式引擎一次只能沿一个空间移动

因此，最初引擎作为
字符串的开始。断言捕获
12
，
捕获并使用
1
。现在引擎在
1
之后，断言捕获
23
，而
捕获并消耗
2
。等等

诀窍在于断言一次捕获两个字符，而模式一次只前进一个字符

这艘班轮可以