Biểu thức chính quy để khớp các số có hoặc không có dấu phẩy và số thập phân trong văn bản

Tôi đang cố định vị và thay thế tất cả các số trong nội dung văn bản. Tôi đã tìm thấy một vài ví dụ của regex, hầu như giải quyết được vấn đề, nhưng chưa có cái nào là hoàn hảo. Vấn đề tôi gặp phải là các số trong văn bản của tôi có thể có hoặc không có số thập phân và dấu phẩy. Ví dụ:

"Con cáo 5000 lb. đã nhảy qua hàng rào dài 99,999,99998713 foot."

Regex phải trả về " 5000" và " 99,999.99998713". Các ví dụ tôi đã tìm thấy chia nhỏ các số trên dấu phẩy hoặc được giới hạn ở hai chữ số thập phân. Tôi bắt đầu hiểu regex đủ để thấy lý do tại sao một số ví dụ bị giới hạn ở hai chữ số thập phân, nhưng tôi vẫn chưa học cách vượt qua nó và cũng bao gồm dấu phẩy để có được toàn bộ chuỗi.

Đây là phiên bản mới nhất của tôi:

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

Trả về " 5000", " 99,99", " 9.99" và " 998713" cho văn bản trên.

CHỈNH SỬA: Vì điều này đã nhận được rất nhiều lượt xem, hãy để tôi bắt đầu bằng cách cung cấp cho mọi người những gì họ đã lên 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])?$

Bây giờ thì điều đó không xảy ra, hầu hết những điều sau đây chỉ là bình luận về cách thức phức tạp của regex có thể đạt được nếu bạn cố gắng khéo léo với nó và tại sao bạn nên tìm kiếm các giải pháp thay thế. Đọc có nguy cơ của riêng bạn.

Đây là một nhiệm vụ rất phổ biến, nhưng tất cả các câu trả lời tôi thấy ở đây cho đến nay sẽ chấp nhận đầu vào không phù hợp với định dạng số của bạn, chẳng hạn như ,111, 9,9,9hoặc thậm chí .,,.. Điều đó đủ đơn giản để sửa chữa, ngay cả khi các số được nhúng trong văn bản khác. IMHO bất cứ điều gì mà không để kéo 1,234.56 và 1234- và chỉ những số out của abc22 1,234.56 9.9.9.9 def 1234một câu trả lời sai.

Trước hết, nếu bạn không cần thực hiện tất cả trong một regex, thì đừng. Rất khó để duy trì một regex cho hai định dạng số khác nhau ngay cả khi chúng không được nhúng vào văn bản khác. Những gì bạn thực sự nên làm là chia toàn bộ trên khoảng trắng, sau đó chạy hai hoặc ba regex nhỏ hơn trên kết quả. Nếu đó không phải là một lựa chọn cho bạn, hãy tiếp tục đọc.

Mẫu cơ bản

Xem xét các ví dụ bạn đã đưa ra, đây là một regex đơn giản cho phép 0000định dạng khá nhiều số nguyên hoặc số thập phân và chặn mọi thứ khác:

^\d*\.?\d+$

Đây là một trong những yêu cầu 0,000định dạng:

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

Đặt chúng lại với nhau và dấu phẩy trở thành tùy chọn miễn là chúng nhất quán:

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

Số được nhúng

Các mẫu trên yêu cầu toàn bộ đầu vào là một số. Bạn đang tìm kiếm các số được nhúng trong văn bản, vì vậy bạn phải nới lỏng phần đó. Mặt khác, bạn không muốn nó nhìn thấy catch22và nghĩ rằng nó được tìm thấy số 22. Nếu bạn đang sử dụng thứ gì đó có hỗ trợ lookbehind (như .NET), điều này khá dễ dàng: thay thế ^bằng (?<!\S)và $bằng (?!\S)và bạn ổn đi:

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

Nếu bạn đang làm việc với JavaScript hoặc Ruby hoặc thứ gì đó, mọi thứ bắt đầu phức tạp hơn:

(?:^|\s)(\d*\.?\d+|\d{1,3}(?:,\d{3})*(?:\.\d+)?)(?!\S)

Bạn sẽ phải sử dụng các nhóm chụp; Tôi không thể nghĩ ra một giải pháp thay thế mà không có sự hỗ trợ từ phía sau Các số bạn muốn sẽ nằm trong Nhóm 1 (giả sử toàn bộ trận đấu là Nhóm 0).

Xác thực và các quy tắc phức tạp hơn

Tôi nghĩ rằng điều đó bao hàm câu hỏi của bạn, vì vậy nếu đó là tất cả những gì bạn cần, hãy ngừng đọc ngay bây giờ. Nếu bạn muốn trở nên huyền ảo hơn, mọi thứ trở nên rất phức tạp rất nhanh chóng. Tùy thuộc vào tình huống của bạn, bạn có thể muốn chặn bất kỳ hoặc tất cả những điều sau:

• Đầu vào trống
• Các số 0 đứng đầu (ví dụ: 000123)
• Các số 0 ở cuối (ví dụ: 1.2340000)
• Số thập phân bắt đầu bằng dấu thập phân (ví dụ: 0,001 thay vì 0,001)

Chỉ vì cái quái gì vậy, giả sử bạn muốn chặn 3 cái đầu tiên, nhưng cho phép cái cuối cùng. Những gì bạn nên làm? Tôi sẽ cho bạn biết bạn nên làm gì, bạn nên sử dụng một regex khác nhau cho mỗi quy tắc và dần dần thu hẹp các kết quả phù hợp của mình. Nhưng vì lợi ích của thử thách, đây là cách bạn thực hiện tất cả trong một mô hình khổng lồ:

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

Và đây là ý nghĩa của nó:

(?<!\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.

Đã kiểm tra tại đây: http://rextester.com/YPG96786

Điều này sẽ cho phép những thứ như:

100,000
999.999
90.0009
1,000,023.999
0.111
.111
0

Nó sẽ chặn những thứ như:

1,1,1.111
000,001.111
999.
0.
111.110000
1.1.1.111
9.909,888

Có một số cách để làm cho regex này đơn giản hơn và ngắn hơn, nhưng hãy hiểu rằng việc thay đổi mẫu sẽ làm mất đi những gì nó coi là một số.

Vì nhiều công cụ regex (ví dụ: JavaScript và Ruby) không hỗ trợ giao diện tiêu cực, cách duy nhất để thực hiện điều này một cách chính xác là với các nhóm nắm bắt:

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

Các số bạn đang tìm sẽ nằm trong nhóm bắt 1.

Đã kiểm tra tại đây: http://rubular.com/r/3HCSkndzhT

Một lưu ý cuối cùng

Rõ ràng, đây là một regex khổng lồ, phức tạp, khó đọc. Tôi rất thích thử thách này, nhưng bạn nên cân nhắc xem bạn có thực sự muốn sử dụng nó trong môi trường sản xuất hay không. Thay vì cố gắng thực hiện mọi thứ trong một bước, bạn có thể làm hai bước: một regex để bắt bất cứ thứ gì có thể là một con số, sau đó một bước khác để loại bỏ bất cứ thứ gì không phải là số. Hoặc bạn có thể thực hiện một số xử lý cơ bản, sau đó sử dụng các chức năng phân tích cú pháp số có sẵn trong ngôn ngữ của bạn. Lựa chọn của bạn.

Vài ngày trước, tôi đã giải quyết vấn đề xóa các số không ở cuối chuỗi một số .

Trong sự liên tục của bài toán đó, tôi thấy bài toán này rất thú vị vì nó mở rộng vấn đề thành các số bao gồm dấu phẩy.

Tôi đã lấy mẫu của regex mà tôi đã viết trong bài toán trước đó mà tôi đã làm việc và tôi đã cải thiện nó để nó có thể coi các số có dấu phẩy là câu trả lời cho vấn đề này.

Tôi đã bị cuốn đi với sự nhiệt tình và niềm yêu thích của tôi với regexes. Tôi không biết liệu kết quả có phù hợp chính xác với nhu cầu của Michael Prescott hay không. Tôi muốn biết những điểm thừa hoặc thiếu trong regex của mình và sửa lại để phù hợp hơn với bạn.

Bây giờ, sau một thời gian dài làm việc trên regex này, tôi có một khối lượng lớn trong não, vì vậy tôi không đủ tỉnh táo để giải thích nhiều. Nếu các điểm còn mù mờ, và nếu ai đó có thể đủ quan tâm, vui lòng hỏi tôi.

Regex được xây dựng để nó có thể phát hiện các số được biểu thị bằng ký hiệu khoa học 2E10 hoặc thậm chí 5,22,454.12E-00.0478 , loại bỏ các số không không cần thiết trong hai phần của các số đó. Nếu một số mũ bằng 0, số đó được sửa đổi để không còn số mũ nữa.

Tôi đặt một số xác minh trong mẫu để một số trường hợp cụ thể sẽ không khớp, ví dụ: '12 ..57 ' sẽ không khớp. Nhưng trong ', 111' thì chuỗi '111' khớp vì dấu phẩy đứng trước được coi là dấu phẩy không có trong một số mà là dấu phẩy của câu.

Tôi nghĩ rằng việc quản lý dấu phẩy nên được cải thiện, bởi vì đối với tôi, dường như chỉ có 2 chữ số giữa dấu phẩy trong đánh số Ấn Độ. Sẽ không khó sửa, tôi đoán là

Đây là đoạn mã trình bày cách thức hoạt động của regex. Có hai hàm, tùy theo nếu người ta muốn các số '.1245' được chuyển thành '0.1245' hay không. Tôi sẽ không ngạc nhiên nếu lỗi hoặc các kết hợp không mong muốn hoặc không khớp sẽ vẫn còn đối với một số trường hợp chuỗi số nhất định; thì tôi muốn biết những trường hợp này để hiểu và sửa chữa sự thiếu hụt.

Tôi xin lỗi vì mã này được viết bằng Python, nhưng regexes là ngôn ngữ chuyển đổi và tôi nghĩ rằng mọi người sẽ có khả năng sử dụng mô hình của 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

kết quả

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', '', '', '', '')

Regex bên dưới sẽ khớp với cả hai số từ ví dụ của bạn.

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

Nó sẽ trả về 5000 và 99,999.99998713 - phù hợp với yêu cầu của bạn.

Tự do nhất định với các yêu cầu, bạn đang tìm kiếm

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

Nhưng lưu ý rằng điều này sẽ khớp với ví dụ: 11,11,1

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

Điều này giả định rằng luôn có ít nhất một chữ số trước hoặc sau bất kỳ dấu phẩy hoặc số thập phân nào và cũng giả định rằng có nhiều nhất một số thập phân và tất cả các dấu phẩy đứng trước số thập phân.

Regex này:

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

Đối sánh mọi số trong chuỗi:

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

Đây là một regex:

(?:\d+)((\d{1,3})*([\,\ ]\d{3})*)(\.\d+)?

chấp nhận các số:

• không có khoảng trắng và / hoặc số thập phân, ví dụ. 123456789,123.123
• với dấu phẩy hoặc dấu cách làm dấu phân cách hàng nghìn và / hoặc số thập phân, ví dụ. 123 456 789, 123 456 789.100, 123,456,3,232,300,000.00

Kiểm tra: http://regexr.com/3h1a2

Đây là một cấu trúc khác bắt đầu với định dạng số đơn giản nhất và sau đó, theo cách không chồng chéo, dần dần thêm các định dạng số phức tạp hơn:

Java regep:

(\d)|([1-9]\d+)|(\.\d+)|(\d\.\d*)|([1-9]\d+\.\d*)|([1-9]\d{0,2}(,\d{3})+(\.\d*)?)

Là một chuỗi Java (lưu ý rằng phần bổ sung cần thiết để thoát sang \ và. Kể từ \ và. Có ý nghĩa đặc biệt trong một regexp khi ở riêng):

String myregexp="(\\d)|([1-9]\\d+)|(\\.\\d+)|(\\d\\.\\d*)|([1-9]\\d+\\.\\d*)|([1-9]\\d{0,2}(,\\d{3})+(\\.\\d*)?)";   

Giải trình:

1. Regexp này có dạng A | B | C | D | E | F trong đó A, B, C, D, E, F là các regexp không trùng nhau. Nói chung, tôi thấy bắt đầu dễ dàng hơn với các kết quả đơn giản nhất có thể, A. Nếu A bỏ lỡ các kết quả bạn muốn, thì hãy tạo một B là một sửa đổi nhỏ của A và bao gồm thêm một chút những gì bạn muốn. Sau đó, dựa trên B, tạo một C bắt được nhiều hơn, v.v. Tôi cũng thấy dễ dàng hơn khi tạo các regexps không trùng lặp; dễ hiểu hơn về một regexp với 20 regexp đơn giản không chồng chéo được kết nối với OR hơn là một vài regexp có kết hợp phức tạp hơn. Nhưng mỗi sở hữu của họ!

2. A là (\ d) và khớp chính xác với một trong 0,1,2,3,4,5,6,7,8,9 không thể đơn giản hơn!

3. B là ([1-9] \ d +) và chỉ khớp với các số có từ 2 chữ số trở lên, chữ số đầu tiên không bao gồm số 0. B trùng đúng một trong 10,11,12, ... B không trùng A nhưng là một sửa đổi nhỏ của A.

4. C là (. \ D +) và chỉ khớp với một số thập phân theo sau bởi một hoặc nhiều chữ số. C khớp đúng với một trong số .0 .1 .2 .3 .4 .5 .6 .7 .8 .9 .00 .01 .02 .... .23000 ... C cho phép các dấu eros ở bên phải mà tôi thích hơn: nếu đây là dữ liệu đo lường, số lượng các số không ở cuối cho biết mức độ chính xác. Nếu bạn không muốn các số 0 ở cuối bên phải, hãy thay đổi (. \ D +) thành (. \ D * [1-9]) nhưng điều này cũng loại trừ .0 mà tôi nghĩ nên được phép. C cũng là một biến đổi nhỏ của A.

5. D là (\ d. \ D *) là A cộng với các số thập phân với các số không ở bên phải. D chỉ khớp với một chữ số duy nhất, theo sau là số thập phân, theo sau là không hoặc nhiều chữ số. D khớp với 0. 0.0 0.1 0.2 .... 0.01000 ... 9. 9.0 9.1..0.0230000 .... 9.9999999999 ... Nếu bạn muốn loại trừ "0." sau đó thay đổi D thành (\ d. \ d +). Nếu bạn muốn loại trừ các số không ở cuối bên phải, hãy thay đổi D thành (\ d. \ D * [1-9]) nhưng điều này loại trừ 2.0 mà tôi nghĩ nên được bao gồm. D không trùng A, B, C.

6. E là ([1-9] \ d +. \ D *) là B cộng với các số thập phân với các số không ở bên phải. Ví dụ: nếu bạn muốn loại trừ "13.", thì hãy thay đổi E thành ([1-9] \ d +. \ D +). E không trùng với A, B, C hoặc D. E khớp với 10. 10.0 10.0100 .... 99.9999999999 ... Các số không ở cuối có thể được xử lý như trong 4. và 5.

7. F là ([1-9] \ d {0,2} (, \ d {3}) + (. \ D *)?) Và chỉ khớp với các số có dấu phẩy và có thể là số thập phân cho phép các số không ở bên phải. Nhóm đầu tiên ([1-9] \ d {0,2}) khớp với một chữ số khác 0, theo sau là 0, một hoặc hai chữ số nữa. Nhóm thứ hai (, \ d {3}) + khớp với nhóm 4 ký tự (một dấu phẩy theo sau bởi chính xác ba chữ số) và nhóm này có thể khớp một hoặc nhiều lần (không khớp có nghĩa là không có dấu phẩy!). Cuối cùng, (. \ D *)? không khớp với nhau, hoặc khớp. bằng chính nó, hoặc khớp với một số thập phân. theo sau là bất kỳ số chữ số nào, có thể không có. Một lần nữa, để loại trừ những thứ như "1,111.", Hãy thay đổi (. \ D *) thành (. \ D +). Các số không ở cuối có thể được xử lý như trong 4. hoặc 5. F không chồng lên A, B, C, D hoặc E. Tôi không thể nghĩ ra một regexp dễ dàng hơn cho F.

Hãy cho tôi biết nếu bạn quan tâm và tôi có thể chỉnh sửa ở trên để xử lý các số không ở cuối bên phải như mong muốn.

Đây là những gì phù hợp với regexp và những gì không phù hợp:

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 -------> ranh giới từ

\ d + ------> một hoặc chữ số

, --------> chứa dấu phẩy,

Ví dụ:

sddsgg 70.000 sdsfdsf fdgfdg70,00

sfsfsd 5,44,4343 5,7788,44 555

Nó sẽ phù hợp với:

70,

5,

44,

, 44

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

Điều này sẽ khớp với bất kỳ số nhỏ hoặc lớn nào sau đây có hoặc không có dấu phẩy

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

hoặc là

1
100
1262
156262
1078999
123456789