blocks|key|1437180|text|不，它们是不同的。%5E.{2,}?$匹配长度至少为2(as+seen+on+rubular.com)的字符串：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1437181|12
123
1234|code-block|syntax|javascript|1437182|相比之下，%5E.{2}$只匹配长度恰好为2+(as+seen+on+rubular.com)的字符串。|1437183|由于不情愿，.{2,}?将首先尝试只匹配两个字符，这是正确的。但要使整体模式匹配，可能需要更多时间。但.{2}并非如此，它只能匹配2个字符。|1437184|参考文献|1437185|1437186|regular-expressions.info/Repetition|unordered-list-item|1437187|1437188|相关问题|1437189|1437190|Difference+between+.*?+and+.*+for+regex|1437191|1437192|entityMap|0|LINK|mutability|MUTABLE|url|http://www.rubular.com/r/VYxE6xCSsp|1|http://www.rubular.com/r/EFhrDMp2u3|2|http://www.regular-expressions.info/repeat.html|3|https://stackoverflow.com/questions/3075130/difference-between-and-for-regex/3075532#3075532^0|9|8|Q|M|0|0|0|5|6|M|M|1|0|6|6|1F|4|0|0|0|0|Z|2|0|0|0|0|J|3|R|2|0|13|3|0|0^^$0|@$1|2|3|4|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@$9|1I|A|1J|1|1K]]|E|$]]|$1|F|3|G|5|H|7|1L|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1M|8|@$9|1N|A|1O|B|C]]|D|@$9|1P|A|1Q|1|1R]]|E|$]]|$1|M|3|N|5|6|7|1S|8|@$9|1T|A|1U|B|C]|$9|1V|A|1W|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1X|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1Y|8|@]|D|@]|E|$]]|$1|R|3|S|5|T|7|1Z|8|@]|D|@$9|20|A|21|1|22]]|E|$]]|$1|U|3|-4|5|6|7|23|8|@]|D|@]|E|$]]|$1|V|3|W|5|6|7|24|8|@]|D|@]|E|$]]|$1|X|3|-4|5|6|7|25|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|T|7|26|8|@$9|27|A|28|B|C]|$9|29|A|2A|B|C]]|D|@$9|2B|A|2C|1|2D]]|E|$]]|$1|10|3|-4|5|6|7|2E|8|@]|D|@]|E|$]]|$1|11|3|-4|5|6|7|2F|8|@]|D|@]|E|$]]]|12|$13|$5|14|15|16|E|$17|18]]|19|$5|14|15|16|E|$17|1A]]|1B|$5|14|15|16|E|$17|1C]]|1D|$5|14|15|16|E|$17|1E]]]]

No, they are different. <code>^.{2,}?$</code> matches strings whose length is at least 2 (<a href="http://www.rubular.com/r/VYxE6xCSsp" rel="nofollow noreferrer">as seen on rubular.com</a>):

<pre><code>12
123
1234
</code></pre>

By contrast, <code>^.{2}$</code> only matches strings whose length is exactly 2 (<a href="http://www.rubular.com/r/EFhrDMp2u3" rel="nofollow noreferrer">as seen on rubular.com</a>).

It's correct that being reluctant, <code>.{2,}?</code> will first attempt to match only two characters. But for the overall pattern to match, it can take more. This is not the case with <code>.{2}</code>, which can only match exactly 2 characters.

<h3>References</h3>

<ul>
<li><a href="http://www.regular-expressions.info/repeat.html" rel="nofollow noreferrer">regular-expressions.info/Repetition</a></li>
</ul>

<h3>Related questions</h3>

<ul>
<li><a href="https://stackoverflow.com/questions/3075130/difference-between-and-for-regex/3075532#3075532">Difference between <code>.*?</code> and <code>.*</code> for regex</a></li>
</ul>

blocks|key|1437147|text|不是的。{2,}指的是两次或更多，而{2}指的是两次。默认情况下，量词是贪婪的，因此如果使用.{2,}，则给定字符串foo，则会得到foo；如果使用.{2,}?，则会得到fo，因为您将其设为惰性。但是，如有必要，允许后者匹配两次以上，但.{2}始终表示恰好两个字符。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1437148|因此，如果您有字符串test123和模式.{2,}?\d，您将得到test1，因为它必须匹配最多四个字符，以便\d也可以匹配。|1437149|entityMap^0|4|4|I|3|1A|5|1M|3|1U|3|22|6|2D|2|3A|4|0|A|7|K|8|X|5|1J|2|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|I|$]]

No. <code>{2,}</code> means two times or more while <code>{2}</code> means exactly two times. Quantifiers are greedy by default, so given the string <code>foo</code> you would get <code>foo</code> if you use <code>.{2,}</code>, but <code>fo</code> if you use <code>.{2,}?</code> because you made it lazy. However, the latter is allowed to match more than two times if necessary, but <code>.{2}</code> always means exactly two characters.

So if you have the string <code>test123</code> and the pattern <code>.{2,}?\d</code>, you would get <code>test1</code> because it has to match up to four characters so the <code>\d</code> can also match.

blocks|key|3758972|text|在孤立的情况下，它们的行为可能是相同的，但在较大的表达式中不是这样的，因为惰性版本允许匹配两个以上的符号。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3758973|+++++++++++++abx++++++++abcx

%5E.{2,}?x$++++match++++++match
%5E.{2}x$++++++match++++++no+match|code-block|syntax|javascript|3758974|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In isolation they probably behave identical but not inside larger expressions because the lazy version is allowed to match more than two symbols.

<pre><code> abx abcx

^.{2,}?x$ match match
^.{2}x$ match no match
</code></pre>

blocks|key|1437268|text|让这个问题特别有趣的是，有时.{2,}?等同于.{2}，但这种情况永远不会发生。其他人已经指出，正则表达式末尾的不情愿的量词总是与最小字符数匹配，因为在它之后没有任何东西可以强迫它消耗更多的字符。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1437269|另一个不应该使用它们的地方是在atomic+group内子表达式的末尾。例如，假设您尝试将foo+bar与|1437270|f(?>.%2B?)+bar|code-block|syntax|javascript|1437271|子表达式最初使用第一个'o‘，然后转到下一个部分，该部分尝试匹配空格，但未成功。如果没有原子组，它就会走回头路，让.%2B?使用另一个字符。但它不能回溯到原子组，并且在组之前没有回旋余地，因此匹配尝试失败。|1437272|正则表达式末尾或原子子表达式末尾的不情愿的量词是明确的代码气味。|1437273|entityMap|0|LINK|mutability|MUTABLE|url|http://www.regular-expressions.info/atomic.html^0|E|6|N|4|0|19|7|F|C|0|0|0|1L|3|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@$9|16|A|17|1|18]]|E|$]]|$1|H|3|I|5|J|7|19|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1D|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

What makes this question especially interesting is that there are times when <code>.{2,}?</code> is equivalent to <code>.{2}</code>, but it should never happen. Others have already pointed out how a reluctant quantifier at the very end of a regex always matches the minimum number of of characters because there's nothing after it to force it to consume more. 

The other place they shouldn't be used is at the end of a subexpression inside an <a href="http://www.regular-expressions.info/atomic.html" rel="nofollow noreferrer">atomic group</a>. For example, suppose you try to match <code>foo bar</code> with 

<pre><code>f(?&gt;.+?) bar
</code></pre>

The subexpression initially consumes the first 'o' and hands off to the next part, which tries unsuccessfully to match a space. Without the atomic group, it would backtrack and let the <code>.+?</code> consume another character. But it can't backtrack into the atomic group, and there's no wiggle room before the group, so the match attempt fails.

A reluctant quantifier at the end of a regex or at end of an atomic subexpression is definite code smell.

blocks|key|691955|text|并不完全使用PHP来执行regexp匹配并显示捕获|type|unstyled|depth|inlineStyleRanges|entityRanges|data|691956|$string+=+'aaabbaabbbaaa';

$search+=+preg_match_all('/b{2}a/',$string,$matches,PREG_SET_ORDER+);

echo+'<pre>';
var_dump($matches);
echo+'</pre>';

$search+=+preg_match_all('/b{2,}?a/',$string,$matches,PREG_SET_ORDER+);

echo+'<pre>';
var_dump($matches);
echo+'</pre>';|code-block|syntax|javascript|691957|第一个结果是：|691958|array(2)+{
++[0]=>
++array(1)+{
++++[0]=>
++++string(3)+"bba"
++}
++[1]=>
++array(1)+{
++++[0]=>
++++string(3)+"bba"
++}
}|691959|第二个给予：|691960|array(2)+{
++[0]=>
++array(1)+{
++++[0]=>
++++string(3)+"bba"
++}
++[1]=>
++array(1)+{
++++[0]=>
++++string(4)+"bbba"
++}
}|691961|对于b{2}，捕获仅返回2个b，对于b{2，}，它返回2个或更多|691962|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Not exactly
Using PHP to do a regexp match and display the capture

<pre><code>$string = 'aaabbaabbbaaa';

$search = preg_match_all('/b{2}a/',$string,$matches,PREG_SET_ORDER );

echo '&lt;pre&gt;';
var_dump($matches);
echo '&lt;/pre&gt;';

$search = preg_match_all('/b{2,}?a/',$string,$matches,PREG_SET_ORDER );

echo '&lt;pre&gt;';
var_dump($matches);
echo '&lt;/pre&gt;';
</code></pre>

First result gives:

<pre><code>array(2) {
 [0]=&gt;
 array(1) {
 [0]=&gt;
 string(3) "bba"
 }
 [1]=&gt;
 array(1) {
 [0]=&gt;
 string(3) "bba"
 }
}
</code></pre>

second gives:

<pre><code>array(2) {
 [0]=&gt;
 array(1) {
 [0]=&gt;
 string(3) "bba"
 }
 [1]=&gt;
 array(1) {
 [0]=&gt;
 string(4) "bbba"
 }
}
</code></pre>

With b{2} the capture only returns 2 b's, with b{2,} it returns 2 or more

blocks|key|1437219|text|x.{2,}?x与"xasdfxbx"中的"xasdfx"匹配，但x.{2}x根本不匹配。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1437220|如果没有尾随的?，第一个将匹配整个字符串。|1437221|entityMap^0|0|8|9|A|L|8|X|6|0|7|1|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|I|$]]

<code>x.{2,}?x</code> matches <code>"xasdfx"</code> in <code>"xasdfxbx"</code> but <code>x.{2}x</code> does not match at all. 

Without the trailing <code>?</code>, the first one will match the whole string.

blocks|key|3759042|text|不，它们是不同的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3759043|.{2,}?：任意字符，至少2次重复，尽可能少|offset|length|style|CODE|3759044|.{2}：任意字符，恰好2次重复|3759045|entityMap^0|0|0|6|0|0|4|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|K|$]]

No, they are different :

<code>.{2,}?</code> : Any character, at least 2 repetitions, as few as possible

<code>.{2}</code> : Any character, exactly 2 repetitions

-edit- NOTE the <code>?</code> at the end of <code>.{2,}?</code>

I found out you can write

<pre><code>.{2,}?
</code></pre>

Isnt that exactly the same as below?

<pre><code>.{2}
</code></pre>

`regex{n,}?` == `regex{n}`?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

-编辑-请注意.{2,}?末尾的?我发现你可以写.{2,}?这不是和下面的完全一样吗？.{2}

问` `regex{n，}?` == ` `regex{n}`？
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问` `regex{n，}?` == ` `regex{n}`？EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问` `regex{n，}?` == ` `regex{n}`？
EN