正则expression式用于匹配文本中带有或不带逗号和小数的数字
我试图find并replace文本正文中的所有数字。 我find了几个正则expression式的例子，几乎解决了这个问题，但没有一个是完美的。 我的问题是，在我的文本中的数字可能会或可能不会有小数和逗号。 例如：
“5000磅的狐狸跳过了99,999.99998713英尺的围栏。”
正则expression式应该返回“ 5000 ”和“ 99,999.99998713 ”。 示例我已经发现分割逗号的数字或限制在两位小数。 我开始理解正则expression式足以看出为什么一些例子被限制在两位小数，但我还没有学会如何克服它，也包括逗号得到整个序列。
这是我的最新版本：
[0-9]+(\.[0-9][0-9]?)?
对于上述文本，返回“ 5000 ”，“ 99,99 ”，“ 9.99 ”和“ 998713 ”。
编辑：由于这已经得到了很多意见，让我开始给每个人他们谷歌search：
#ALL THESE REQUIRE THE WHOLE STRING TO BE A NUMBER #For numbers embedded in sentences, see discussion below #### NUMBERS AND DECIMALS ONLY #### #No commas allowed #Pass: (1000.0), (001), (.001) #Fail: (1,000.0) ^\d*\.?\d+$ #No commas allowed #Can't start with "." #Pass: (0.01) #Fail: (.01) ^(\d+\.)?\d+$ #### CURRENCY #### #No commas allowed #"$" optional #Can't start with "." #Either 0 or 2 decimal digits #Pass: ($1000), (1.00), ($0.11) #Fail: ($1.0), (1.), ($1.000), ($.11) ^\$?\d+(\.\d{2})?$ #### COMMA-GROUPED #### #Commas required between powers of 1,000 #Can't start with "." #Pass: (1,000,000), (0.001) #Fail: (1000000), (1,00,00,00), (.001) ^\d{1,3}(,\d{3})*(\.\d+)?$ #Commas required #Cannot be empty #Pass: (1,000.100), (.001) #Fail: (1000), () ^(?=.)(\d{1,3}(,\d{3})*)?(\.\d+)?$ #Commas optional as long as they're consistent #Can't start with "." #Pass: (1,000,000), (1000000) #Fail: (10000,000), (1,00,00) ^(\d+|\d{1,3}(,\d{3})*)(\.\d+)?$ #### LEADING AND TRAILING ZEROES #### #No commas allowed #Can't start with "." #No leading zeroes in integer part #Pass: (1.00), (0.00) #Fail: (001) ^([1-9]\d*|0)(\.\d+)?$ #No commas allowed #Can't start with "." #No trailing zeroes in decimal part #Pass: (1), (0.1) #Fail: (1.00), (0.1000) ^\d+(\.\d*[1-9])?$
既然这样，下面的大部分内容就是评论如果你试图聪明地使用正则expression式可以得到多么复杂，为什么你应该寻求替代方法。 阅读风险自负。
这是一个非常普遍的任务，但是我在这里看到的所有答案都将接受与您的数字格式不匹配的input，例如9,9,9或甚至.,,. 。 即使数字embedded在其他文本中，这也足以解决问题。 恕我直言，任何不能拉1,234.56和1234- ，只有那些数字 – abc22 1,234.56 9.9.9.9 def 1234是错误的答案。
首先，如果你不需要在一个正则expression式中完成这一切，不要。 对于两种不同数字格式的单个正则expression式即使没有embedded到其他文本中也难以维护。 你真正应该做的是把整个事情分割成空白，然后在结果上运行两到三个较小的正则expression式。 如果这不适合你，请继续阅读。
基本模式
考虑到你给出的例子，这里有一个简单的正则expression式，它允许几乎所有的0000格式的整数或小数，并阻止其他的一切：
^\d*\.?\d+$
这是一个需要0,000格式的文件：
^\d{1,3}(,\d{3})*(\.\d+)?$
把它们放在一起，只要一致，逗号就变成可选的：
^(\d*\.?\d+|\d{1,3}(,\d{3})*(\.\d+)?)$
embedded号码
上面的模式要求整个input是一个数字。 你正在寻找embedded文本的数字，所以你必须放松那部分。 另一方面，你不希望它看到catch22并认为它是22号。如果你正在使用一些支持catch22的东西（比如.NET），这很容易：把^replace成(?<!\S)和$ (?!\S) ，你很好去：
(?<!\S)(\d*\.?\d+|\d{1,3}(,\d{3})*(\.\d+)?)(?!\S)
如果你正在使用JavaScript或Ruby或其他东西，事情开始看起来更复杂：
(?:^|\s)(\d*\.?\d+|\d{1,3}(?:,\d{3})*(?:\.\d+)?)(?!\S)
你将不得不使用捕获组; 我不能想到一个替代scheme，没有向后看的支持。 你想要的数字将在第1组（假设整个比赛是组0）。
validation和更复杂的规则
我认为这涵盖了你的问题，所以如果这是你所需要的，现在停止阅读。 如果你想更有趣，事情变得非常复杂。 根据您的情况，您可能想要阻止以下任何或全部内容：
- 空input
- 领先的零（例如000123）
- 尾随零（例如1.2340000）
- 以小数点开始的小数（例如.001而不是0.001）
只是为了它的地狱，让我们假设你想阻止前3，但允许最后一个。 你该怎么办？ 我会告诉你你应该做什么，你应该为每个规则使用不同的正则expression式，逐步缩小你的匹配。 但是为了这个挑战，下面是你如何在一个巨大的模式中做到这一点：
(?<!\S)(?=.)(0|([1-9](\d*|\d{0,2}(,\d{3})*)))?(\.\d*[1-9])?(?!\S)
这意味着什么：
(?<!\S) to (?!\S) #The whole match must be surrounded by either whitespace or line boundaries. So if you see something bogus like :;:9.:, ignore the 9. (?=.) #The whole thing can't be blank. ( #Rules for the integer part: 0 #1. The integer part could just be 0... | # [1-9] # ...otherwise, it can't have leading zeroes. ( # \d* #2. It could use no commas at all... | # \d{0,2}(,\d{3})* # ...or it could be comma-separated groups of 3 digits each. ) # )? #3. Or there could be no integer part at all. ( #Rules for the decimal part: \. #1. It must start with a decimal point... \d* #2. ...followed by a string of numeric digits only. [1-9] #3. It can't be just the decimal point, and it can't end in 0. )? #4. The whole decimal part is also optional. Remember, we checked at the beginning to make sure the whole thing wasn't blank.
testing这里： http : //rextester.com/YPG96786
这将允许像这样的事情：
100,000 999.999 90.0009 1,000,023.999 0.111 .111 0
它会阻止像这样的东西：
1,1,1.111 000,001.111 999. 0. 111.110000 1.1.1.111 9.909,888
有几种方法可以使这个正则expression式更简单和更短，但是要明白，改变模式会放松它认为的数字。
由于许多正则expression式引擎（例如，JavaScript和Ruby）不支持负向倒序，正确执行此操作的唯一方法是使用捕获组：
(:?^|\s)(?=.)((?:0|(?:[1-9](?:\d*|\d{0,2}(?:,\d{3})*)))?(?:\.\d*[1-9])?)(?!\S)
您要查找的数字将在捕获组1中。
testing在这里： http : //rubular.com/r/3HCSkndzhT
最后一个音符
显然，这是一个庞大，复杂，难以理解的正则expression式。 我喜欢这个挑战，但是你应该考虑你是否真的想在生产环境中使用它。 不要试图一步到位，你可以在两个方面做到这一点：一个正则expression式来捕捉可能是一个数字的任何东西，然后是另一个去除任何不是数字的东西。 或者你可以做一些基本的处理，然后使用你的语言内置的数字parsingfunction。 你的select。
几天前，我曾经处理过从数字串中去掉尾随零的问题 。
在这个问题的连续性中，我觉得这个问题很有意思，因为它将问题扩大到包含逗号的数字。
我已经采用了我曾经写过的正则expression式的模式，并对其进行了改进，以便可以用逗号来对待这些数字，作为此问题的答案。
我被我的热情和我喜欢的正规performance感染了。 我不知道这个结果是否恰好符合迈克尔·普雷斯科特（Michael Prescott）所expression的需要。 我有兴趣知道在我的正则expression式中过多或缺乏的要点，并纠正它，使它更适合你。
现在经过这个正则expression式的长时间的工作之后，我脑中有一种沉重的感觉，所以我不够新鲜，不能给出很多的解释。 如果分数不明确，如果有人可能有兴趣，请问我。
正则expression式的构build是为了能够检测到用科学记数法2E10或者甚至是5,224,454.12E-00.0478表示的数字，也可以在这些数字的两部分中去除不必要的零。 如果指数等于零，则数字被修改，以便不再有指数。
我在模式中进行了一些validation，以便某些特定情况不匹配，例如'12.57'将不匹配。 但是，在'111'中 ，string'111'匹配，因为前面的逗号被认为是不是数字的逗号，而是句子的逗号。
我认为应该改进逗号的pipe理，因为在我看来，在印度的编号之间逗号之间只有两位数字。 我认为，纠正并不困难
这里是一个代码，演示了我的正则expression式如何工作。 有两个函数，根据是否需要将数字“.1245”转换为“ 0.1245” 。 如果在某些string的情况下错误或不需要的匹配或不匹配，我不会感到惊讶; 那么我想知道这些情况来理解和纠正这个缺陷。
我为使用Python编写的代码表示歉意，但是正则expression式是跨语言的，我认为每个人都有能力去除reex的模式
import re regx = re.compile('(?<![\d.])(?!\.\.)(?<![\d.][eE][+-])(?<![\d.][eE])(?<!\d[.,])' '' #--------------------------------- '([+-]?)' '(?![\d,]*?\.[\d,]*?\.[\d,]*?)' '(?:0|,(?=0)|(?<!\d),)*' '(?:' '((?:\d(?!\.[1-9])|,(?=\d))+)[.,]?' '|\.(0)' '|((?<!\.)\.\d+?)' '|([\d,]+\.\d+?))' '0*' '' #--------------------------------- '(?:' '([eE][+-]?)(?:0|,(?=0))*' '(?:' '(?!0+(?=\D|\Z))((?:\d(?!\.[1-9])|,(?=\d))+)[.,]?' '|((?<!\.)\.(?!0+(?=\D|\Z))\d+?)' '|([\d,]+\.(?!0+(?=\D|\Z))\d+?))' '0*' ')?' '' #--------------------------------- '(?![.,]?\d)') def dzs_numbs(x,regx = regx): # ds = detect and zeros-shave if not regx.findall(x): yield ('No match,', 'No catched string,', 'No groups.') for mat in regx.finditer(x): yield (mat.group(), ''.join(mat.groups('')), mat.groups('')) def dzs_numbs2(x,regx = regx): # ds = detect and zeros-shave if not regx.findall(x): yield ('No match,', 'No catched string,', 'No groups.') for mat in regx.finditer(x): yield (mat.group(), ''.join(('0' if n.startswith('.') else '')+n for n in mat.groups('')), mat.groups('')) NS = [' 23456000and23456000. or23456000.000 00023456000 s000023456000. 000023456000.000 ', 'arf 10000 sea10000.+10000.000 00010000-00010000. kant00010000.000 ', ' 24: 24, 24. 24.000 24.000, 00024r 00024. blue 00024.000 ', ' 8zoom8. 8.000 0008 0008. and0008.000 ', ' 0 00000M0. = 000. 0.0 0.000 000.0 000.000 .000000 .0 ', ' .0000023456 .0000023456000 ' ' .0005872 .0005872000 .00503 .00503000 ', ' .068 .0680000 .8 .8000 .123456123456 .123456123456000 ', ' .657 .657000 .45 .4500000 .7 .70000 0.0000023230000 000.0000023230000 ', ' 0.0081000 0000.0081000 0.059000 0000.059000 ', ' 0.78987400000 snow 00000.78987400000 0.4400000 00000.4400000 ', ' -0.5000 -0000.5000 0.90 000.90 0.7 000.7 ', ' 2.6 00002.6 00002.60000 4.71 0004.71 0004.7100 ', ' 23.49 00023.49 00023.490000 103.45 0000103.45 0000103.45000 ', ' 10003.45067 000010003.45067 000010003.4506700 ', ' +15000.0012 +000015000.0012 +000015000.0012000 ', ' 78000.89 000078000.89 000078000.89000 ', ' .0457e10 .0457000e10 00000.0457000e10 ', ' 258e8 2580000e4 0000000002580000e4 ', ' 0.782e10 0000.782e10 0000.7820000e10 ', ' 1.23E2 0001.23E2 0001.2300000E2 ', ' 432e-102 0000432e-102 004320000e-106 ', ' 1.46e10and0001.46e10 0001.4600000e10 ', ' 1.077e-300 0001.077e-300 0001.077000e-300 ', ' 1.069e10 0001.069e10 0001.069000e10 ', ' 105040.03e10 000105040.03e10 105040.0300e10 ', ' +286E000024.487900 -78.4500e.14500 .0140E789. ', ' 081,12.40E07,95.0120 0045,78,123.03500e-0.00 ', ' 0096,78,473.0380e-0. 0008,78,373.066000E0. 0004512300.E0000 ', ' ..18000 25..00 36...77 2..8 ', ' 3.8..9 .12500. 12.51.400 ', ' 00099,111.8713000 -0012,45,83,987.26+0.000,099,88,44.or00,00,00.00must', ' 00099,44,and 0000,099,88,44.bom', '00,000,00.587000 77,98,23,45., this,that ', ' ,111 145.20 +9,9,9 0012800 .,,. 1 100,000 ', '1,1,1.111 000,001.111 -999. 0. 111.110000 1.1.1.111 9.909,888'] for ch in NS: print 'string: '+repr(ch) for strmatch, modified, the_groups in dzs_numbs2(ch): print strmatch.rjust(20),'',modified,'',the_groups print
结果
string: ' 23456000and23456000. or23456000.000 00023456000 s000023456000. 000023456000.000 ' 23456000 23456000 ('', '23456000', '', '', '', '', '', '', '') 23456000. 23456000 ('', '23456000', '', '', '', '', '', '', '') 23456000.000 23456000 ('', '23456000', '', '', '', '', '', '', '') 00023456000 23456000 ('', '23456000', '', '', '', '', '', '', '') 000023456000. 23456000 ('', '23456000', '', '', '', '', '', '', '') 000023456000.000 23456000 ('', '23456000', '', '', '', '', '', '', '') string: 'arf 10000 sea10000.+10000.000 00010000-00010000. kant00010000.000 ' 10000 10000 ('', '10000', '', '', '', '', '', '', '') 10000. 10000 ('', '10000', '', '', '', '', '', '', '') 10000.000 10000 ('', '10000', '', '', '', '', '', '', '') 00010000 10000 ('', '10000', '', '', '', '', '', '', '') 00010000. 10000 ('', '10000', '', '', '', '', '', '', '') 00010000.000 10000 ('', '10000', '', '', '', '', '', '', '') string: ' 24: 24, 24. 24.000 24.000, 00024r 00024. blue 00024.000 ' 24 24 ('', '24', '', '', '', '', '', '', '') 24, 24 ('', '24', '', '', '', '', '', '', '') 24. 24 ('', '24', '', '', '', '', '', '', '') 24.000 24 ('', '24', '', '', '', '', '', '', '') 24.000 24 ('', '24', '', '', '', '', '', '', '') 00024 24 ('', '24', '', '', '', '', '', '', '') 00024. 24 ('', '24', '', '', '', '', '', '', '') 00024.000 24 ('', '24', '', '', '', '', '', '', '') string: ' 8zoom8. 8.000 0008 0008. and0008.000 ' 8 8 ('', '8', '', '', '', '', '', '', '') 8. 8 ('', '8', '', '', '', '', '', '', '') 8.000 8 ('', '8', '', '', '', '', '', '', '') 0008 8 ('', '8', '', '', '', '', '', '', '') 0008. 8 ('', '8', '', '', '', '', '', '', '') 0008.000 8 ('', '8', '', '', '', '', '', '', '') string: ' 0 00000M0. = 000. 0.0 0.000 000.0 000.000 .000000 .0 ' 0 0 ('', '0', '', '', '', '', '', '', '') 00000 0 ('', '0', '', '', '', '', '', '', '') 0. 0 ('', '0', '', '', '', '', '', '', '') 000. 0 ('', '0', '', '', '', '', '', '', '') 0.0 0 ('', '', '0', '', '', '', '', '', '') 0.000 0 ('', '', '0', '', '', '', '', '', '') 000.0 0 ('', '', '0', '', '', '', '', '', '') 000.000 0 ('', '', '0', '', '', '', '', '', '') .000000 0 ('', '', '0', '', '', '', '', '', '') .0 0 ('', '', '0', '', '', '', '', '', '') string: ' .0000023456 .0000023456000 .0005872 .0005872000 .00503 .00503000 ' .0000023456 0.0000023456 ('', '', '', '.0000023456', '', '', '', '', '') .0000023456000 0.0000023456 ('', '', '', '.0000023456', '', '', '', '', '') .0005872 0.0005872 ('', '', '', '.0005872', '', '', '', '', '') .0005872000 0.0005872 ('', '', '', '.0005872', '', '', '', '', '') .00503 0.00503 ('', '', '', '.00503', '', '', '', '', '') .00503000 0.00503 ('', '', '', '.00503', '', '', '', '', '') string: ' .068 .0680000 .8 .8000 .123456123456 .123456123456000 ' .068 0.068 ('', '', '', '.068', '', '', '', '', '') .0680000 0.068 ('', '', '', '.068', '', '', '', '', '') .8 0.8 ('', '', '', '.8', '', '', '', '', '') .8000 0.8 ('', '', '', '.8', '', '', '', '', '') .123456123456 0.123456123456 ('', '', '', '.123456123456', '', '', '', '', '') .123456123456000 0.123456123456 ('', '', '', '.123456123456', '', '', '', '', '') string: ' .657 .657000 .45 .4500000 .7 .70000 0.0000023230000 000.0000023230000 ' .657 0.657 ('', '', '', '.657', '', '', '', '', '') .657000 0.657 ('', '', '', '.657', '', '', '', '', '') .45 0.45 ('', '', '', '.45', '', '', '', '', '') .4500000 0.45 ('', '', '', '.45', '', '', '', '', '') .7 0.7 ('', '', '', '.7', '', '', '', '', '') .70000 0.7 ('', '', '', '.7', '', '', '', '', '') 0.0000023230000 0.000002323 ('', '', '', '.000002323', '', '', '', '', '') 000.0000023230000 0.000002323 ('', '', '', '.000002323', '', '', '', '', '') string: ' 0.0081000 0000.0081000 0.059000 0000.059000 ' 0.0081000 0.0081 ('', '', '', '.0081', '', '', '', '', '') 0000.0081000 0.0081 ('', '', '', '.0081', '', '', '', '', '') 0.059000 0.059 ('', '', '', '.059', '', '', '', '', '') 0000.059000 0.059 ('', '', '', '.059', '', '', '', '', '') string: ' 0.78987400000 snow 00000.78987400000 0.4400000 00000.4400000 ' 0.78987400000 0.789874 ('', '', '', '.789874', '', '', '', '', '') 00000.78987400000 0.789874 ('', '', '', '.789874', '', '', '', '', '') 0.4400000 0.44 ('', '', '', '.44', '', '', '', '', '') 00000.4400000 0.44 ('', '', '', '.44', '', '', '', '', '') string: ' -0.5000 -0000.5000 0.90 000.90 0.7 000.7 ' -0.5000 -0.5 ('-', '', '', '.5', '', '', '', '', '') -0000.5000 -0.5 ('-', '', '', '.5', '', '', '', '', '') 0.90 0.9 ('', '', '', '.9', '', '', '', '', '') 000.90 0.9 ('', '', '', '.9', '', '', '', '', '') 0.7 0.7 ('', '', '', '.7', '', '', '', '', '') 000.7 0.7 ('', '', '', '.7', '', '', '', '', '') string: ' 2.6 00002.6 00002.60000 4.71 0004.71 0004.7100 ' 2.6 2.6 ('', '', '', '', '2.6', '', '', '', '') 00002.6 2.6 ('', '', '', '', '2.6', '', '', '', '') 00002.60000 2.6 ('', '', '', '', '2.6', '', '', '', '') 4.71 4.71 ('', '', '', '', '4.71', '', '', '', '') 0004.71 4.71 ('', '', '', '', '4.71', '', '', '', '') 0004.7100 4.71 ('', '', '', '', '4.71', '', '', '', '') string: ' 23.49 00023.49 00023.490000 103.45 0000103.45 0000103.45000 ' 23.49 23.49 ('', '', '', '', '23.49', '', '', '', '') 00023.49 23.49 ('', '', '', '', '23.49', '', '', '', '') 00023.490000 23.49 ('', '', '', '', '23.49', '', '', '', '') 103.45 103.45 ('', '', '', '', '103.45', '', '', '', '') 0000103.45 103.45 ('', '', '', '', '103.45', '', '', '', '') 0000103.45000 103.45 ('', '', '', '', '103.45', '', '', '', '') string: ' 10003.45067 000010003.45067 000010003.4506700 ' 10003.45067 10003.45067 ('', '', '', '', '10003.45067', '', '', '', '') 000010003.45067 10003.45067 ('', '', '', '', '10003.45067', '', '', '', '') 000010003.4506700 10003.45067 ('', '', '', '', '10003.45067', '', '', '', '') string: ' +15000.0012 +000015000.0012 +000015000.0012000 ' +15000.0012 +15000.0012 ('+', '', '', '', '15000.0012', '', '', '', '') +000015000.0012 +15000.0012 ('+', '', '', '', '15000.0012', '', '', '', '') +000015000.0012000 +15000.0012 ('+', '', '', '', '15000.0012', '', '', '', '') string: ' 78000.89 000078000.89 000078000.89000 ' 78000.89 78000.89 ('', '', '', '', '78000.89', '', '', '', '') 000078000.89 78000.89 ('', '', '', '', '78000.89', '', '', '', '') 000078000.89000 78000.89 ('', '', '', '', '78000.89', '', '', '', '') string: ' .0457e10 .0457000e10 00000.0457000e10 ' .0457e10 0.0457e10 ('', '', '', '.0457', '', 'e', '10', '', '') .0457000e10 0.0457e10 ('', '', '', '.0457', '', 'e', '10', '', '') 00000.0457000e10 0.0457e10 ('', '', '', '.0457', '', 'e', '10', '', '') string: ' 258e8 2580000e4 0000000002580000e4 ' 258e8 258e8 ('', '258', '', '', '', 'e', '8', '', '') 2580000e4 2580000e4 ('', '2580000', '', '', '', 'e', '4', '', '') 0000000002580000e4 2580000e4 ('', '2580000', '', '', '', 'e', '4', '', '') string: ' 0.782e10 0000.782e10 0000.7820000e10 ' 0.782e10 0.782e10 ('', '', '', '.782', '', 'e', '10', '', '') 0000.782e10 0.782e10 ('', '', '', '.782', '', 'e', '10', '', '') 0000.7820000e10 0.782e10 ('', '', '', '.782', '', 'e', '10', '', '') string: ' 1.23E2 0001.23E2 0001.2300000E2 ' 1.23E2 1.23E2 ('', '', '', '', '1.23', 'E', '2', '', '') 0001.23E2 1.23E2 ('', '', '', '', '1.23', 'E', '2', '', '') 0001.2300000E2 1.23E2 ('', '', '', '', '1.23', 'E', '2', '', '') string: ' 432e-102 0000432e-102 004320000e-106 ' 432e-102 432e-102 ('', '432', '', '', '', 'e-', '102', '', '') 0000432e-102 432e-102 ('', '432', '', '', '', 'e-', '102', '', '') 004320000e-106 4320000e-106 ('', '4320000', '', '', '', 'e-', '106', '', '') string: ' 1.46e10and0001.46e10 0001.4600000e10 ' 1.46e10 1.46e10 ('', '', '', '', '1.46', 'e', '10', '', '') 0001.46e10 1.46e10 ('', '', '', '', '1.46', 'e', '10', '', '') 0001.4600000e10 1.46e10 ('', '', '', '', '1.46', 'e', '10', '', '') string: ' 1.077e-300 0001.077e-300 0001.077000e-300 ' 1.077e-300 1.077e-300 ('', '', '', '', '1.077', 'e-', '300', '', '') 0001.077e-300 1.077e-300 ('', '', '', '', '1.077', 'e-', '300', '', '') 0001.077000e-300 1.077e-300 ('', '', '', '', '1.077', 'e-', '300', '', '') string: ' 1.069e10 0001.069e10 0001.069000e10 ' 1.069e10 1.069e10 ('', '', '', '', '1.069', 'e', '10', '', '') 0001.069e10 1.069e10 ('', '', '', '', '1.069', 'e', '10', '', '') 0001.069000e10 1.069e10 ('', '', '', '', '1.069', 'e', '10', '', '') string: ' 105040.03e10 000105040.03e10 105040.0300e10 ' 105040.03e10 105040.03e10 ('', '', '', '', '105040.03', 'e', '10', '', '') 000105040.03e10 105040.03e10 ('', '', '', '', '105040.03', 'e', '10', '', '') 105040.0300e10 105040.03e10 ('', '', '', '', '105040.03', 'e', '10', '', '') string: ' +286E000024.487900 -78.4500e.14500 .0140E789. ' +286E000024.487900 +286E24.4879 ('+', '286', '', '', '', 'E', '', '', '24.4879') -78.4500e.14500 -78.45e0.145 ('-', '', '', '', '78.45', 'e', '', '.145', '') .0140E789. 0.014E789 ('', '', '', '.014', '', 'E', '789', '', '') string: ' 081,12.40E07,95.0120 0045,78,123.03500e-0.00 ' 081,12.40E07,95.0120 81,12.4E7,95.012 ('', '', '', '', '81,12.4', 'E', '', '', '7,95.012') 0045,78,123.03500 45,78,123.035 ('', '', '', '', '45,78,123.035', '', '', '', '') string: ' 0096,78,473.0380e-0. 0008,78,373.066000E0. 0004512300.E0000 ' 0096,78,473.0380 96,78,473.038 ('', '', '', '', '96,78,473.038', '', '', '', '') 0008,78,373.066000 8,78,373.066 ('', '', '', '', '8,78,373.066', '', '', '', '') 0004512300. 4512300 ('', '4512300', '', '', '', '', '', '', '') string: ' ..18000 25..00 36...77 2..8 ' No match, No catched string, No groups. string: ' 3.8..9 .12500. 12.51.400 ' No match, No catched string, No groups. string: ' 00099,111.8713000 -0012,45,83,987.26+0.000,099,88,44.or00,00,00.00must' 00099,111.8713000 99,111.8713 ('', '', '', '', '99,111.8713', '', '', '', '') -0012,45,83,987.26 -12,45,83,987.26 ('-', '', '', '', '12,45,83,987.26', '', '', '', '') 00,00,00.00 0 ('', '', '0', '', '', '', '', '', '') string: ' 00099,44,and 0000,099,88,44.bom' 00099,44, 99,44 ('', '99,44', '', '', '', '', '', '', '') 0000,099,88,44. 99,88,44 ('', '99,88,44', '', '', '', '', '', '', '') string: '00,000,00.587000 77,98,23,45., this,that ' 00,000,00.587000 0.587 ('', '', '', '.587', '', '', '', '', '') 77,98,23,45. 77,98,23,45 ('', '77,98,23,45', '', '', '', '', '', '', '') string: ' ,111 145.20 +9,9,9 0012800 .,,. 1 100,000 ' ,111 111 ('', '111', '', '', '', '', '', '', '') 145.20 145.2 ('', '', '', '', '145.2', '', '', '', '') +9,9,9 +9,9,9 ('+', '9,9,9', '', '', '', '', '', '', '') 0012800 12800 ('', '12800', '', '', '', '', '', '', '') 1 1 ('', '1', '', '', '', '', '', '', '') 100,000 100,000 ('', '100,000', '', '', '', '', '', '', '') string: '1,1,1.111 000,001.111 -999. 0. 111.110000 1.1.1.111 9.909,888' 1,1,1.111 1,1,1.111 ('', '', '', '', '1,1,1.111', '', '', '', '') 000,001.111 1.111 ('', '', '', '', '1.111', '', '', '', '') -999. -999 ('-', '999', '', '', '', '', '', '', '') 0. 0 ('', '0', '', '', '', '', '', '', '') 111.110000 111.11 ('', '', '', '', '111.11', '', '', '', '')
采取一定的自由与要求，你正在寻找
\d+([\d,]?\d)*(\.\d+)?
但请注意，这将匹配例如11,11,1
\d+(,\d+)*(\.\d+)?
这假定在逗号或小数之前或之后总是至less有一位数字，并且假设至多有一位小数，并且所有逗号都在小数位之前。
下面的正则expression式将匹配你的例子中的两个数字。
\b\d[\d,.]*\b
它将返回5000和99,999.99998713 – 符合您的要求。
这是另一种以最简单的数字格式开始的结构，然后以不重叠的方式逐步添加更复杂的数字格式：
Java的regep：
(\d)|([1-9]\d+)|(\.\d+)|(\d\.\d*)|([1-9]\d+\.\d*)|([1-9]\d{0,2}(,\d{3})+(\.\d*)?)
作为一个Javastring（注意额外\需要转义为\和。因为\和。在自己的正则expression式中有特殊含义）：
String myregexp="(\\d)|([1-9]\\d+)|(\\.\\d+)|(\\d\\.\\d*)|([1-9]\\d+\\.\\d*)|([1-9]\\d{0,2}(,\\d{3})+(\\.\\d*)?)";
说明：
-
这个正则expression式的forms是A | B | C | D | E | F，其中A，B，C，D，E，F本身是不重叠的正则expression式。 一般来说，我觉得从最简单的可能匹配开始比较容易。如果A错过了你想要的匹配，那么创build一个B，它是对A的一个小修改，并且包含更多你想要的内容。 然后，基于B创build一个捕获更多的C等。我也发现创build不重叠的正则expression式更容易; 理解20个简单的非重叠正则expression式与OR相关的正则expression式更容易理解，而不是一些具有更复杂匹配的正则expression式。 但是，每一个都是属于自己的！
-
A是（\ d），恰好匹配0,1,2,3,4,5,6,7,8,9中的一个，不能简单一些！
-
B是（[1-9] \ d +），只匹配2位或更多位的数字，第一位不包括0。 B完全匹配10,11,12中的一个，… B不重叠A，而是A的小修改。
-
C是（。\ d +），并且只匹配一个小数，后跟一个或多个数字。 C恰好匹配.0 .1.2 .3 .4 .5 .6 .7 .8 .9 .00 .01 .02 …之一。 .23000 … C允许在我喜欢的右边跟随eros：如果这是测量数据，尾随零的数量表示精确度。 如果你不想在右边结尾的零，把（。\ d +）改为（。\ d * [1-9]），但是这也排除了我认为应该允许的.0。 C也是A的一个小修改。
-
D是（\ d。\ d *），它是A加小数，右边是尾随零。 D只匹配一个数字，后跟一个小数，后跟零个或多个数字。 D匹配0. 0.0 0.1 0.2 …. 0.01000 … 9。 9.0 9.1..0.0230000 …. 9.9999999999 …如果要排除“0” 然后将D更改为（\ d。\ d +）。 如果你想排除右侧的尾部零，把D改为（\ d。\ d * [1-9]），但是这个排除了我认为应该包含的2.0。 D不重叠A，B或C.
-
E是（[1-9] \ d +。\ d *），它是B加小数，右边是尾随零。 例如，如果要排除“13.”，则将E更改为（[1-9] \ d +。\ d +）。 E不与A，B，C或D重叠。E匹配10. 10.0 10.0100 …. 99.9999999999 …可以按照4.和5处理尾随零。
-
F是（[1-9] \ d {0,2}（，\ d {3}）+（。\ d *）？），并且只能用逗号和可能的小数来匹配数字，允许右边的尾随零。 第一组（[1-9] \ d {0,2}）匹配一个非零数字，然后是零个，另外一个或两个数字。 第二组（\ d {3}）+匹配一个4个字符的组（一个逗号后跟三个数字），这个组可以匹配一次或多次（不匹配表示没有逗号！）。 最后，（。\ d *）？ 什么都不匹配，或匹配。 本身，或匹配一个小数。 接着是任意数字，可能没有。 再次，要排除诸如“1,111”之类的内容，请将（。\ d *）更改为（。\ d +）。 Trailing zeros can be handled as in 4. or 5. F does not overlap A,B,C,D, or E. I couldn't think of an easier regexp for F.
Let me know if you are interested and I can edit above to handle the trailing zeros on the right as desired.
Here is what matches regexp and what does not:
0 1 02 <- invalid 20 22 003 <- invalid 030 <- invalid 300 033 <- invalid 303 330 333 0004 <- invalid 0040 <- invalid 0400 <- invalid 4000 0044 <- invalid 0404 <- invalid 0440 <- invalid 4004 4040 4400 0444 <- invalid 4044 4404 4440 4444 00005 <- invalid 00050 <- invalid 00500 <- invalid 05000 <- invalid 50000 00055 <- invalid 00505 <- invalid 00550 <- invalid 05050 <- invalid 05500 <- invalid 50500 55000 00555 <- invalid 05055 <- invalid 05505 <- invalid 05550 <- invalid 50550 55050 55500 . <- invalid .. <- invalid .0 0. .1 1. .00 0.0 00. <- invalid .02 0.2 02. <- invalid .20 2.0 20. .22 2.2 22. .000 0.00 00.0 <- invalid 000. <- invalid .003 0.03 00.3 <- invalid 003. <- invalid .030 0.30 03.0 <- invalid 030. <- invalid .033 0.33 03.3 <- invalid 033. <- invalid .303 3.03 30.3 303. .333 3.33 33.3 333. .0000 0.000 00.00 <- invalid 000.0 <- invalid 0000. <- invalid .0004 0.0004 00.04 <- invalid 000.4 <- invalid 0004. <- invalid .0044 0.044 00.44 <- invalid 004.4 <- invalid 0044. <- invalid .0404 0.404 04.04 <- invalid 040.4 <- invalid 0404. <- invalid .0444 0.444 04.44 <- invalid 044.4 <- invalid 0444. <- invalid .4444 4.444 44.44 444.4 4444. .00000 0.0000 00.000 <- invalid 000.00 <- invalid 0000.0 <- invalid 00000. <- invalid .00005 0.0005 00.005 <- invalid 000.05 <- invalid 0000.5 <- invalid 00005. <- invalid .00055 0.0055 00.055 <- invalid 000.55 <- invalid 0005.5 <- invalid 00055. <- invalid .00505 0.0505 00.505 <- invalid 005.05 <- invalid 0050.5 <- invalid 00505. <- invalid .00550 0.0550 00.550 <- invalid 005.50 <- invalid 0055.0 <- invalid 00550. <- invalid .05050 0.5050 05.050 <- invalid 050.50 <- invalid 0505.0 <- invalid 05050. <- invalid .05500 0.5500 05.500 <- invalid 055.00 <- invalid 0550.0 <- invalid 05500. <- invalid .50500 5.0500 50.500 505.00 5050.0 50500. .55000 5.5000 55.000 550.00 5500.0 55000. .00555 0.0555 00.555 <- invalid 005.55 <- invalid 0055.5 <- invalid 00555. <- invalid .05055 0.5055 05.055 <- invalid 050.55 <- invalid 0505.5 <- invalid 05055. <- invalid .05505 0.5505 05.505 <- invalid 055.05 <- invalid 0550.5 <- invalid 05505. <- invalid .05550 0.5550 05.550 <- invalid 055.50 <- invalid 0555.0 <- invalid 05550. <- invalid .50550 5.0550 50.550 505.50 5055.0 50550. .55050 5.5050 55.050 550.50 5505.0 55050. .55500 5.5500 55.500 555.00 5550.0 55500. .05555 0.5555 05.555 <- invalid 055.55 <- invalid 0555.5 <- invalid 05555. <- invalid .50555 5.0555 50.555 505.55 5055.5 50555. .55055 5.5055 55.055 550.55 5505.5 55055. .55505 5.5505 55.505 555.05 5550.5 55505. .55550 5.5550 55.550 555.50 5555.0 55550. .55555 5.5555 55.555 555.55 5555.5 55555. , <- invalid ,, <- invalid 1, <- invalid ,1 <- invalid 22, <- invalid 2,2 <- invalid ,22 <- invalid 2,2, <- invalid 2,2, <- invalid ,22, <- invalid 333, <- invalid 33,3 <- invalid 3,33 <- invalid ,333 <- invalid 3,33, <- invalid 3,3,3 <- invalid 3,,33 <- invalid ,,333 <- invalid 4444, <- invalid 444,4 <- invalid 44,44 <- invalid 4,444 ,4444 <- invalid 55555, <- invalid 5555,5 <- invalid 555,55 <- invalid 55,555 5,5555 <- invalid ,55555 <- invalid 666666, <- invalid 66666,6 <- invalid 6666,66 <- invalid 666,666 66,6666 <- invalid 6,66666 <- invalid 66,66,66 <- invalid 6,66,666 <- invalid ,666,666 <- invalid 1,111. 1,111.11 1,111.110 01,111.110 <- invalid 0,111.100 <- invalid 11,11. <- invalid 1,111,.11 <- invalid 1111.1,10 <- invalid 01111.11,0 <- invalid 0111.100, <- invalid 1,111,111. 1,111,111.11 1,111,111.110 01,111,111.110 <- invalid 0,111,111.100 <- invalid 1,111,111. 1,1111,11.11 <- invalid 11,111,11.110 <- invalid 01,11,1111.110 <- invalid 0,111111.100 <- invalid 0002,22.2230 <- invalid .,5.,., <- invalid 2.0,345,345 <- invalid 2.334.456 <- invalid
This regex:
(\d{1,3},\d{3}(,\d{3})*)(\.\d*)?|\d+\.?\d*
Matched every number in the string:
1 1.0 0.1 1.001 1,000 1,000,000 1000.1 1,000.1 1,323,444,000 1,999 1,222,455,666.0 1,244
Here's a regex:
(?:\d+)((\d{1,3})*([\,\ ]\d{3})*)(\.\d+)?
that accepts numbers:
- without spaces and/or decimals, eg.
123456789,123.123 - with commas or spaces as thousands separator and/or decimals, eg.
123 456 789,123 456 789.100,123,456,3,232,300,000.00
Tests: http://regexr.com/3h1a2
