标签: regex-greedy

我认为默认情况下我的正则表达式会展示我想要的贪婪行为,但它不在以下代码中:

 Regex keywords = new Regex(@"in|int|into|internal|interface");
 var targets = keywords.ToString().Split('|');
 foreach (string t in targets)
    {
    Match match = keywords.Match(t);
    Console.WriteLine("Matched {0,-9} with {1}", t, match.Value);
    }

输出:

Matched in        with in
Matched int       with in
Matched into      with in
Matched internal  with in
Matched interface with in

现在我意识到,如果我只是按照长度降序对关键字进行排序,我可以让它为这个小例子工作

• 我想知道为什么这不能按预期工作,并且
• 我正在处理的实际项目在正则表达式中有更多的单词,并且按字母顺序保留它们非常重要.

所以我的问题是:为什么这是懒惰的,我该如何解决？

我有一个字符串,正确的语法是正则表达式^([0-9]+[abc])+$.所以有效字符串的例子是:'1a2b'或'00333b1119a555a0c'

为清楚起见,字符串是(值,字母)对的列表,并且顺序很重要.我坚持使用输入字符串,所以我不能改变它.虽然使用上面的正则表达式来测试正确的语法似乎很容易,但我正在尝试考虑PHP中最有效的方法将兼容字符串转换为可用的数组,如下所示:

输入:

'00333b1119a555a0c'

输出:

array (
  0 =>  array('num' => '00333', 'let' => 'b'),
  1 =>  array('num' => '1119', 'let' => 'a'),
  2 =>  array('num' => '555', 'let' => 'a'),
  3 =>  array('num' => '0', 'let' => 'c')
)

我在使用preg_match方面遇到了困难.例如,这没有给出预期的结果,意图是在EITHER\d +上贪婪匹配(并保存)OR [abc](并保存),重复直到到达字符串结尾.

$text = '00b000b0b';
$out = array();
$x = preg_match("/^(?:(\d+|[abc]))+$/", $text, $out);

这也不起作用,这里的意图是在\ d + [abc]上贪婪匹配(并保存这些),重复直到字符串到达​​结束,然后将它们分成数字和字母.

$text = '00b000b0b';
$out = array();
$x = preg_match("/^(?:\d+[abc])+$/", $text, $out);

如果使用需要遍历结果2项在时间我计划检查语法作为的preg_match的一部分,然后使用的preg_match输出到贪婪-匹配"块"(或使用使preg_split保持分隔符如果),然后for (...; i+=2)到在他们的对中提取值字母.

但我似乎无法让基本的preg_split()或preg_match()方法顺利运行,更不用说探索是否有"整洁"或更有效的方法.

我有以下文字

tooooooooooooon

根据我正在阅读的这本书,当?任何量词之后,它变得非贪婪.

我的正则表达式to*?n仍在回归tooooooooooooon.

它应该回归ton不应该吗？

知道为什么吗？

我需要做一场非贪婪的比赛,并希望有人能帮助我.我有以下内容,我使用的是JavaScript和ASP

match(/\href=".*?\/pdf\/.*?\.pdf/)

上面的匹配匹配href标记的第一个开头.我需要它只匹配作为/pdf/文件夹一部分的最后一个href .

有任何想法吗 ？

这种模式:

/a+?b+?/

对于以下字符串:

aaaaaabbbbbb

火柴:

aaaaaab

我们看到非贪婪在向后/向左方向(全部采用)和向前/向右方向(仅采用一个)方面表现不同.

有没有办法让开头的非贪婪,匹配所有a,以尽可能少的匹配？这样它的行为方式与最后的b部分一样吗？

给定一个输入字符串，fooxxxxxxfooxxxboo我正在尝试编写一个匹配的正则表达式，fooxxxboo即从第二个 foo 开始到最后一个 boo。

我尝试了以下

foo.*?boo 匹配完整的字符串 fooxxxxxxfooxxxboo

foo.*boo 也匹配完整的字符串 fooxxxxxxfooxxxboo

我读了这篇Greedy vs. Reluctant vs. Possessive Quantifiers并且我理解它们的区别，但我试图从匹配正则表达式的末尾匹配最短的字符串，即类似于要从后面评估的正则表达式。有什么办法可以只匹配最后一部分？

我有一个应该在字符串中的多个位置匹配的正则表达式模式.我想将所有匹配组放入一个数组中,然后打印每个元素.

所以,我一直在尝试这个:

#!/bin/bash

f=$'\n\tShare1   Disk\n\tShare2  Disk\n\tPrnt1  Printer'
regex=$'\n\t(.+?)\\s+Disk'
if [[ $f =~ $regex ]]
then
    for match in "${BASH_REMATCH[@]}"
    do
        echo "New match: $match"
    done
else
    echo "No matches"
fi

结果:

New match: 
    Share1   Disk
    Share2  Disk
New match: Share1   Disk
    Share2 

预期的结果将是

New match: Share1
New match: Share2

我认为它不起作用,因为我.+?匹配贪婪.所以我查看了如何使用bash正则表达式实现这一点.但是每个人似乎都建议在perl正则表达式中使用grep.

但肯定还有另一种方式.我想的可能是[^\\s]+......但是输出的结果是:

New match: 
    Share1   Disk
New match: Share1

... 有任何想法吗？

我遇到了这个迷你语法的问题,它试图匹配像markdown一样的头部结构.

role Like-a-word {
    regex like-a-word { \S+ }
}

role Span does Like-a-word {
    regex span { <like-a-word>[\s+ <like-a-word>]* } 
}
grammar Grammar::Headers does Span {
    token TOP {^ <header> \v+ $}

    token hashes { '#'**1..6 }

    regex header {^^ <hashes> \h+ <span> [\h* $0]? $$}
}

我希望它匹配## Easier ##为标题,但它##作为一部分span:

TOP
|  header
|  |  hashes
|  |  * MATCH "##"
|  |  span
|  |  |  like-a-word
|  |  |  * MATCH …

我正在尝试编写一种方法来转换字幕文件，以便每个字幕始终只有一个句子。

我的想法如下：

1. 对于每个字幕：

1.1->我得到字幕的持续时间

1.2->计算 characters_per_second

1.3->使用它来存储（里面dict_times_word_subtitle）说单词的时间i

2. 我从全文中提取句子

3. 对于每个句子：

3.1我在（内部dict_sentences_subtitle）存储用特定单词讲句子所花费的时间（从中我可以得到说出来的持续时间）

4. 我创建了一个新的srt文件（字幕文件），该文件与原始srt文件同时启动，然后可以从讲句子的持续时间中获取字幕时间。

现在，我已经编写了以下代码：

#---------------------------------------------------------
import pysrt
import re
from datetime import datetime, date, time, timedelta
#---------------------------------------------------------

def convert_subtitle_one_sentence(file_name):

    sub = pysrt.open(file_name)   

    ### ----------------------------------------------------------------------
    ### Store Each Word and the Average Time it Takes to Say it in a dictionary
    ### ----------------------------------------------------------------------

    dict_times_word_subtitle = {}
    running_variable = 0
    for i in range(len(sub)):

        subtitle_text = sub[i].text
        subtitle_duration = (datetime.combine(date.min, sub[i].duration.to_time()) - datetime.min).total_seconds()

        # Compute …

在Java Pattern类的文档中,我看到确切的量词X{n}有贪婪和不情愿的形式:

贪婪的量词

• X {n} X,正好是n次
• ...

不情愿的量词

• X {N}？X,正好是n次
• ...

文档给出了贪婪和不情愿行为之间差异的一般示例,但没有给出确切量词的任何示例.

起初我想,"好吧,也许差异在于它X本身可以以不同的方式匹配." 但是其中X可以有自己的贪婪/不情愿的说明者,而且我确实测试了它,这不是一个区别(贪婪与不情愿).

鉴于此,在任何一种情况下,它都会完全匹配n,两者的行为之间是否有任何区别？