blocks|key|3985903|text|为什么只使用正则表达式来检查数字？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3985904|int+n+=+-2000;

if(n+>=+-2055+&&+n+<=+2055)
//Do+something
else
//Do+something+else|code-block|syntax|javascript|3985905|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|$]]

Why use Regex only to check a number?

<pre><code>int n = -2000;

if(n &gt;= -2055 &amp;&amp; n &lt;= 2055)
//Do something
else
//Do something else
</code></pre>

blocks|key|5403617|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5403618|\-?\b0*(205[0-5]%7C20[0-4]\d%7C1?\d{3}%7C\d{1,2})\b|code-block|syntax|javascript|5403619|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|$]]

Try this:

<pre><code>\-?\b0*(205[0-5]|20[0-4]\d|1?\d{3}|\d{1,2})\b
</code></pre>

blocks|key|1555859|text|作为aliteralmind提供的伟大表达式的另一种方法，这里有一个更长但有趣的方法，以便了解另一种方法可能像(以及不应该做什么)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1555860|这是一个有趣的练习，因为您可以考虑两个不同的方法：大致上，您可以：|1555861|1555862|先匹配4个字符的数字，然后匹配3个字符的数字等。|ordered-list-item|1555863|或匹配千位数字，然后匹配百位数字，依此类推。|1555864|1555865|如果不尝试，你怎么知道哪一个是最好的呢？事实证明，第一种方法(aliteralmind的答案)要经济得多。|1555866|下面，我在PHP语言中包含了一系列测试，以防您或其他人想要检查输出。|1555867|下面，我将给出“自由空格模式”的正则表达式，它允许在正则表达式中添加注释，这样您就可以很容易地理解它的作用。然而，并不是所有的正则表达式引擎都支持自由空格模式，所以在我们开始讨论有趣的部分之前，这里先将正则表达式作为一行代码。|1555868|请注意，您的问题提到了从-2055到2055的数字。我假设你想要匹配“正态数”，没有前导零。这意味着正则表达式将匹配999，但不匹配0999。如果您想要前导零，请让我知道，这是一个非常容易的调整。|1555869|此外，如果您在utf-8模式下进行匹配，则应该用[0-9]替换\d。这是更常见的形式。|CODE|1555870|将正则表达式作为一行程序进行|1555871|%5E(?!-0$)-?(?:(?=\d{4}$)[12])?(?:(?=\d{3}$)(?:(?:(?<=%5E)%7C(?<=%5E-)%7C(?<=1)%7C(?<=-1))\d%7C(?:(?<=2)%7C(?<=-2))0))?(?:(?=\d{2}$)(?:(?:(?<=%5E)%7C(?<=%5E-)%7C(?<=%5E\d)%7C(?<=%5E-\d)%7C(?<=%5E\d{2})(?<!20)%7C(?<=%5E-\d{2})(?<!-20))\d%7C(?:(?<=20)%7C(?<=-20))[0-5]))?(?:(?=\d$)(?:(?:(?<=%5E)%7C(?<=%5E-)%7C(?<=%5E\d)%7C(?<=%5E-\d)%7C(?<=%5E\d{2})%7C(?<=%5E-\d{2})%7C(?<=%5E\d{3})(?<!205)%7C(?<=%5E-\d{3})(?<!-205))\d%7C(?:(?<=205)%7C(?<=-205))[0-5]))$|code-block|syntax|javascript|1555872|在自由间距模式中正则表达式|1555873|(?x)++++++++++++++++#+free-spacing+mode
%5E+++++++++++++++++++#+anchor+at+beginning+of+string.
(?!-0$)-?+++++++++++#+optional+minus+sign,+but+not+for+-0

(?:+++++++++++++++++#+OPTIONAL+THOUSANDS+DIGIT
(?=\d{4}$)[12]++++++#+assert+that+the+number+is+4-digit+long,+match+1+or+2
)?++++++++++++++++++#+end+optional+thousands+digit


(?:+++++++++++++++++#+OPTIONAL+HUNDREDS+DIGIT
(?=\d{3}$)++++++++++#+assert+that+there+are+three+digits+left
(?:+++++++++++++++++#+non-capturing+group
++(?:(?<=%5E)%7C(?<=%5E-)%7C(?<=1)%7C(?<=-1))\d++++#+if+preceding+chars+are+1,+-1+or+head+of+string:+value+can+be+any+digit
++%7C++++++++++++++++++++++#+or
++(?:(?<=2)%7C(?<=-2))0++++++++++++++++#+if+preceding+chars+are+2+or+-2:+value+must+be+0
)+++++++++++++++++++#+close+non-capturing+group
)?++++++++++++++++++#+end+optional+hundreds+digits

(?:+++++++++++++#+OPTIONAL+TENS+DIGIT
(?=\d{2}$)++++++#+assert+that+there+are+two+digits+left
(?:+++++++++++++#+start+non-capturing+group

++++++++++++++++#+if+preceding+char+is+head+of+string,+single+digit,
++++++++++++++++#+or+two+digits+that+are+not+20
++++++++++++++++#+(with+or+without+a+minus)
++++++++++++++++#+value+can+be+any+digit
++(?:(?<=%5E)%7C(?<=%5E-)%7C(?<=%5E\d)%7C(?<=%5E-\d)%7C
+++++(?<=%5E\d{2})(?<!20)%7C(?<=%5E-\d{2})(?<!-20))\d++
%7C+++++++++++++++#+or
(?:(?<=20)%7C(?<=-20))[0-5]++#+if+preceding+chars+are+20+or+-20:+value+can+be+from+0+to+5

)+++++++++++++++#+end+non-capturing+group
)?++++++++++++++#+close+optional+tens+digits

(?:+++++++++++++#+FINAL+DIGIT+(non+optional)
(?=\d$)+++++++++#+assert+that+there+is+only+one+digit+left
(?:+++++++++++++#+start+non-capturing+group

++++++++++++++++#+if+preceding+char+is+head+of+string,+single+digit,+
++++++++++++++++#+two+digits,+or+three+digits+that+are+not+205
++++++++++++++++#+(with+or+without+a+minus)
++++++++++++++++#+value+can+be+any+digit
++(?:(?<=%5E)%7C(?<=%5E-)%7C(?<=%5E\d)%7C(?<=%5E-\d)%7C
++++++(?<=%5E\d{2})%7C(?<=%5E-\d{2})%7C
++++++(?<=%5E\d{3})(?<!205)%7C(?<=%5E-\d{3})(?<!-205))
++++++\d
++%7C+++++++++++++#+or
++(?:(?<=205)%7C(?<=-205))[0-5]+#+if+preceding+chars+are+205+or+-205:+value+can+be+from+0+to+5
)+++++++++++++++#+end+non-capturing+group
)+++++++++++++++#+end+final+digit
$|1555874|系列测试|1555875|这些测试尝试与-100000到100000之间的数字进行匹配。它们会产生以下输出：|1555876|Successful+test:+matches+from+-2055+to+2055
Successful+test:+NO+matches+from+-100000+to+-2056
Successful+test:+NO+matches+from+2056+to+100000|1555877|代码如下：|1555878|<?php
$regex="~%5E(?!-0$)-?(?:(?=\d{4}$)[12])?(?:(?=\d{3}$)(?:(?:(?<=%5E)%7C(?<=%5E-)%7C(?<=1)%7C(?<=-1))\d%7C(?:(?<=2)%7C(?<=-2))0))?(?:(?=\d{2}$)(?:(?:(?<=20)%7C(?<=-20))[0-5]%7C(?:(?<=%5E)%7C(?<=%5E-)%7C(?<=%5E\d)%7C(?<=%5E-\d)%7C(?<=%5E\d{2})(?<!20)%7C(?<=%5E-\d{2})(?<!-20))\d))?(?:(?=\d$)(?:(?:(?<=205)%7C(?<=-205))[0-5]%7C(?:(?<=%5E)%7C(?<=%5E-)%7C(?<=%5E\d)%7C(?<=%5E-\d)%7C(?<=%5E\d{2})%7C(?<=%5E-\d{2})%7C(?<=%5E\d{3})(?<!205)%7C(?<=%5E-\d{3})(?<!-205))\d))$~";

//+Test+1
$success="Successful+test:+matches+from+-2055+to+2055";
for($i=-2055;$i<=2055;$i%2B%2B)+{
$chari+=+sprintf("%25d",$i);
if+(!+preg_match($regex,$chari))+{
++++$success="Failed+test:+matches+from+-2055+to+2055";
++++echo+$chari.":+No+Match!<br+/>";
++++}
}
echo+$success."<br+/>";

//+Test+2
$success="Successful+test:+NO+matches+from+-100000+to+-2056";
for($i=-100000;$i<=-2056;$i%2B%2B)+{
$chari+=+sprintf("%25d",$i);
if+(preg_match($regex,$chari))+{
++++$success="Failed+test:+NO+matches+from+-100000+to+-2056";
++++echo+$chari.":+Match!<br+/>";
++++}
}
echo+$success."<br+/>";

//+Test+3
$success="Successful+test:+NO+matches+from+2056+to+100000";
for($i=2056;$i<=100000;$i%2B%2B)+{
$chari+=+sprintf("%25d",$i);
if+(preg_match($regex,$chari))+{
++++$success="Failed+test:+NO+matches+from+2056+to+100000";
++++echo+$chari.":+Match!<br+/>";
++++}
}
echo+$success."<br+/>";

?>|1555879|速度测试|1555880|这是我的简单速度测试的输出，匹配-1M到%2B1M。正如Casimir所指出的，如果aliteralmind的表达式是锚定的，那么它将比以前更快25%25！|1555881|zx81:+3.796217918396
aliteralmind:+3.9922280311584
difference:+5.1632998151294+percent+longer|1555882|下面是测试代码：|1555883|$regex="~(?x)%5E(?!-0$)-?(?:(?=\d{4}$)[12])?(?:(?=\d{3}$)(?:(?:(?<=%5E)%7C(?<=%5E-)%7C(?<=1)%7C(?<=-1))\d%7C(?:(?<=2)%7C(?<=-2))0))?(?:(?=\d{2}$)(?:(?:(?<=%5E)%7C(?<=%5E-)%7C(?<=%5E\d)%7C(?<=%5E-\d)%7C(?<=%5E\d{2})(?<!20)%7C(?<=%5E-\d{2})(?<!-20))\d%7C(?:(?<=20)%7C(?<=-20))[0-5]))?(?:(?=\d$)(?:(?:(?<=%5E)%7C(?<=%5E-)%7C(?<=%5E\d)%7C(?<=%5E-\d)%7C(?<=%5E\d{2})%7C(?<=%5E-\d{2})%7C(?<=%5E\d{3})(?<!205)%7C(?<=%5E-\d{3})(?<!-205))\d%7C(?:(?<=205)%7C(?<=-205))[0-5]))$~";

$regex2+=+"~(-?\b(?:20(?:5[0-5]%7C[0-4][0-9])%7C1[0-9]{3}%7C[1-9][0-9]{0,2}%7C(?<!-)0%2B))\b~";

$start=microtime(TRUE);
for+($i=-1000000;$i<1000000;$i%2B%2B)+preg_match($regex,$i);
$zxend=microtime(TRUE);
for+($i=-1000000;$i<1000000;$i%2B%2B)+preg_match($regex2,$i);
$alitend=microtime(TRUE);
$zx81+=+$zxend-$start;
$alit+=+$alitend-$zxend;
$diff+=+100*($alit-$zx81)/$zx81;
echo+"zx81:+".$zx81."<br+/>";
echo+"aliteralmind:+".$alit."<br+/>";
echo+"difference:+".$diff."+percent+longer<br+/>";|1555884|entityMap^0|1J|A|0|H|7|0|0|0|0|0|0|H|2|0|0|0|O|5|V|2|0|0|0|0|7|8|5|0|0|0|4|0|0|15|0|0|0|5|0|0|0|4|0|0|22|0|0|0|8|0|0^^$0|@$1|2|3|4|5|6|7|1W|8|@$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1Z|8|@$9|20|A|21|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|22|8|@]|D|@]|E|$]]|$1|I|3|J|5|K|7|23|8|@]|D|@]|E|$]]|$1|L|3|M|5|K|7|24|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|25|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|26|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|27|8|@$9|28|A|29|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|2A|8|@]|D|@]|E|$]]|$1|U|3|V|5|6|7|2B|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|2C|8|@$9|2D|A|2E|B|Y]|$9|2F|A|2G|B|Y]]|D|@]|E|$]]|$1|Z|3|10|5|6|7|2H|8|@]|D|@]|E|$]]|$1|11|3|12|5|13|7|2I|8|@]|D|@]|E|$14|15]]|$1|16|3|17|5|6|7|2J|8|@$9|2K|A|2L|B|C]|$9|2M|A|2N|B|C]]|D|@]|E|$]]|$1|18|3|19|5|13|7|2O|8|@]|D|@]|E|$14|15]]|$1|1A|3|1B|5|6|7|2P|8|@$9|2Q|A|2R|B|C]]|D|@]|E|$]]|$1|1C|3|1D|5|6|7|2S|8|@$9|2T|A|2U|B|C]]|D|@]|E|$]]|$1|1E|3|1F|5|13|7|2V|8|@]|D|@]|E|$14|15]]|$1|1G|3|1H|5|6|7|2W|8|@$9|2X|A|2Y|B|C]]|D|@]|E|$]]|$1|1I|3|1J|5|13|7|2Z|8|@]|D|@]|E|$14|15]]|$1|1K|3|1L|5|6|7|30|8|@$9|31|A|32|B|C]]|D|@]|E|$]]|$1|1M|3|1N|5|6|7|33|8|@$9|34|A|35|B|C]]|D|@]|E|$]]|$1|1O|3|1P|5|13|7|36|8|@]|D|@]|E|$14|15]]|$1|1Q|3|1R|5|6|7|37|8|@$9|38|A|39|B|C]]|D|@]|E|$]]|$1|1S|3|1T|5|13|7|3A|8|@]|D|@]|E|$14|15]]|$1|1U|3|-4|5|6|7|3B|8|@]|D|@]|E|$]]]|1V|$]]

As an alternate approach to the great expression offered by aliteralmind, here is one that is much longer but interesting in order to see what another approach might look like (and what not to do). 

It's an interesting exercise, because you can think of two distinct method: roughly, you can either:

<ol>
<li>proceed by matching 4-char numbers, then 3-char numbers, etc.</li>
<li>or proceed by matching the thousands digit, then the hundreds digit, etc. </li>
</ol>

Without trying, how would you know which is best? It turns out that the first approach (aliteralmind's answer) is far more economical.

Lower, I include a series of tests in the PHP language in case you or someone else would like to check the output.

Below, I will give you the regex in "free-spacing mode", which allows comments inside the regex so you can easily understand what it does. However, not all regex engines support free-spacing mode, so before we start with the interesting part, here is the regex as a one-liner.

Note that your question mentions numbers from -2055 to 2055. I assumed that you wanted to match "normal numbers", without leading zeroes. This means that the regex will match 999 but not 0999. If you would like leading zeroes, let me know, that is a very easy tweak.

Also, if you are matching in utf-8 mode, the <code>\d</code> should be replaced by <code>[0-9]</code>. This is the more common form.

The Regex as a One-Liner

<pre><code>^(?!-0$)-?(?:(?=\d{4}$)[12])?(?:(?=\d{3}$)(?:(?:(?&lt;=^)|(?&lt;=^-)|(?&lt;=1)|(?&lt;=-1))\d|(?:(?&lt;=2)|(?&lt;=-2))0))?(?:(?=\d{2}$)(?:(?:(?&lt;=^)|(?&lt;=^-)|(?&lt;=^\d)|(?&lt;=^-\d)|(?&lt;=^\d{2})(?&lt;!20)|(?&lt;=^-\d{2})(?&lt;!-20))\d|(?:(?&lt;=20)|(?&lt;=-20))[0-5]))?(?:(?=\d$)(?:(?:(?&lt;=^)|(?&lt;=^-)|(?&lt;=^\d)|(?&lt;=^-\d)|(?&lt;=^\d{2})|(?&lt;=^-\d{2})|(?&lt;=^\d{3})(?&lt;!205)|(?&lt;=^-\d{3})(?&lt;!-205))\d|(?:(?&lt;=205)|(?&lt;=-205))[0-5]))$
</code></pre>

The Regex in Free-Spacing Mode

<pre><code>(?x) # free-spacing mode
^ # anchor at beginning of string.
(?!-0$)-? # optional minus sign, but not for -0

(?: # OPTIONAL THOUSANDS DIGIT
(?=\d{4}$)[12] # assert that the number is 4-digit long, match 1 or 2
)? # end optional thousands digit


(?: # OPTIONAL HUNDREDS DIGIT
(?=\d{3}$) # assert that there are three digits left
(?: # non-capturing group
 (?:(?&lt;=^)|(?&lt;=^-)|(?&lt;=1)|(?&lt;=-1))\d # if preceding chars are 1, -1 or head of string: value can be any digit
 | # or
 (?:(?&lt;=2)|(?&lt;=-2))0 # if preceding chars are 2 or -2: value must be 0
) # close non-capturing group
)? # end optional hundreds digits

(?: # OPTIONAL TENS DIGIT
(?=\d{2}$) # assert that there are two digits left
(?: # start non-capturing group

 # if preceding char is head of string, single digit,
 # or two digits that are not 20
 # (with or without a minus)
 # value can be any digit
 (?:(?&lt;=^)|(?&lt;=^-)|(?&lt;=^\d)|(?&lt;=^-\d)|
 (?&lt;=^\d{2})(?&lt;!20)|(?&lt;=^-\d{2})(?&lt;!-20))\d 
| # or
(?:(?&lt;=20)|(?&lt;=-20))[0-5] # if preceding chars are 20 or -20: value can be from 0 to 5

) # end non-capturing group
)? # close optional tens digits

(?: # FINAL DIGIT (non optional)
(?=\d$) # assert that there is only one digit left
(?: # start non-capturing group

 # if preceding char is head of string, single digit, 
 # two digits, or three digits that are not 205
 # (with or without a minus)
 # value can be any digit
 (?:(?&lt;=^)|(?&lt;=^-)|(?&lt;=^\d)|(?&lt;=^-\d)|
 (?&lt;=^\d{2})|(?&lt;=^-\d{2})|
 (?&lt;=^\d{3})(?&lt;!205)|(?&lt;=^-\d{3})(?&lt;!-205))
 \d
 | # or
 (?:(?&lt;=205)|(?&lt;=-205))[0-5] # if preceding chars are 205 or -205: value can be from 0 to 5
) # end non-capturing group
) # end final digit
$
</code></pre>

Series of Tests

These tests try to match against numbers from -100000 to 100000. They produce the following output:

<pre><code>Successful test: matches from -2055 to 2055
Successful test: NO matches from -100000 to -2056
Successful test: NO matches from 2056 to 100000
</code></pre>

Here is the code:

<pre><code>&lt;?php
$regex="~^(?!-0$)-?(?:(?=\d{4}$)[12])?(?:(?=\d{3}$)(?:(?:(?&lt;=^)|(?&lt;=^-)|(?&lt;=1)|(?&lt;=-1))\d|(?:(?&lt;=2)|(?&lt;=-2))0))?(?:(?=\d{2}$)(?:(?:(?&lt;=20)|(?&lt;=-20))[0-5]|(?:(?&lt;=^)|(?&lt;=^-)|(?&lt;=^\d)|(?&lt;=^-\d)|(?&lt;=^\d{2})(?&lt;!20)|(?&lt;=^-\d{2})(?&lt;!-20))\d))?(?:(?=\d$)(?:(?:(?&lt;=205)|(?&lt;=-205))[0-5]|(?:(?&lt;=^)|(?&lt;=^-)|(?&lt;=^\d)|(?&lt;=^-\d)|(?&lt;=^\d{2})|(?&lt;=^-\d{2})|(?&lt;=^\d{3})(?&lt;!205)|(?&lt;=^-\d{3})(?&lt;!-205))\d))$~";

// Test 1
$success="Successful test: matches from -2055 to 2055";
for($i=-2055;$i&lt;=2055;$i++) {
$chari = sprintf("%d",$i);
if (! preg_match($regex,$chari)) {
 $success="Failed test: matches from -2055 to 2055";
 echo $chari.": No Match!&lt;br /&gt;";
 }
}
echo $success."&lt;br /&gt;";

// Test 2
$success="Successful test: NO matches from -100000 to -2056";
for($i=-100000;$i&lt;=-2056;$i++) {
$chari = sprintf("%d",$i);
if (preg_match($regex,$chari)) {
 $success="Failed test: NO matches from -100000 to -2056";
 echo $chari.": Match!&lt;br /&gt;";
 }
}
echo $success."&lt;br /&gt;";

// Test 3
$success="Successful test: NO matches from 2056 to 100000";
for($i=2056;$i&lt;=100000;$i++) {
$chari = sprintf("%d",$i);
if (preg_match($regex,$chari)) {
 $success="Failed test: NO matches from 2056 to 100000";
 echo $chari.": Match!&lt;br /&gt;";
 }
}
echo $success."&lt;br /&gt;";

?&gt;
</code></pre>

Speed Tests

Here is the output of my simple speed test, matching from -1M to +1M. As Casimir pointed out, if aliteralmind's expression were anchored, instead of being slower it would be faster by 25%!

<pre><code>zx81: 3.796217918396
aliteralmind: 3.9922280311584
difference: 5.1632998151294 percent longer
</code></pre>

Here is the test code:

<pre><code>$regex="~(?x)^(?!-0$)-?(?:(?=\d{4}$)[12])?(?:(?=\d{3}$)(?:(?:(?&lt;=^)|(?&lt;=^-)|(?&lt;=1)|(?&lt;=-1))\d|(?:(?&lt;=2)|(?&lt;=-2))0))?(?:(?=\d{2}$)(?:(?:(?&lt;=^)|(?&lt;=^-)|(?&lt;=^\d)|(?&lt;=^-\d)|(?&lt;=^\d{2})(?&lt;!20)|(?&lt;=^-\d{2})(?&lt;!-20))\d|(?:(?&lt;=20)|(?&lt;=-20))[0-5]))?(?:(?=\d$)(?:(?:(?&lt;=^)|(?&lt;=^-)|(?&lt;=^\d)|(?&lt;=^-\d)|(?&lt;=^\d{2})|(?&lt;=^-\d{2})|(?&lt;=^\d{3})(?&lt;!205)|(?&lt;=^-\d{3})(?&lt;!-205))\d|(?:(?&lt;=205)|(?&lt;=-205))[0-5]))$~";

$regex2 = "~(-?\b(?:20(?:5[0-5]|[0-4][0-9])|1[0-9]{3}|[1-9][0-9]{0,2}|(?&lt;!-)0+))\b~";

$start=microtime(TRUE);
for ($i=-1000000;$i&lt;1000000;$i++) preg_match($regex,$i);
$zxend=microtime(TRUE);
for ($i=-1000000;$i&lt;1000000;$i++) preg_match($regex2,$i);
$alitend=microtime(TRUE);
$zx81 = $zxend-$start;
$alit = $alitend-$zxend;
$diff = 100*($alit-$zx81)/$zx81;
echo "zx81: ".$zx81."&lt;br /&gt;";
echo "aliteralmind: ".$alit."&lt;br /&gt;";
echo "difference: ".$diff." percent longer&lt;br /&gt;";
</code></pre>

blocks|key|1876194|text|尝试使用一个非常简单的正则表达式。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1876195|%5E([-0][0-1][0-9][0-9][0-9])$%7C%5E([-0]20[0-4][0-9])$%7C%5E([-0]205[0-5])$|code-block|syntax|javascript|1876196|视觉表现|1876197|​|1876198|📷|atomic|1876199|1876200|这是，理解非常简单。|1876201|1876202|group+1+[-0][0-1][0-9][0-9][0-9]将涵盖-1999、1999+values|unordered-list-item|CODE|1876203|group+2+[-0]20[0-4][0-9]将涵盖-2000、-2049+E215和E1162000、2049值|1876204|第三组D20将涵盖E121-2050、-2055+E222和E1232050、2055+E224值|1876205|1876206|1876207|+String.format("%2505d",+number)在这里做得很好吗？|blockquote|1876208|1876209|1876210|示例代码：(为了更清晰，请阅读内联注释。)|1876211|int[]+numbers+=+new+int[]+{+-10002,+-3000,+-2056,+-2055,+-2000,+-1999,+-20,+
++++++++++++++++++++++++++++-1,++0,+1,+260,+1999,+2000,+2046,+2055,+2056,+2955,+
+++++++++++++++++++++++++++++3000,+10002,+123456+};

//valid+range+-2055+to+2055+inclusive

Pattern+p+=+Pattern.compile("%5E([-0][0-1][0-9][0-9][0-9])$%7C%5E([-0]20[0-4][0-9])$%7C%5E([-0]205[0-5])$");

for+(int+number+:+numbers)+{
++++String+string+=+String.format("%2505d",+number);
++++Matcher+m+=+p.matcher(string);

++++if+(m.find())+{
++++++++System.out.println(number+%2B+"+is+in+range.");
++++}+else+{
++++++++System.out.println(number+%2B+"+is+not+in+range.");
++++}
}|1876212|输出：|1876213|-10002+is+not+in+range.
-3000+is+not+in+range.
-2056+is+not+in+range.
-2055+is+in+range.
-2000+is+in+range.
-1999+is+in+range.
-20+is+in+range.
-1+is+in+range.
0+is+in+range.
1+is+in+range.
260+is+in+range.
1999+is+in+range.
2000+is+in+range.
2046+is+in+range.
2055+is+in+range.
2056+is+not+in+range.
2955+is+not+in+range.
3000+is+not+in+range.
10002+is+not+in+range.
123456+is+not+in+range.|1876214|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/d4296de675758ee1ecaddbdc835ccbb5.png|imageAlt^0|B|5|0|0|0|0|0|1|0|0|0|2|3|0|0|8|O|Z|A|0|8|G|R|U|0|0|0|0|1|T|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1R|8|@$9|1S|A|1T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1U|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1V|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|1W|8|@]|D|@]|E|$]]|$1|O|3|P|5|Q|7|1X|8|@]|D|@$9|1Y|A|1Z|1|20]]|E|$]]|$1|R|3|N|5|6|7|21|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|22|8|@$9|23|A|24|B|C]]|D|@]|E|$]]|$1|U|3|-4|5|6|7|25|8|@]|D|@]|E|$]]|$1|V|3|W|5|X|7|26|8|@$9|27|A|28|B|Y]|$9|29|A|2A|B|C]]|D|@]|E|$]]|$1|Z|3|10|5|X|7|2B|8|@$9|2C|A|2D|B|Y]|$9|2E|A|2F|B|C]]|D|@]|E|$]]|$1|11|3|12|5|X|7|2G|8|@]|D|@]|E|$]]|$1|13|3|-4|5|6|7|2H|8|@]|D|@]|E|$]]|$1|14|3|-4|5|6|7|2I|8|@]|D|@]|E|$]]|$1|15|3|16|5|17|7|2J|8|@$9|2K|A|2L|B|Y]]|D|@]|E|$]]|$1|18|3|-4|5|6|7|2M|8|@]|D|@]|E|$]]|$1|19|3|-4|5|6|7|2N|8|@]|D|@]|E|$]]|$1|1A|3|1B|5|6|7|2O|8|@]|D|@]|E|$]]|$1|1C|3|1D|5|H|7|2P|8|@]|D|@]|E|$I|J]]|$1|1E|3|1F|5|6|7|2Q|8|@]|D|@]|E|$]]|$1|1G|3|1H|5|H|7|2R|8|@]|D|@]|E|$I|J]]|$1|1I|3|-4|5|6|7|2S|8|@]|D|@]|E|$]]]|1J|$1K|$5|1L|1M|1N|E|$1O|1P|1Q|-4]]]]

Try with a very simple regex.

<pre><code>^([-0][0-1][0-9][0-9][0-9])$|^([-0]20[0-4][0-9])$|^([-0]205[0-5])$
</code></pre>

Visual representation

<img src="https://i.stack.imgur.com/L9bok.png" alt="enter image description here">

It's very simple to understand.

<ul>
<li>group 1 <code>[-0][0-1][0-9][0-9][0-9]</code> will cover [-1999, 1999] values</li>
<li>group 2 <code>[-0]20[0-4][0-9]</code> will cover [-2000,-2049] and [2000,2049] values</li>
<li>group 3 <code>[-0]205[0-5]</code> will cover [-2050, -2055] and [2050, 2055] values</li>
</ul>

<blockquote>
 <code>String.format("%05d", number)</code> is doing very well done job here?
</blockquote>

Sample code: (Read inline comments for more clarity.)

<pre><code>int[] numbers = new int[] { -10002, -3000, -2056, -2055, -2000, -1999, -20, 
 -1, 0, 1, 260, 1999, 2000, 2046, 2055, 2056, 2955, 
 3000, 10002, 123456 };

//valid range -2055 to 2055 inclusive

Pattern p = Pattern.compile("^([-0][0-1][0-9][0-9][0-9])$|^([-0]20[0-4][0-9])$|^([-0]205[0-5])$");

for (int number : numbers) {
 String string = String.format("%05d", number);
 Matcher m = p.matcher(string);

 if (m.find()) {
 System.out.println(number + " is in range.");
 } else {
 System.out.println(number + " is not in range.");
 }
}
</code></pre>

output:

<pre><code>-10002 is not in range.
-3000 is not in range.
-2056 is not in range.
-2055 is in range.
-2000 is in range.
-1999 is in range.
-20 is in range.
-1 is in range.
0 is in range.
1 is in range.
260 is in range.
1999 is in range.
2000 is in range.
2046 is in range.
2055 is in range.
2056 is not in range.
2955 is not in range.
3000 is not in range.
10002 is not in range.
123456 is not in range.
</code></pre>

blocks|key|3986124|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3986125|%5E-?0*(1?[0-9]{1,3}%7C20[0-4][0-9]%7C205[0-5])$|code-block|syntax|javascript|3986126|括号前的正则表达式匹配一个可选的-和任何前导0。|offset|length|style|CODE|3986127|括号中的第一部分(1?[0-9]{1,3})匹配0-1999。|3986128|括号中的第二部分(20[0-4][0-9])与2000年至2049年匹配。|3986129|括号中的第三部分(205[0-5])匹配2050-2055。|3986130|entityMap^0|0|0|G|1|0|9|C|0|9|C|0|9|8|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@$I|10|J|11|K|L]]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@$I|13|J|14|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|15|8|@$I|16|J|17|K|L]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|T|$]]

Try this:

<pre><code>^-?0*(1?[0-9]{1,3}|20[0-4][0-9]|205[0-5])$
</code></pre>

The regex before the brackets matches an optional <code>-</code> and any leading 0s.

The first part in the brackets (<code>1?[0-9]{1,3}</code>) matches 0-1999.

The second part in the brackets (<code>20[0-4][0-9]</code>) matches 2000-2049.

The third part in the brackets (<code>205[0-5]</code>) matches 2050-2055.

blocks|key|1876336|text|分析问题|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1876337|如果您“必须”使用正则表达式，那么可以通过分析接受的排列来分解问题。|1876338|“从-2055到2055的范围”可以表示为：|1876339|1876340|a+optional+-|unordered-list-item|1876341|可选的前导零|1876342|后跟一个从0到2055的数字|1876343|1876344|“从0到2055的数字”可以是有限数量的特定排列之一：|1876345|(10-99)|1876346|three数字以1开头的(100-999)|1876347|
|1876348|four数字|1876349|一位数字(0-9)|1876350|两位数字以205+(2050-2055*)|1876351|开头的20位(1000-1999)|1876352|1876353|1876354|1876355|请注意，对于此正则表达式的目的，没有必要区分范围"0-9“和"1-9"，并且只有最后两个范围对可接受的数字/字符的范围有任何限制(用星号表示)。|1876356|编写组件正则表达式|1876357|上面的每个组成部分都很容易单独表示为正则表达式：|1876358|1876359|-?|1876360|*+|1876361|0-9|1876362|1876363|0-90-9|1876364|10-90-9|1876365|200-4|1876366|2050-5|1876367|1876368|1876369|把这些表达式放在一起|1876370|整个匹配的相关表达式为：|1876371|-?0*([0-9]%7C[0-9][0-9]%7C[0-9][0-9][0-9]%7C1[0-9][0-9][0-9]%7C20[0-4][0-9]%7C205[0-5])|code-block|syntax|javascript|1876372|或者更简明一点：|1876373|-?0*([0-9]{1,3}%7C1[0-9]{3}%7C20[0-4][0-9]%7C205[0-5])|1876374|假设输入只包含"the+number“，不包含其他内容，因此最终的正则表达式为：|1876375|%5E-?0*([0-9]{1,3}%7C1[0-9]{3}%7C20[0-4][0-9]%7C205[0-5])$|1876376|如果有必要允许使用前导加号，则会变成：|1876377|%5E[-%2B]?0*([0-9]{1,3}%7C1[0-9]{3}%7C20[0-4][0-9]%7C205[0-5])$|1876378|Here's+a+js+fiddle演示了在最后一个正则表达式中通过和失败的内容。|offset|length|1876379|entityMap|0|LINK|mutability|MUTABLE|url|http://jsfiddle.net/S878Y/9/^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|1|1|1|1|1|1|1|0|0|0|0|0|0|0|0|0|0|0|0|I|0|0^^$0|@$1|2|3|4|5|6|7|2S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|2T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|2U|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|2V|8|@]|9|@]|A|$]]|$1|G|3|H|5|I|7|2W|8|@]|9|@]|A|$]]|$1|J|3|K|5|I|7|2X|8|@]|9|@]|A|$]]|$1|L|3|M|5|I|7|2Y|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|2Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|30|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|31|8|@]|9|@]|A|$]]|$1|S|3|T|5|I|7|32|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|33|8|@]|9|@]|A|$]]|$1|W|3|X|5|I|7|34|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|I|7|35|8|@]|9|@]|A|$]]|$1|10|3|11|5|I|7|36|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|37|8|@]|9|@]|A|$]]|$1|14|3|V|5|6|7|38|8|@]|9|@]|A|$]]|$1|15|3|X|5|I|7|39|8|@]|9|@]|A|$]]|$1|16|3|-4|5|6|7|3A|8|@]|9|@]|A|$]]|$1|17|3|18|5|6|7|3B|8|@]|9|@]|A|$]]|$1|19|3|1A|5|6|7|3C|8|@]|9|@]|A|$]]|$1|1B|3|1C|5|6|7|3D|8|@]|9|@]|A|$]]|$1|1D|3|-4|5|6|7|3E|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|I|7|3F|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|I|7|3G|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|I|7|3H|8|@]|9|@]|A|$]]|$1|1K|3|1J|5|I|7|3I|8|@]|9|@]|A|$]]|$1|1L|3|1M|5|I|7|3J|8|@]|9|@]|A|$]]|$1|1N|3|1O|5|I|7|3K|8|@]|9|@]|A|$]]|$1|1P|3|1Q|5|I|7|3L|8|@]|9|@]|A|$]]|$1|1R|3|1S|5|I|7|3M|8|@]|9|@]|A|$]]|$1|1T|3|-4|5|6|7|3N|8|@]|9|@]|A|$]]|$1|1U|3|-4|5|6|7|3O|8|@]|9|@]|A|$]]|$1|1V|3|1W|5|6|7|3P|8|@]|9|@]|A|$]]|$1|1X|3|1Y|5|6|7|3Q|8|@]|9|@]|A|$]]|$1|1Z|3|20|5|21|7|3R|8|@]|9|@]|A|$22|23]]|$1|24|3|25|5|6|7|3S|8|@]|9|@]|A|$]]|$1|26|3|27|5|21|7|3T|8|@]|9|@]|A|$22|23]]|$1|28|3|29|5|6|7|3U|8|@]|9|@]|A|$]]|$1|2A|3|2B|5|21|7|3V|8|@]|9|@]|A|$22|23]]|$1|2C|3|2D|5|6|7|3W|8|@]|9|@]|A|$]]|$1|2E|3|2F|5|21|7|3X|8|@]|9|@]|A|$22|23]]|$1|2G|3|2H|5|6|7|3Y|8|@]|9|@$2I|3Z|2J|40|1|41]]|A|$]]|$1|2K|3|-4|5|6|7|42|8|@]|9|@]|A|$]]]|2L|$2M|$5|2N|2O|2P|A|$2Q|2R]]]]

<h2>Analyze the problem</h2>
If you &quot;must&quot; use a regex, break the problem down by analysing the accepted permutations.
&quot;a range from -2055 to 2055&quot; can be expressed as:
<ul>
<li>an optional -</li>
<li>optional leading zeros</li>
<li>followed by a number from 0 to 2055</li>
</ul>
&quot;A number from 0 to 2055&quot; can be one of a finite number of specific permutations:
<ul>
<li>one digit (0-9)</li>
<li>two digits (10-99)</li>
<li>three digits (100-999)</li>
<li>four digits starting with a 1 (1000-1999)</li>
<li>four digits starting with 20 (2000-204*9)</li>
<li>four digits starting with 205 (2050-2055*)</li>
</ul>
Note that for the purpose of this regex, it's not necessary to distinguish between the range &quot;0-9&quot; and &quot;1-9&quot;, and only the last two ranges have any restrictions on the range of accepted digits/characters (indicated with a star).
<h2>Write component regex expressions</h2>
Each of the above component parts are easy to individually express as a regular expression:
<ul>
<li>-?</li>
<li>0*
<ul>
<li>[0-9]</li>
<li>[0-9][0-9]</li>
<li>[0-9][0-9][0-9]</li>
<li>1[0-9][0-9][0-9]</li>
<li>20[0-4][0-9]</li>
<li>205[0-5]</li>
</ul>
</li>
</ul>
<h2>Put the expressions together</h2>
The relevant expression for the whole match would be:
<pre><code>-?0*([0-9]|[0-9][0-9]|[0-9][0-9][0-9]|1[0-9][0-9][0-9]|20[0-4][0-9]|205[0-5])
</code></pre>
Or slightly more concisely:
<pre><code>-?0*([0-9]{1,3}|1[0-9]{3}|20[0-4][0-9]|205[0-5])
</code></pre>
Assuming the input contains only &quot;the number&quot; and nothing else, the final regex is therefore:
<pre><code>^-?0*([0-9]{1,3}|1[0-9]{3}|20[0-4][0-9]|205[0-5])$
</code></pre>
If it's necessary to allow for a leading plus sign, this becomes:
<pre><code>^[-+]?0*([0-9]{1,3}|1[0-9]{3}|20[0-4][0-9]|205[0-5])$
</code></pre>
<a href="http://jsfiddle.net/S878Y/9/" rel="noreferrer">Here's a js fiddle</a> demonstrating what passes and what would fails the last regex.

blocks|key|5403914|text|这么多答案，但是没有人在评论中读到(或关心)+OPs方面的问题？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5403915|5403916|我正在用OCaml写一个解释器....如何在不使用正则表达式的情况下验证范围内的输入数字?？-+Trung+Nguyen+Mar+2+at+17:30|blockquote|5403917|5403918|5403919|正如许多答案正确地指出，在这种情况下使用正则表达式是可怕的，让我们考虑一下OCaml中的其他方法！自从我使用OCaml以来已经有一段时间了，但是通过查找一些构造，我能够将这些拼凑在一起：|5403920|let+isInRange+i+=+
++++not(i+<+-2055+or+i+>+2055);;

let+isIntAndInRange+s+=+
++++try
++++let+i+=+int_of_string+s+in
++++not(i+<+-2055+or+i+>+2055)
++++with+Failure+"int_of_string"+->+false;;

let+()+=+print_string+"type+a+number:+"+in
let+s+=+read_line+()+in
isIntAndInRange+s|code-block|syntax|javascript|5403921|如果有任何不清楚的地方，请仔细阅读它的语法、type+conversion+functions、exception+handling和input-output+functions。|offset|length|5403922|用户输入部分仅用于演示。在那里使用read_int函数可能更方便。但处理异常的基本概念保持不变。|style|CODE|5403923|entityMap|0|LINK|mutability|MUTABLE|url|http://caml.inria.fr/pub/docs/manual-ocaml/libref/Pervasives.html#6_Stringconversionfunctions|1|http://www2.lib.uchicago.edu/keith/ocaml-class/exceptions.html|2|http://caml.inria.fr/pub/docs/oreilly-book/html/book-ora027.html|3|http://caml.inria.fr/pub/docs/manual-ocaml/libref/Pervasives.html#7_Inputfunctionsonstandardinput^0|0|0|0|0|0|0|0|M|P|0|1C|I|1|1V|M|2|0|H|8|H|8|3|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1C|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1F|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1G|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1H|8|@]|9|@$Q|1I|R|1J|1|1K]|$Q|1L|R|1M|1|1N]|$Q|1O|R|1P|1|1Q]]|A|$]]|$1|S|3|T|5|6|7|1R|8|@$Q|1S|R|1T|U|V]]|9|@$Q|1U|R|1V|1|1W]]|A|$]]|$1|W|3|-4|5|6|7|1X|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]|14|$5|Z|10|11|A|$12|15]]|16|$5|Z|10|11|A|$12|17]]|18|$5|Z|10|11|A|$12|19]]]]

So many answers, but noone reads (or cares) about the OPs side question in the comments?

<blockquote>
 I'm writing an interpreter in OCaml .... how can i validate the input
 number within the range without using regex ?? – Trung Nguyen Mar 2
 at 17:30
</blockquote>

As so many answers - correctly - pointed out that using regex is horrible for this scenario, lets think about other ways in OCaml! It is a while since I used OCaml, but with looking up a few constructs I was able to knock this together:

<pre><code>let isInRange i = 
 not(i &lt; -2055 or i &gt; 2055);;

let isIntAndInRange s = 
 try
 let i = int_of_string s in
 not(i &lt; -2055 or i &gt; 2055)
 with Failure "int_of_string" -&gt; false;;

let () = print_string "type a number: " in
let s = read_line () in
isIntAndInRange s
</code></pre>

If anything about is unclear, please read up on its syntax, <a href="http://caml.inria.fr/pub/docs/manual-ocaml/libref/Pervasives.html#6_Stringconversionfunctions" rel="noreferrer">type conversion functions</a> and <a href="http://www2.lib.uchicago.edu/keith/ocaml-class/exceptions.html" rel="noreferrer">exception handling</a> and <a href="http://caml.inria.fr/pub/docs/oreilly-book/html/book-ora027.html" rel="noreferrer">input-output functions</a>.

The user input part is only used to demonstrate. It might be more convenient to use the <a href="http://caml.inria.fr/pub/docs/manual-ocaml/libref/Pervasives.html#7_Inputfunctionsonstandardinput" rel="noreferrer"><code>read_int</code></a> function there. But the basic concept of handling the exception stays the same.

blocks|key|1876452|text|还有另一个-|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1876453|+#++%5E-?0*(?:20(?:[0-4][0-9]%7C5[0-5])%7C[0-9]{1,3})$

+%5E+
+-?
+0*
+(?:
++++++20
++++++(?:
+++++++++++[0-4]+[0-9]+
++++++++%7C++
+++++++++++5+[0-5]+
++++++)
+++%7C++
++++++[0-9]{1,3}+
+)
+$|code-block|syntax|javascript|1876454|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|$]]

Yet another - 

<pre><code> # ^-?0*(?:20(?:[0-4][0-9]|5[0-5])|[0-9]{1,3})$

 ^ 
 -?
 0*
 (?:
 20
 (?:
 [0-4] [0-9] 
 | 
 5 [0-5] 
 )
 | 
 [0-9]{1,3} 
 )
 $
</code></pre>

blocks|key|1876472|text|看看这个强大的工具，它为数字范围生成正则表达式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1876473|http://gamon.webfactional.com/regexnumericrangegenerator/|offset|length|1876474|对于OP请求的范围，它会生成：-?([0-9]{1,3}%7C1[0-9]{3}%7C20[0-4][0-9]%7C205[0-5])|style|CODE|1876475|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1L|0|0|F|1A|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@$D|S|E|T|1|U]]|A|$]]|$1|F|3|G|5|6|7|V|8|@$D|W|E|X|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|C]]]]

Check out this great tool which generates a regex for numeric ranges:

<a href="http://gamon.webfactional.com/regexnumericrangegenerator/" rel="noreferrer">http://gamon.webfactional.com/regexnumericrangegenerator/</a>

For the range requested by OP it generates: <code>-?([0-9]{1,3}|1[0-9]{3}|20[0-4][0-9]|205[0-5])</code>

My input number is an int. But the input number must be in a range from -2055 to 2055 and I want to check this by using regular expression.

So is there anyway to write a regular expression to check whether a number is in (-2055, 2055) or not ?

It is easier to use if statement to check whether the number is in range or not. But I'm writing an interpreter so I should use regex to check the input number

Using regular expressions to validate a numeric range

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我的输入数字是一个整数。但是输入的数字必须在-2055到2055的范围内，我想使用正则表达式进行检查。那么有没有什么办法写一个正则表达式来检查一个数字是否在(-2055,2055)中呢？更容易使用if语句来检查数字是否在范围内。但是我正在编写一个解释器，所以我应该使用regex来检查输入数字

问使用正则表达式验证数值范围
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用正则表达式验证数值范围EN