텍스트에서 쉼표와 소수를 포함하거나 포함하지 않고 숫자를 일치시키는 정규 표현식

텍스트 본문의 모든 숫자를 찾아서 바꾸려고합니다. 문제를 거의 해결하는 정규식 예제를 몇 가지 찾았지만 아직 완벽한 것은 없습니다. 내가 가진 문제는 내 텍스트의 숫자에 소수와 쉼표가있을 수도 있고 없을 수도 있다는 것입니다. 예를 들면 :

"5000 파운드의 여우는 99,999.99998713 피트 울타리를 뛰어 넘었습니다."

정규식은 " 5000"및 " 99,999.99998713"를 반환해야합니다 . 예제 쉼표에서 숫자를 분리했거나 소수점 이하 두 자리로 제한되어 있습니다. 일부 예제가 소수점 이하 두 자리로 제한되는 이유를 알 수있을만큼 정규식을 이해하기 시작했지만,이를 극복하는 방법과 전체 시퀀스를 얻기 위해 쉼표를 포함하는 방법을 아직 배우지 못했습니다.

내 최신 버전은 다음과 같습니다.

[0-9]+(\.[0-9][0-9]?)?

위의 텍스트에 대해 " 5000", " 99,99", " 9.99"및 " 998713"를 반환 합니다.

편집 : 이것은 많은 견해를 얻었으므로 모든 사람에게 Google에서 검색 한 것을 제공하여 시작하겠습니다.

#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또는 심지어을 .,,.. 숫자가 다른 텍스트에 포함되어 있어도 수정할 수있을만큼 간단합니다. 1,234.56 및 1234- 끌어 실패 이럴 아무것도 단지 그 숫자를 의 -out은 abc22 1,234.56 9.9.9.9 def 1234잘못된 답변입니다.

우선, 하나의 정규식에서이 모든 작업을 수행 할 필요가 없다면하지 마십시오. 두 가지 다른 숫자 형식에 대한 단일 정규식은 다른 텍스트에 포함되지 않은 경우에도 유지하기가 어렵습니다. 실제로해야 할 일은 모든 것을 공백으로 분할 한 다음 결과에 대해 2 ~ 3 개의 더 작은 정규식을 실행하는 것입니다. 그것이 당신을위한 선택이 아니라면, 계속 읽으십시오.

기본 패턴

주어진 예를 고려하면 다음은 거의 모든 정수 또는 소수를 허용하는 간단한 정규식입니다. 0000 형식으로 허용하고 다른 모든 것을 차단 .

^\d*\.?\d+$

여기에 필요한 0,000 형식 입니다.

^\d{1,3}(,\d{3})*(\.\d+)?$

그것들을 합치면 쉼표는 일관성이있는 한 선택 사항이됩니다.

^(\d*\.?\d+|\d{1,3}(,\d{3})*(\.\d+)?)$

포함 된 숫자

위의 패턴은 전체 입력이 숫자 여야합니다. 텍스트에 포함 된 숫자를 찾고 있으므로 해당 부분을 풀어야합니다. 반면에, 당신은 그것을보고 싶지 않아 catch22대체 : 당신이 (.NET 등) lookbehind 지원 뭔가를 사용하는 경우는 수 (22)을 발견 생각이 꽤 쉽게 ^로 (?<!\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이라고 가정).

유효성 검사 및 더 복잡한 규칙

그게 당신의 질문을 다룰 것 같으니, 그게 전부라면 지금 그만 읽으세요. 더 멋지게 만들고 싶다면 상황이 매우 빠르게 복잡해집니다. 상황에 따라 다음 중 일부 또는 모두를 차단할 수 있습니다.

• 빈 입력
• 선행 0 (예 : 000123)
• 후행 0 (예 : 1.2340000)
• 소수점으로 시작하는 소수점 (예 : 0.001이 아닌 .001)

지옥을 위해 처음 3 개는 차단하고 마지막 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)이 네거티브 lookbehind를 지원하지 않기 때문에이를 올바르게 수행하는 유일한 방법은 캡처 그룹을 사용하는 것입니다.

(:?^|\s)(?=.)((?:0|(?:[1-9](?:\d*|\d{0,2}(?:,\d{3})*)))?(?:\.\d*[1-9])?)(?!\S)

찾고있는 숫자는 캡처 그룹 1에 있습니다.

여기에서 테스트 됨 : http://rubular.com/r/3HCSkndzhT

마지막 메모

분명히 이것은 거대하고 복잡하며 거의 읽을 수없는 정규식입니다. 나는 도전을 즐겼지만 실제로 프로덕션 환경에서 사용할 것인지 고려해야합니다. 한 단계에서 모든 것을 시도하는 대신 두 가지로 할 수 있습니다. 정규식 은 숫자 일 수 있는 것을 잡는 것이고 다른 것은 숫자 가 아닌 것을 걸러내는 것 입니다. 또는 몇 가지 기본 처리를 수행 한 다음 언어에 내장 된 숫자 구문 분석 기능을 사용할 수 있습니다. 당신의 선택.

며칠 전에 저는 숫자 문자열에서 후행 0을 제거하는 문제를 해결 했습니다. .

그 문제의 연속성에서 나는 이것이 쉼표로 구성된 숫자로 문제를 넓히기 때문에 흥미로운 것을 발견했습니다.

이전에 작업했던 문제에서 작성한 정규식 패턴을 가져와이 문제에 대한 답으로 쉼표로 숫자를 처리 할 수 ​​있도록 개선했습니다.

나는 나의 열정과 내가 좋아하는 정규식에 푹 빠졌다. 결과가 Michael Prescott이 표현한 요구에 정확히 맞는지 모르겠습니다. 내 정규식에서 과도하거나 부족한 점을 알고 더 적합하도록 수정하는 데 관심이 있습니다.

자,이 정규식에 대한 긴 세션 후에, 저는 뇌에 일종의 무게가있어서 많은 설명을 할만큼 신선하지 않습니다. 포인트가 모호하고 관심이 있으신 분이 계시다면 제게 물어보세요.

정규식은 과학적 표기법 2E10 또는 5,22,454.12E-00.0478로 표현 된 숫자를 감지 할 수 있도록 작성되었습니다. 이러한 숫자의 두 부분에서도 불필요한 0을 제거합니다. 지수가 0과 같으면 더 이상 지수가 없도록 숫자가 수정됩니다.

예를 들어 '12 ..57 ' 이 일치하지 않기 때문에 일부 특정 사례가 일치하지 않도록 패턴에 몇 가지 확인을 넣었 습니다. 그러나 ', 111' 에서 문자열 '111' 은 앞의 쉼표가 숫자가 아니라 쉼표의 문장으로 간주되기 때문에 일치합니다.

인도 넘버링에서는 쉼표 사이에 2 자리 만있는 것 같아서 쉼표 관리를 개선해야한다고 생각합니다. 수정하기 어렵지 않을 것 같아요

다음은 내 정규식이 어떻게 작동하는지 보여주는 코드입니다. 이 개 기능은 하나의 숫자를 원하는 경우에 따라이있다 '0.1245이' 에서 변형 될 '0.1245' 여부. 숫자 문자열의 특정 경우에 오류나 원치 않는 일치 또는 불일치가 남아 있어도 놀라지 않을 것입니다. 그런 다음 결함을 이해하고 수정하기 위해 이러한 사례를 알고 싶습니다.

파이썬으로 작성된이 코드에 대해 사과드립니다. 그러나 정규식은 언어를 초월하며 모두가 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', '', '', '', '')

아래 정규식은 예제의 두 숫자와 일치합니다.

\b\d[\d,.]*\b

요구 사항과 일치하는 5000 및 99,999.99998713을 반환합니다.

요구 사항에 대한 특정 자유를 취하면

\d+([\d,]?\d)*(\.\d+)?

그러나 이것은 예를 들어 11,11,1과 일치합니다.

\d+(,\d+)*(\.\d+)?

이는 쉼표 또는 소수점 앞뒤에 항상 하나 이상의 숫자가 있다고 가정하고 최대 하나의 소수점이 있고 모든 쉼표가 소수점 앞에 있다고 가정합니다.

이 정규식 :

(\d{1,3},\d{3}(,\d{3})*)(\.\d*)?|\d+\.?\d*

문자열의 모든 숫자와 일치 :

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

다음은 정규식입니다.

(?:\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

다음은 가장 간단한 숫자 형식으로 시작하여 중첩되지 않는 방식으로 점진적으로 더 복잡한 숫자 형식을 추가하는 또 다른 구성입니다.

자바 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*)?)";   

설명:

1. 이 정규식은 A | B | C | D | E | F 형식을 갖습니다. 여기서 A, B, C, D, E, F는 겹치지 않는 정규식입니다. 일반적으로 가능한 가장 간단한 일치 A로 시작하는 것이 더 쉽다는 것을 알았습니다. A가 원하는 일치를 놓치면 A를 약간 수정하고 원하는 것을 조금 더 포함하는 B를 만듭니다. 그런 다음 B를 기반으로 더 많은 것을 잡는 C를 만듭니다. 또한 겹치지 않는 정규 표현식을 만드는 것이 더 쉽습니다. 더 복잡한 일치를 갖는 몇 개의 정규 표현식이 아니라 OR로 연결된 20 개의 단순 비 중첩 정규 표현식이있는 정규 표현식을 이해하는 것이 더 쉽습니다. 그러나 각각 자신의 것!

2. A는 (\ d)이고 0,1,2,3,4,5,6,7,8,9 중 하나와 정확히 일치합니다.

3. B는 ([1-9] \ d +)이며 2 자리 이상의 숫자 만 일치하며 첫 번째 숫자는 0을 제외합니다. B는 10,11,12, ... 중 하나와 정확히 일치합니다. B는 A와 겹치지 않지만 A의 작은 수정입니다.

4. C는 (. \ d +)이며 소수 다음에 하나 이상의 숫자 만 일치합니다. C는 .0 .1 .2 .3 .4 .5 .6 .7 .8 .9 .00 .01 .02 .... .23000 ... C는 내가 선호하는 오른쪽에 후행 에로스를 허용합니다. 이것이 측정 데이터 인 경우 후행 0의 수는 정밀도 수준을 나타냅니다. 오른쪽에 후행 0을 표시하지 않으려면 (. \ d +)를 (. \ d * [1-9])로 변경하지만 허용되어야한다고 생각하는 .0도 제외됩니다. C는 또한 A의 작은 수정입니다.

5. D는 (\ d. \ d *)이며 A와 소수점 아래 오른쪽에 0이 붙습니다. D는 단일 숫자, 소수, 0 개 이상의 숫자 만 일치합니다. D는 0. 0.0 0.1 0.2 .... 0.01000 ... 9와 일치합니다. 9.0 9.1..0.0230000 .... 9.9999999999 ... "0"을 제외하려는 경우 그런 다음 D를 (\ d. \ d +)로 변경합니다. 오른쪽에있는 후행 0을 제외하려면 D를 (\ d. \ d * [1-9])로 변경합니다.하지만 여기에 포함되어야하는 2.0은 제외됩니다. D는 A, B 또는 C와 겹치지 않습니다.

6. E는 ([1-9] \ d +. \ d *)이며 오른쪽에 뒤에 0이있는 소수를 더한 B입니다. 예를 들어 "13."을 제외하려면 E를 ([1-9] \ d +. \ d +)로 변경합니다. E는 A, B, C 또는 D와 겹치지 않습니다. E는 10과 일치합니다. 10.0 10.0100 .... 99.9999999999 ... 후행 0은 4 및 5와 같이 처리 할 수 ​​있습니다.

7. F는 ([1-9] \ d {0,2} (, \ d {3}) + (. \ d *)?)이며 쉼표가있는 숫자 만 일치하며 오른쪽에 후행 0을 허용하는 소수가있을 수 있습니다. 첫 번째 그룹 ([1-9] \ d {0,2})은 0이 아닌 숫자 다음에 0, 1 또는 2 개 이상의 숫자를 찾습니다. 두 번째 그룹 (, \ d {3}) +는 4 개의 문자 그룹 (쉼표 뒤에 정확히 3 자리 숫자)과 일치하며이 그룹은 한 번 이상 일치 할 수 있습니다 (일치하지 않는 것은 쉼표가 없음을 의미합니다!). 마지막으로 (. \ d *)? 아무것도 일치하지 않거나 일치합니다. 단독으로 또는 소수와 일치합니다. 그 뒤에 임의의 자릿수가옵니다. 다시 말하지만, "1,111."과 같은 것을 제외하려면 (. \ d *)를 (. \ d +)로 변경하십시오. 후행 0은 4 또는 5와 같이 처리 할 수 ​​있습니다. F는 A, B, C, D 또는 E와 겹치지 않습니다. F에 대한 더 쉬운 정규 표현식을 생각할 수 없었습니다.

관심이 있으시면 알려 주시면 위의 편집을 통해 오른쪽에있는 후행 0을 원하는대로 처리 할 수 ​​있습니다.

다음은 regexp와 일치하는 것과 일치하지 않는 것입니다.

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

\b\d+,

\ b -------> 단어 경계

\ d + ------> 하나 또는 숫자

, --------> 쉼표 포함,

예 :

sddsgg 70,000 sdsfdsf fdgfdg70,00

sfsfsd 5,44,4343 5.7788,44 555

다음과 일치합니다.

70,

5,

44,

, 44

(,*[\d]+,*[\d]*)+

이것은 쉼표를 사용하거나 사용하지 않고 다음과 같이 작거나 큰 숫자와 일치합니다.

1
100
1,262
1,56,262
10,78,999
12,34,56,789

또는

1
100
1262
156262
1078999
123456789