Регулярное выражение для сопоставления чисел с запятыми или без запятых в тексте
Я пытаюсь найти и заменить все числа в тексте. Я нашел несколько примеров регулярных выражений, которые почти решают проблему, но ни один еще не идеален. У меня проблема в том, что числа в моем тексте могут иметь или не иметь десятичные и запятые. Например:
"5000-фунтовая лиса перепрыгнула через 99,999.99998713 футов".
Регулярное выражение должно вернуться5000" а также "99,999.99998713". Примеры, которые я нашел, разбивают числа на запятой или ограничены двумя десятичными знаками. Я начинаю понимать достаточно регулярных выражений, чтобы понять, почему некоторые примеры ограничены двумя десятичными знаками, но я еще не изучил как преодолеть это, а также включить запятую, чтобы получить всю последовательность.
Вот моя последняя версия:
[0-9]+(\.[0-9][0-9]?)?
Который возвращается5000","99,99","9.99", а также "998713"для приведенного выше текста.
11 ответов
РЕДАКТИРОВАТЬ: Так как это получило много мнений, позвольте мне начать с того, чтобы дать всем то, что они гуглили:
#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])?$
Теперь, когда это не так, большинство из следующего предназначено в качестве комментария о том, как сложное регулярное выражение может получить, если вы пытаетесь быть умным с ним, и почему вы должны искать альтернативы. Читайте на свой страх и риск.
Это очень распространенная задача, но все ответы, которые я вижу здесь до сих пор, будут принимать входные данные, которые не соответствуют вашему числовому формату, такие как ,111, 9,9,9, или даже .,,., Это достаточно просто исправить, даже если числа встроены в другой текст. ИМХО все, что не может тянуть 1234,56 и 1234 -и только эти цифры - из abc22 1,234.56 9.9.9.9 def 1234 неправильный ответ
Прежде всего, если вам не нужно делать все это в одном регулярном выражении, не делайте этого. Трудно поддерживать одно регулярное выражение для двух разных числовых форматов, даже если они не встроены в другой текст. Что вам действительно нужно сделать, так это разделить все на пустое пространство, а затем выполнить два или три меньших регулярных выражения для результатов. Если это не вариант для вас, продолжайте читать.
Основная модель
Рассматривая приведенные вами примеры, вот простое регулярное выражение, которое допускает практически любое целое или десятичное число в 0000 отформатировать и заблокировать все остальное:
^\d*\.?\d+$
Вот тот, который требует 0,000 формат:
^\d{1,3}(,\d{3})*(\.\d+)?$
Поместите их вместе, и запятые станут необязательными, если они согласованы:
^(\d*\.?\d+|\d{1,3}(,\d{3})*(\.\d+)?)$
Встроенные номера
Шаблоны выше требуют, чтобы весь ввод был числом. Вы ищете цифры, встроенные в текст, поэтому вы должны ослабить эту часть. С другой стороны, вы не хотите это видеть catch22 и думаю, что он нашел число 22. Если вы используете что-то с поддержкой lookbehind (например,.NET), это довольно просто: заменить ^ с (?<!\S) а также $ с (?!\S) и тебе хорошо идти
(?<!\S)(\d*\.?\d+|\d{1,3}(,\d{3})*(\.\d+)?)(?!\S)
Если вы работаете с JavaScript, Ruby или чем-то еще, все становится более сложным:
(?:^|\s)(\d*\.?\d+|\d{1,3}(?:,\d{3})*(?:\.\d+)?)(?!\S)
Вам придется использовать группы захвата; Я не могу придумать альтернативу без поддержки назад. Номера, которые вы хотите, будут в группе 1 (при условии, что все совпадение - это группа 0).
Валидация и более сложные правила
Я думаю, что это покрывает ваш вопрос, поэтому, если это все, что вам нужно, прекратите читать сейчас. Если вы хотите стать более модным, все становится очень сложным очень быстро. В зависимости от вашей ситуации вы можете заблокировать любое или все из следующего:
- Пустой ввод
- Ведущие нули (например, 000123)
- Конечные нули (например, 1.2340000)
- Десятичные знаки, начинающиеся с десятичной точки (например, 0,001, а не 0,001)
Просто ради этого давайте предположим, что вы хотите заблокировать первые 3, но разрешите последний. Что вы должны сделать? Я скажу вам, что вы должны делать, вы должны использовать различные регулярные выражения для каждого правила и постепенно сужать свои совпадения. Но ради вызова, вот как вы делаете все это в одном гигантском паттерне:
(?<!\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.
Протестировано здесь: 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
Есть несколько способов сделать это регулярное выражение проще и короче, но поймите, что изменение шаблона ослабит то, что он считает числом.
Так как многие движки регулярных выражений (например, JavaScript и Ruby) не поддерживают отрицательный взгляд назад, единственный способ сделать это правильно - с помощью групп захвата:
(:?^|\s)(?=.)((?:0|(?:[1-9](?:\d*|\d{0,2}(?:,\d{3})*)))?(?:\.\d*[1-9])?)(?!\S)
Номера, которые вы ищете, будут в группе захвата 1.
Протестировано здесь: http://rubular.com/r/3HCSkndzhT
Последнее замечание
Очевидно, это массивное, сложное, почти нечитаемое регулярное выражение. Мне понравилось, но вы должны подумать, действительно ли вы хотите использовать это в производственной среде. Вместо того, чтобы пытаться сделать все за один шаг, вы можете сделать это за два: регулярное выражение, чтобы поймать все, что может быть числом, затем другое, чтобы отсеять то, что не является числом. Или вы можете выполнить некоторую базовую обработку, а затем использовать встроенные функции синтаксического анализа вашего языка. Твой выбор.
Регулярное выражение ниже будет соответствовать обоим числам из вашего примера.
\b\d[\d,.]*\b
Он вернет 5000 и 99,999.99998713 - в соответствии с вашими требованиями.
Несколько дней назад я работал над проблемой удаления конечных нулей из строки числа.
В продолжении этой проблемы я нахожу эту интересную, поскольку она расширяет проблему до чисел, содержащих запятые.
Я взял шаблон регулярного выражения, который написал в предыдущей задаче, над которой работал, и улучшил его, чтобы он мог рассматривать числа с запятыми как ответ на эту проблему.
Я был увлечен своим энтузиазмом и пристрастием к регулярным выражениям. Я не знаю, соответствует ли результат именно той потребности, о которой говорил Майкл Прескотт. Мне было бы интересно узнать, какие моменты в моем регулярном выражении являются лишними или недостающими, и исправить это, чтобы сделать его более подходящим для вас.
Теперь, после долгого сеанса работы с этим регулярным выражением, у меня в мозгу что-то вроде веса, поэтому я недостаточно свеж, чтобы дать много объяснений. Если пункты неясны, и если кто-то может заинтересоваться, пожалуйста, спросите меня.
Регулярное выражение построено для того, чтобы оно могло обнаруживать числа, выраженные в научной нотации 2E10 или даже 5,22,454.12E-00.0478, удаляя ненужные нули в двух частях таких чисел. Если показатель степени равен нулю, число модифицируется так, что показателя больше нет.
Я добавил в шаблон некоторую проверку, чтобы некоторые конкретные случаи не совпадали, например, " 12..57" не будет совпадать. Но в ',111' строка '111' совпадает, потому что предыдущая запятая считается запятой не в числе, а в запятой предложения.
Я думаю, что управление запятыми должно быть улучшено, потому что мне кажется, что в индийской нумерации между запятыми есть только 2 цифры. Это не будет трудно исправить, я полагаю,
Ниже приведен код, демонстрирующий работу моего регулярного выражения. Есть две функции, в зависимости от того, нужно ли преобразовать числа ".1245" в "0.1245" или нет. Я не удивлюсь, если ошибки или нежелательные совпадения или несоответствия останутся для определенных случаев числовых строк; тогда я хотел бы знать эти случаи, чтобы понять и исправить недостаток.
Я прошу прощения за этот код, написанный на Python, но регулярные выражения являются транс-лингвистическими, и я думаю, что каждый сможет понять паттерн re ex
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+([\d,]?\d)*(\.\d+)?
Но обратите внимание, это будет соответствовать, например, 11,11,1
(,*[\d]+,*[\d]*)+
Это будет соответствовать любому маленькому или большому числу, как следует с запятой или без
1
100
1,262
1,56,262
10,78,999
12,34,56,789
или же
1
100
1262
156262
1078999
123456789
Это регулярное выражение:
(\d{1,3},\d{3}(,\d{3})*)(\.\d*)?|\d+\.?\d*
Соответствует каждому числу в строке:
1 1,00,1 1,001 000 1000 000 1000,1 1 000,1 1 323 444 000 1 999 1 222 455 666,0 1 244
Вот регулярное выражение:
(?:\d+)((\d{1,3})*([\,\ ]\d{3})*)(\.\d+)?
который принимает номера:
- без пробелов и / или десятичных дробей, например.
123456789,123.123 - с запятыми или пробелами в качестве разделителя тысяч и / или десятичных знаков, например.
123 456 789,123 456 789.100,123,456,3,232,300,000.00
Тесты: http://regexr.com/3h1a2
\b\d+,
\b-------> граница слова
\d+------> одна или цифра
,--------> содержащие запятые,
Например:
sddsgg 70 000 sdsfdsf fdgfdg70,00
sfsfsd 5,44,4343 5,7788,44 555
Это будет соответствовать:
70,
5,
44,
, 44
Вот еще одна конструкция, которая начинается с простейшего числового формата, а затем непересекающимся образом постепенно добавляет более сложные числовые форматы:
Java regep:
(\d)|([1-9]\d+)|(\.\d+)|(\d\.\d*)|([1-9]\d+\.\d*)|([1-9]\d{0,2}(,\d{3})+(\.\d*)?)
Как строка Java (обратите внимание, что дополнительные \, необходимые для перехода к \ и., Поскольку \ и. Имеют специальное значение в регулярном выражении, когда они сами по себе):
String myregexp="(\\d)|([1-9]\\d+)|(\\.\\d+)|(\\d\\.\\d*)|([1-9]\\d+\\.\\d*)|([1-9]\\d{0,2}(,\\d{3})+(\\.\\d*)?)";
Объяснение:
Это регулярное выражение имеет вид A|B|C|D|E|F, где A,B,C,D,E,F сами являются регулярными выражениями, которые не перекрываются. Как правило, мне проще начать с простейших возможных совпадений: A. Если A пропускает совпадения, которые вы хотите, то создайте B, который является незначительной модификацией A и включает в себя немного больше того, что вы хотите. Затем, на основе B, создайте C, который ловит больше и т. Д. Я также считаю, что проще создавать регулярные выражения, которые не пересекаются; легче понять регулярное выражение с 20 простыми непересекающимися регулярными выражениями, связанными с OR, чем с несколькими регулярными выражениями с более сложным сопоставлением. Но каждому свое!
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 разрешает замыкание эросов справа, которое я предпочитаю: если это данные измерений, число конечных нулей указывает уровень точности. Если вам не нужны конечные нули справа, измените (.\ 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 +). Конечные нули можно обрабатывать как в 4. или 5. F не перекрывает A, B, C, D или E. Я не мог придумать более простого регулярного выражения для F.
Дайте мне знать, если вы заинтересованы, и я могу отредактировать выше, чтобы обработать конечные нули справа по желанию.
Вот что соответствует регулярному выражению, а что нет:
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