นิพจน์ทั่วไปเพื่อจับคู่ตัวเลขโดยมีหรือไม่มีเครื่องหมายจุลภาคและทศนิยมในข้อความ

ฉันกำลังพยายามค้นหาและแทนที่ตัวเลขทั้งหมดในเนื้อหาของข้อความ ฉันได้พบ regex ตัวอย่างบางส่วนซึ่งเกือบจะแก้ปัญหาได้ แต่ก็ยังไม่มีอะไรที่สมบูรณ์แบบ ปัญหาที่ฉันมีคือตัวเลขในข้อความของฉันอาจมีหรือไม่มีทศนิยมและลูกน้ำก็ได้ ตัวอย่างเช่น:

"สุนัขจิ้งจอกน้ำหนัก 5,000 ปอนด์กระโดดข้ามรั้ว 99,999.99998713 ฟุต"

regex ควรส่งคืน " 5000" และ " 99,999.99998713" ตัวอย่างที่ฉันพบการแบ่งตัวเลขในเครื่องหมายจุลภาคหรือ จำกัด ไว้ที่ทศนิยมสองตำแหน่ง ฉันเริ่มเข้าใจ regex มากพอที่จะเห็นว่าเหตุใดบางตัวอย่างจึง จำกัด ทศนิยมสองตำแหน่ง แต่ฉันยังไม่ได้เรียนรู้วิธีเอาชนะมันและยังรวมเครื่องหมายจุลภาคเพื่อรับลำดับทั้งหมด

นี่คือเวอร์ชันล่าสุดของฉัน:

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

ซึ่งจะส่งคืน " 5000", " 99,99", " 9.99" และ " 998713" สำหรับข้อความด้านบน

แก้ไข: เนื่องจากสิ่งนี้ได้รับการดูจำนวนมากให้ฉันเริ่มต้นด้วยการให้สิ่งที่พวกเขา Googled ทุกคนทราบ:

#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])?$

ตอนนี้มันเป็นไปไม่ได้สิ่งต่อไปนี้ส่วนใหญ่มีไว้เพื่อให้ความเห็นว่า regex ที่ซับซ้อนจะได้รับอย่างไรหากคุณพยายามที่จะฉลาดกับมันและทำไมคุณควรมองหาทางเลือกอื่น อ่านด้วยความเสี่ยงของคุณเอง

นี้เป็นงานที่พบบ่อยมาก แต่ทุกคำตอบที่ผมเห็นที่นี่เพื่อให้ห่างไกลจะยอมรับปัจจัยการผลิตที่ไม่ตรงกับรูปแบบตัวเลขของคุณเช่น,111, หรือแม้กระทั่ง9,9,9 .,,.ง่ายพอที่จะแก้ไขแม้ว่าตัวเลขจะฝังอยู่ในข้อความอื่นก็ตาม IMHO อะไรที่ล้มเหลวในการดึง 1,234.56 และ 1234- และมีเพียงตัวเลขเหล่าท์ของabc22 1,234.56 9.9.9.9 def 1234เป็นคำตอบที่ผิด

ก่อนอื่นถ้าคุณไม่จำเป็นต้องทำสิ่งนี้ทั้งหมดใน regex เดียวอย่าทำ regex เดียวสำหรับรูปแบบตัวเลขสองรูปแบบนั้นยากที่จะรักษาแม้ว่าจะไม่ได้ฝังอยู่ในข้อความอื่นก็ตาม สิ่งที่คุณควรทำจริงๆคือแบ่งทุกอย่างในช่องว่างจากนั้นเรียกใช้ regexes ขนาดเล็กสองหรือสามรายการในผลลัพธ์ หากนั่นไม่ใช่ทางเลือกสำหรับคุณโปรดอ่านต่อไป

รูปแบบพื้นฐาน

เมื่อพิจารณาจากตัวอย่างที่คุณให้มานี่คือนิพจน์ทั่วไปที่อนุญาตให้ใช้จำนวนเต็มหรือทศนิยมใน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)
• ทศนิยมที่เริ่มต้นด้วยจุดทศนิยม (เช่น. 001 ซึ่งตรงข้ามกับ 0.001)

สำหรับนรกของมันสมมติว่าคุณต้องการบล็อก 3 ตัวแรก แต่อนุญาตอันสุดท้าย คุณควรทำอะไร? ฉันจะบอกคุณว่าคุณควรทำอะไรคุณควรใช้ regex ที่แตกต่างกันสำหรับแต่ละกฎและ จำกัด การจับคู่ของคุณให้แคบลงเรื่อย ๆ แต่เพื่อประโยชน์ของความท้าทายนี่คือวิธีที่คุณทำทั้งหมดในรูปแบบยักษ์เดียว:

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

มีหลายวิธีที่จะทำให้ regex นี้ง่ายขึ้นและสั้นลง แต่เข้าใจว่าการเปลี่ยนรูปแบบจะคลายสิ่งที่พิจารณาตัวเลข

เนื่องจากเอ็นจิ้น regex จำนวนมาก (เช่น JavaScript และ Ruby) ไม่รองรับรูปลักษณ์เชิงลบวิธีเดียวที่จะทำสิ่งนี้ได้อย่างถูกต้องคือการจับกลุ่ม:

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

หมายเลขที่คุณกำลังมองหาจะอยู่ในกลุ่มการจับ 1

ทดสอบที่นี่: http://rubular.com/r/3HCSkndzhT

หมายเหตุสุดท้าย

เห็นได้ชัดว่านี่เป็น regex ขนาดใหญ่ที่ซับซ้อนและไม่สามารถอ่านได้ ฉันชอบความท้าทายนี้ แต่คุณควรพิจารณาว่าคุณต้องการใช้สิ่งนี้ในสภาพแวดล้อมการผลิตจริงหรือไม่ แทนที่จะพยายามทำทุกอย่างในขั้นตอนเดียวคุณสามารถทำได้เป็นสองอย่างคือ regex เพื่อจับอะไรก็ได้ที่อาจเป็นตัวเลขจากนั้นอีกอันเพื่อกำจัดสิ่งที่ไม่ใช่ตัวเลข หรือคุณสามารถประมวลผลพื้นฐานบางอย่างจากนั้นใช้ฟังก์ชันการแยกวิเคราะห์ตัวเลขในภาษาของคุณ ทางเลือกของคุณ.

บางวันที่ผ่านมาผมทำงานเกี่ยวกับปัญหาของการลบเลขศูนย์ต่อท้ายจากสตริงของตัวเลข

ในความต่อเนื่องของปัญหานั้นฉันคิดว่าปัญหานี้น่าสนใจเพราะมันทำให้ปัญหากว้างขึ้นเป็นตัวเลขที่ประกอบด้วยลูกน้ำ

ฉันใช้รูปแบบของ regex ที่ฉันเขียนในปัญหาก่อนหน้านั้นที่ฉันได้แก้ไขและฉันได้ปรับปรุงเพื่อให้สามารถใช้ตัวเลขด้วยเครื่องหมายจุลภาคเป็นคำตอบสำหรับปัญหานี้

ฉันถูกพาไปด้วยความกระตือรือร้นและความชอบใน regexes ฉันไม่รู้ว่าผลลัพธ์ตรงกับความต้องการของ Michael Prescott หรือไม่ ฉันสนใจที่จะทราบจุดที่เกินหรือขาดใน regex ของฉันและแก้ไขเพื่อให้เหมาะสมกับคุณมากขึ้น

หลังจากทำงานเกี่ยวกับ regex นี้มาเป็นเวลานานฉันมีน้ำหนักในสมองดังนั้นฉันจึงไม่สดพอที่จะให้คำอธิบายได้มากนัก ถ้าคะแนนคลุมเครือและมีใครสนใจมากพอโปรดถามฉัน

regex ถูกสร้างขึ้นเพื่อให้สามารถตรวจจับตัวเลขที่แสดงในสัญกรณ์วิทยาศาสตร์2E10หรือแม้แต่5,22,454.12E-00.0478โดยลบเลขศูนย์ที่ไม่จำเป็นในสองส่วนของตัวเลขดังกล่าวด้วย ถ้าเลขชี้กำลังเท่ากับศูนย์จำนวนจะถูกแก้ไขเพื่อให้ไม่มีเลขชี้กำลังอีกต่อไป

ฉันใส่รูปแบบการตรวจสอบเพื่อให้บางกรณีไม่ตรงกันสำหรับตัวอย่าง'12 ..57 'จะไม่ตรงกัน แต่ใน"111"สตริง"111" จะตรงกันเนื่องจากลูกน้ำนำหน้าถือเป็นเครื่องหมายจุลภาคที่ไม่อยู่ในตัวเลข แต่เป็นเครื่องหมายจุลภาคของประโยค

ฉันคิดว่าควรปรับปรุงการจัดการเครื่องหมายจุลภาคเพราะสำหรับฉันแล้วดูเหมือนว่ามีเพียง 2 หลักระหว่างจุลภาคในการนับเลขของอินเดีย ฉันคิดว่ามันจะไม่ซับซ้อนเท่าไหร่

ต่อไปนี้คือโค้ดที่แสดงให้เห็นว่า regex ของฉันทำงานอย่างไร มีสองฟังก์ชั่นตามที่ต้องการให้ตัวเลข".1245"เปลี่ยนเป็น"0.1245"หรือไม่ ฉันจะไม่แปลกใจถ้าข้อผิดพลาดหรือการจับคู่ที่ไม่ต้องการหรือการไม่ตรงกันจะยังคงอยู่ในบางกรณีของสตริงตัวเลข ฉันต้องการทราบกรณีเหล่านี้เพื่อทำความเข้าใจและแก้ไขข้อบกพร่อง

ฉันขอโทษสำหรับรหัสนี้ที่เขียนด้วย Python แต่ regexes เป็นภาษาทรานส์และฉันคิดว่าทุกคนจะสามารถเข้าใจรูปแบบของ 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', '', '', '', '')

regex ด้านล่างจะตรงกับตัวเลขทั้งสองจากตัวอย่างของคุณ

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

จะคืนค่า 5,000 และ 99,999.99998713 - ตรงกับความต้องการของคุณ

คุณกำลังมองหาเสรีภาพตามข้อกำหนดบางประการ

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

แต่สังเกตว่าจะตรงกับเช่น 11,11,1

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

สิ่งนี้จะถือว่ามีอย่างน้อยหนึ่งหลักก่อนหรือหลังเครื่องหมายจุลภาคหรือทศนิยมใด ๆ และยังถือว่ามีทศนิยมมากที่สุดหนึ่งตัวและเครื่องหมายจุลภาคทั้งหมดนำหน้าทศนิยม

regex นี้:

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

นี่คือ regex:

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

นี่คือโครงสร้างอื่นที่เริ่มต้นด้วยรูปแบบตัวเลขที่ง่ายที่สุดจากนั้นในลักษณะที่ไม่ทับซ้อนกันจะเพิ่มรูปแบบตัวเลขที่ซับซ้อนขึ้นเรื่อย ๆ :

Java regep:

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

เป็นสตริง Java (สังเกตว่า \ พิเศษที่จำเป็นในการหลบหนีไปยัง \ และ. ตั้งแต่ \ และ. มีความหมายพิเศษใน regexp เมื่ออยู่ในตัวเอง):

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

คำอธิบาย:

1. regexp นี้มีรูปแบบ A | B | C | D | E | F โดยที่ A, B, C, D, E, F คือ regexps ที่ไม่ทับซ้อนกัน โดยทั่วไปฉันพบว่าการเริ่มต้นด้วยการจับคู่ที่ง่ายที่สุดง่ายกว่า A. หาก A ไม่ตรงกับที่คุณต้องการให้สร้าง B ที่เป็นการปรับเปลี่ยนเล็กน้อยของ A และรวมสิ่งที่คุณต้องการอีกเล็กน้อย จากนั้นใช้ B สร้าง C ที่จับได้มากกว่า ฯลฯ ฉันยังพบว่าการสร้าง regexps ที่ไม่ทับซ้อนกันนั้นง่ายกว่า มันง่ายกว่าที่จะเข้าใจ regexp ที่มี regexps ที่ไม่ทับซ้อนกัน 20 รายการที่เชื่อมต่อกับ OR แทนที่จะเป็น regexps สองสามรายการที่มีการจับคู่ที่ซับซ้อนกว่า แต่แต่ละคนเป็นของตัวเอง!

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 อนุญาตให้มีการกัดเซาะต่อท้ายทางด้านขวาซึ่งฉันต้องการ: หากเป็นข้อมูลการวัดจำนวนศูนย์ต่อท้ายจะบ่งบอกถึงระดับความแม่นยำ หากคุณไม่ต้องการค่าศูนย์ต่อท้ายทางด้านขวาให้เปลี่ยน (. \ d +) เป็น (. \ d * [1-9]) แต่ยังไม่รวม. 0 ซึ่งฉันคิดว่าควรได้รับอนุญาต C เป็นการดัดแปลงเล็กน้อยของ A.

5. 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

6. 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

7. 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 ฉันไม่สามารถนึกถึง regexp ที่ง่ายกว่าสำหรับ F ได้

แจ้งให้เราทราบหากคุณสนใจและฉันสามารถแก้ไขด้านบนเพื่อจัดการกับศูนย์ต่อท้ายทางด้านขวาได้ตามต้องการ

นี่คือสิ่งที่ตรงกับ 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