Ekspresi reguler untuk mencocokkan angka dengan atau tanpa koma dan desimal dalam teks

97

Saya mencoba mencari dan mengganti semua angka di badan teks. Saya telah menemukan beberapa contoh regex, yang hampir menyelesaikan masalah, tetapi belum ada yang sempurna. Masalah yang saya miliki adalah bahwa angka dalam teks saya mungkin atau mungkin tidak memiliki desimal dan koma. Sebagai contoh:

"Rubah seberat 5.000 lb. melompati pagar setinggi 99.999.99998713."

Regex harus mengembalikan " 5000" dan " 99,999.99998713". Contoh saya telah menemukan angka putus-putus di koma atau dibatasi untuk dua tempat desimal. Saya mulai memahami regex cukup untuk melihat mengapa beberapa contoh dibatasi pada dua tempat desimal, tetapi saya belum belajar cara mengatasinya dan juga menyertakan koma untuk mendapatkan seluruh urutan.

Ini versi terbaru saya: 

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

Yang mengembalikan, " 5000", " 99,99", " 9.99", dan " 998713" untuk teks di atas.

regex Donat
sumber
1
Apa bahasa pemrograman atau rasa regex?
Matt Ball
7
Sepertinya hampir setiap jawaban di sini membuat kesalahan dengan membiarkan hal-hal seperti .,.,.atau 9,9,9,9atau 9,9.99.9. Regexe ini tidak mengharuskan angka dalam format yang benar, dan paling buruk, akan memperlakukan tanda baca sebagai angka. Ada beberapa penyesuaian opsional yang mungkin (misalnya apakah akan mengizinkan nol di depan dan di belakang), tetapi beberapa jawaban yang saya lihat benar-benar salah. Saya benar-benar tidak suka downvoting, terutama pada upaya yang jujur, tetapi saya merasa jawaban di sini perlu dibersihkan. Ini adalah pertanyaan yang umum dan pasti akan ditanyakan lagi.
Justin Morgan
Jika Anda tidak mengetahuinya, lihatlah regexpal.com
entonio
Maaf atas keterlambatan Matt. Saya menggunakan Adobe ActionScript 3. Saya pikir perilaku regex sama dengan JavaScript, tetapi saya menguji saran Justin di regexpal.com dan membandingkannya dengan hasil aplikasi Flash saya dan melihat dua hasil berbeda, keduanya salah.
Harus bekerja kali ini, berdasarkan tes saya sendiri. Beri tahu saya jika masih perlu perbaikan.
Justin Morgan

Jawaban:

293

EDIT: Karena ini mendapatkan banyak tampilan, izinkan saya mulai dengan memberikan kepada semua orang apa yang mereka cari di 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])?$

Sekarang setelah itu, sebagian besar dari yang berikut ini dimaksudkan sebagai komentar tentang seberapa kompleks regex bisa didapat jika Anda mencoba untuk menjadi pandai dengannya, dan mengapa Anda harus mencari alternatif. Baca dengan risiko Anda sendiri.

Ini adalah tugas yang sangat umum, tetapi semua jawaban yang saya lihat di sini sejauh akan menerima masukan yang tidak cocok format angka Anda, seperti ,111, 9,9,9, atau bahkan .,,.. Itu cukup sederhana untuk diperbaiki, bahkan jika angka-angka tersebut disematkan di teks lain. IMHO apa pun yang gagal menarik 1.234.56 dan 1234 — dan hanya angka-angka itu — dari abc22 1,234.56 9.9.9.9 def 1234jawaban yang salah.

Pertama-tama, jika Anda tidak perlu melakukan ini semua dalam satu regex, jangan. Regex tunggal untuk dua format angka yang berbeda sulit dipertahankan meskipun tidak disematkan di teks lain. Apa yang harus Anda lakukan adalah membagi semuanya di spasi, kemudian menjalankan dua atau tiga ekspresi reguler yang lebih kecil pada hasil. Jika itu bukan pilihan untuk Anda, teruslah membaca.

Pola dasar

Mempertimbangkan contoh yang Anda berikan, berikut regex sederhana yang memungkinkan hampir semua bilangan bulat atau desimal dalam 0000format dan memblokir yang lainnya:

^\d*\.?\d+$

Ini salah satu yang membutuhkan 0,000format:

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

Gabungkan keduanya, dan koma menjadi opsional selama konsisten:

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

Nomor yang disematkan

Pola di atas mengharuskan seluruh masukan berupa angka. Anda sedang mencari angka yang disematkan dalam teks, jadi Anda harus melonggarkan bagian itu. Di sisi lain, Anda tidak ingin melihat catch22dan mengira itu menemukan nomor 22. Jika Anda menggunakan sesuatu dengan dukungan lookbehind (seperti .NET), ini cukup mudah: ganti ^dengan (?<!\S)dan $dengan (?!\S)dan Anda baik untuk pergi:

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

Jika Anda bekerja dengan JavaScript atau Ruby atau sesuatu, segalanya mulai terlihat lebih kompleks:

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

Anda harus menggunakan grup penangkapan; Saya tidak dapat memikirkan alternatif tanpa dukungan di belakang. Angka-angka yang Anda inginkan akan berada di Grup 1 (dengan asumsi bahwa seluruh pertandingan adalah Grup 0).

Validasi dan aturan yang lebih kompleks

Saya pikir itu mencakup pertanyaan Anda, jadi jika hanya itu yang Anda butuhkan, berhentilah membaca sekarang. Jika Anda ingin menjadi lebih menarik, segalanya berubah menjadi sangat kompleks dengan sangat cepat. Bergantung pada situasi Anda, Anda mungkin ingin memblokir salah satu atau semua hal berikut:

  • Masukan kosong
  • Angka nol terdepan (mis. 000123)
  • Di belakang nol (misalnya 1,2340000)
  • Desimal dimulai dengan titik desimal (mis .001 sebagai lawan 0,001)

Persetan, anggap saja Anda ingin memblokir 3 yang pertama, tetapi mengizinkan yang terakhir. Apa yang harus Anda lakukan? Saya akan memberi tahu Anda apa yang harus Anda lakukan, Anda harus menggunakan regex yang berbeda untuk setiap aturan dan secara progresif mempersempit kecocokan Anda. Namun demi tantangannya, berikut cara Anda melakukan semuanya dalam satu pola raksasa:

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

Dan inilah artinya:

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

Diuji di sini: http://rextester.com/YPG96786

Ini akan memungkinkan hal-hal seperti:

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

Ini akan memblokir hal-hal seperti:

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

Ada beberapa cara untuk membuat ekspresi reguler ini lebih sederhana dan lebih pendek, tetapi pahami bahwa mengubah pola akan melonggarkan apa yang dianggapnya angka.

Karena banyak mesin regex (misalnya JavaScript dan Ruby) tidak mendukung tampilan negatif, satu-satunya cara untuk melakukannya dengan benar adalah dengan grup tangkap:

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

Angka-angka yang Anda cari akan ada di grup tangkapan 1.

Diuji di sini: http://rubular.com/r/3HCSkndzhT

Satu catatan terakhir

Jelas, ini adalah regex yang masif, rumit, dan hampir tidak bisa dibaca. Saya menikmati tantangannya, tetapi Anda harus mempertimbangkan apakah Anda benar-benar ingin menggunakannya dalam lingkungan produksi. Alih-alih mencoba melakukan semuanya dalam satu langkah, Anda dapat melakukannya dalam dua langkah: ekspresi reguler untuk menangkap apa pun yang mungkin berupa angka, lalu satu lagi untuk menyingkirkan apa pun yang bukan angka. Atau Anda dapat melakukan beberapa pemrosesan dasar, lalu gunakan fungsi penguraian angka bawaan bahasa Anda. Pilihanmu.

Justin Morgan
sumber
1
Ini adalah upaya yang sangat bagus, tetapi mungkin ada masalah dengannya - tergantung pada keserakahan mesin, angka tertentu mungkin cocok sebagian dari dua format yang bersaing, instruksi untuk mencocokkan satu sama lain dengan yang benar - yaitu 5000 dapat menghasilkan 500 plus 0 Itu membuat saya sedikit skeptis untuk mencoba menutupi terlalu banyak hanya dengan satu ekspresi, dan itulah mengapa saya memberikan jawaban yang lebih sederhana dengan peringatan kemungkinan positif palsu. Pada akhirnya, ketatnya persyaratan harus menentukan solusinya.
entonio
@entonio - Itu poin yang adil. Ini mungkin berfungsi dengan pengeditan terbaru. BTW, downvote Anda bukan dari saya, karena Anda menunjukkan potensi 1,11,11 kecocokan.
Justin Morgan
Saya menggunakan ActionScript, yang menurut saya berperilaku sama dengan JavaScript. Menggunakan pola pertama yang Anda rekomendasikan, saya mendapatkan hasil berikut pada string pengujian saya (Untuk validasi, saya hanya mengembalikan kecocokan yang dibungkus dengan "<< [hasil] >>"): << 5 >> 000 lb. fox melompati << 9 >> 9 <<, 9 >> <<99>> <<. 9 >> <<99>> <<98>> <<71>> pagar 3 kaki.
2
Nah, salah satu suara positif Anda adalah dari saya :) karena menurut saya jawaban Anda selengkap mungkin dan Anda berusaha keras. Hanya untuk membuat ini komentar-konten, catatan untuk OP, itu?: Di awal kelompok apakah ada sehingga mereka tidak dikembalikan secara otonom di hasil ('ditangkap'), meskipun mereka berkontribusi pada pencocokan seluruh ekspresi; setiap angka yang diformat dalam masukan cocok dengan seluruh ekspresi.
entonio
@Michael dan @entonio - Lihat hasil edit terbaru, yang tampaknya berfungsi. Ini adalah salah satu masalah regex yang lebih sulit daripada yang terlihat.
Justin Morgan
10

Beberapa hari yang lalu, saya mengerjakan masalah menghapus nol tertinggal dari string angka .

Dalam kontinuitas soal itu, menurut saya yang satu ini menarik karena memperluas soal menjadi angka yang terdiri dari koma.

Saya telah mengambil pola regex yang saya tulis di masalah sebelumnya yang saya kerjakan dan saya memperbaikinya agar dapat memperlakukan angka dengan koma sebagai jawaban untuk masalah ini.

Saya telah terbawa dengan antusiasme dan kesukaan saya pada regex. Saya tidak tahu apakah hasilnya sesuai dengan kebutuhan yang diungkapkan oleh Michael Prescott. Saya akan tertarik untuk mengetahui poin-poin yang kelebihan atau kekurangan pada regex saya, dan memperbaikinya agar lebih cocok untuk Anda.

Sekarang, setelah sesi panjang mengerjakan regex ini, saya memiliki semacam beban di otak, jadi saya tidak cukup segar untuk memberikan banyak penjelasan. Jika poin-poinnya tidak jelas, dan jika ada yang tertarik, silakan tanya saya.

Regex dibuat agar dapat mendeteksi angka yang diekspresikan dalam notasi ilmiah 2E10 atau bahkan 5,22,454.12E-00.0478 , menghilangkan nol yang tidak perlu di dua bagian angka tersebut juga. Jika eksponen sama dengan nol, bilangan tersebut dimodifikasi sehingga tidak ada eksponen lagi.

Saya menempatkan beberapa verifikasi dalam pola sehingga beberapa kasus tertentu tidak akan cocok, misalnya '12 ..57 ' tidak akan cocok. Tetapi dalam ', 111' string '111' cocok karena koma sebelumnya dianggap sebagai koma bukan dalam angka melainkan koma kalimat.

Menurut saya, pengelolaan koma harus ditingkatkan, karena menurut saya hanya ada 2 angka di antara koma dalam penomoran India. Tidak akan sulit untuk memperbaikinya, saya kira

Berikut adalah kode yang menunjukkan cara kerja regex saya. Ada dua fungsi, menurut apakah seseorang ingin bilangan '.1245' diubah menjadi '0.1245' atau tidak. Saya tidak akan terkejut jika kesalahan atau kecocokan atau ketidakcocokan yang tidak diinginkan akan tetap ada untuk kasus string angka tertentu; maka saya ingin mengetahui kasus-kasus ini untuk memahami dan memperbaiki kekurangannya.

Saya minta maaf atas kode ini yang ditulis dengan Python, tetapi regex adalah trans-bahasa dan saya pikir semua orang akan mampu memahami pola 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

hasil

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', '', '', '', '')
eyquem
sumber
8

Regex di bawah ini akan cocok dengan kedua angka dari contoh Anda. 

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

Ini akan mengembalikan 5000 dan 99,999.99998713 - sesuai dengan kebutuhan Anda.

Leons
sumber
3
Ini akan cocok dengan koma in this,that.
Justin Morgan
@ Justin Morgan - Anda benar, saya tidak menguji kondisi itu. Berikut adalah versi terbaru yang akan wrok untuk semua kasus, kecuali untuk nomor yang dimulai dengan koma atau titik. \b\d[\d,.]+\b
Leons
Jauh lebih baik, tetapi masih akan mengizinkan 9....9atau 1,,,,X(meskipun X tidak akan disertakan dalam pertandingan).
Justin Morgan
1
Ngomong-ngomong, \b\d[\d,.]*\bcukup dekat sehingga jika Anda mengedit jawaban Anda, saya akan menghapus -1. Ini harus menjadi * bukan + sekalipun; \b\d[\d,.]+\btidak mengizinkan angka satu digit.
Justin Morgan
@ Justin Morgan - terima kasih atas wawasannya. Pertanyaan ini jelas lebih kompleks dari yang terlihat. Saya memperbarui jawaban saya berdasarkan umpan balik Anda - itu masuk akal.
Leons
3

Mengambil kebebasan tertentu dengan persyaratan yang Anda cari

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

Tapi perhatikan ini akan cocok misalnya 11,11,1

entonio
sumber
Karena penasaran, adakah alasan Anda pergi dengan \d+([\d,]?\d)*(\.\d+)?selain \d+(,\d+)*(\.\d+)?? Saya pikir mereka akan memberikan pertandingan yang setara, meskipun grup penangkapan akan berbeda.
Justin Morgan
Hai. Tidak ada alasan khusus, itu adalah pengalihan dari memulai dengan ekspresi yang lebih kompleks agar tidak cocok dengan format yang tidak valid.
entonio
3 
\d+(,\d+)*(\.\d+)?

Ini mengasumsikan bahwa selalu ada setidaknya satu digit sebelum atau sesudah koma atau desimal dan juga mengasumsikan bahwa ada paling banyak satu desimal dan semua koma mendahului desimal.

Neil
sumber
2
Ini tidak membatasi grup koma ke format 3 digit. Itu akan menerima 999999,9,9,9,9.
Justin Morgan
Meskipun saya mungkin harus menunjukkan bahwa ini lebih mendekati benar daripada kebanyakan yang lain. -1 Anda bukan dari saya.
Justin Morgan
Ini adalah RE yang akan saya gunakan, meskipun dengan langkah validasi lain setelahnya (mungkin tidak dengan RE); mencoba melakukan segalanya dengan satu RE membuat hidup jauh lebih sulit.
Donal Fellows
@Justin Morgan Tidak jelas bahwa koma hanya diterima di grup 3 digit. Tapi itu mudah diselesaikan dengan mengubahnya (,\d+)menjadi (,\d\d\d)kurasa.
Neil
2

Regex ini:

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

Cocok dengan setiap angka dalam string:

1 1.0 0.1 1.001 1.000 1.000.000 1000.1 1.000.1 1.323.444.000 1.999 1.222.455.666.0 1.244

Eric D
sumber
2

Ini regex:

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

yang menerima angka:

  • tanpa spasi dan / atau desimal, misalnya. 123456789,123.123
  • dengan koma atau spasi sebagai pemisah ribuan dan / atau desimal, misalnya. 123 456 789, 123 456 789.100, 123,456,3,232,300,000.00

Tes: http://regexr.com/3h1a2

Kacper Cz
sumber
Ini berfungsi dengan baik di regexr.com tetapi dalam modul ulang python tidak berfungsi
Pardhu
1

Berikut adalah konstruksi lain yang dimulai dengan format angka paling sederhana dan kemudian, dengan cara yang tidak tumpang tindih, secara bertahap menambahkan format angka yang lebih kompleks:

Regep jawa:

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

Sebagai String Java (perhatikan \ ekstra yang diperlukan untuk melarikan diri ke \ dan. Karena \ dan. Memiliki arti khusus dalam regexp saat mereka sendiri):

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

Penjelasan:

  1. Regex ini memiliki bentuk A | B | C | D | E | F di mana A, B, C, D, E, F itu sendiri adalah regexps yang tidak tumpang tindih. Secara umum, saya merasa lebih mudah untuk memulai dengan kecocokan yang paling sederhana, A. Jika A melewatkan kecocokan yang Anda inginkan, maka buatlah B yang merupakan modifikasi kecil dari A dan masukkan lebih banyak dari apa yang Anda inginkan. Kemudian, berdasarkan B, buat C yang menangkap lebih banyak, dll. Saya juga merasa lebih mudah untuk membuat regexps yang tidak tumpang tindih; lebih mudah untuk memahami regexp dengan 20 regex sederhana yang tidak tumpang tindih yang terhubung dengan OR daripada beberapa regexp dengan pencocokan yang lebih kompleks. Tapi masing masing untuk mereka sendiri!

  2. A adalah (\ d) dan sama persis dengan salah satu dari 0,1,2,3,4,5,6,7,8,9 yang sangat sederhana!

  3. B adalah ([1-9] \ d +) dan hanya mencocokkan angka dengan 2 digit atau lebih, pertama pengecualian 0. B cocok persis dengan salah satu dari 10,11,12, ... B tidak tumpang tindih dengan A tetapi merupakan modifikasi kecil dari A.

  4. C adalah (. \ D +) dan hanya cocok dengan desimal yang diikuti oleh satu atau lebih digit. C cocok persis dengan salah satu dari .0 .1 .2 .3 .4 .5 .6 .7 .8 .9 .00 .01 .02 .... .23000 ... C memungkinkan jejak eros di sebelah kanan yang saya sukai: jika ini adalah data pengukuran, jumlah nol yang tertinggal menunjukkan tingkat presisi. Jika Anda tidak ingin angka nol di sebelah kanan, ubah (. \ D +) menjadi (. \ D * [1-9]) tetapi ini juga mengecualikan .0 yang menurut saya harus diizinkan. C juga merupakan modifikasi kecil dari A.

  5. D adalah (\ d. \ D *) yang merupakan A plus desimal dengan nol di sebelah kanan. D hanya cocok dengan satu digit, diikuti dengan desimal, diikuti oleh nol atau beberapa digit. D cocok dengan 0. 0.0 0.1 0.2 .... 0.01000 ... 9. 9.0 9.1..0.0230000 .... 9.9999999999 ... Jika Anda ingin mengecualikan "0." lalu ubah D menjadi (\ d. \ d +). Jika Anda ingin mengecualikan nol di sebelah kanan, ubah D menjadi (\ d. \ D * [1-9]) tetapi ini tidak termasuk 2.0 yang menurut saya harus dimasukkan. D tidak tumpang tindih dengan A, B, atau C.

  6. E adalah ([1-9] \ d +. \ D *) yang merupakan B ditambah desimal dengan nol di sebelah kanan. Jika Anda ingin mengecualikan "13.", misalnya, ubah E menjadi ([1-9] \ d +. \ D +). E tidak tumpang tindih dengan A, B, C atau D. E cocok dengan 10. 10.0 10.0100 .... 99.9999999999 ... Nol tertinggal dapat ditangani seperti pada 4. dan 5.

  7. F adalah ([1-9] \ d {0,2} (, \ d {3}) + (. \ D *)?) Dan hanya mencocokkan angka dengan koma dan kemungkinan desimal yang memungkinkan adanya angka nol di sebelah kanan. Grup pertama ([1-9] \ d {0,2}) cocok dengan digit bukan nol diikuti nol, satu atau dua digit lagi. Grup kedua (, \ d {3}) + cocok dengan grup 4 karakter (koma diikuti tepat tiga digit) dan grup ini dapat cocok satu kali atau lebih (tidak ada kecocokan berarti tidak ada koma!). Akhirnya, (. \ D *)? tidak ada yang cocok, atau cocok. dengan sendirinya, atau cocok dengan desimal. diikuti dengan sejumlah digit, mungkin tidak ada. Sekali lagi, untuk mengecualikan hal-hal seperti "1.111.", Ubah (. \ D *) menjadi (. \ D +). Nol tertinggal dapat ditangani seperti pada 4. atau 5. F tidak tumpang tindih dengan A, B, C, D, atau E. Saya tidak dapat memikirkan regexp yang lebih mudah untuk F.

Beri tahu saya jika Anda tertarik dan saya dapat mengedit di atas untuk menangani angka nol di kanan sesuai keinginan.

Inilah yang cocok dengan regexp dan apa yang tidak:

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
David Alexander
sumber
1 
\b\d+,

\ b -------> batas kata

\ d + ------> satu atau digit

, --------> mengandung koma,

Misalnya:

sddsgg 70.000 sdsfdsf fdgfdg70,00

sfsfsd 5,44,4343 5.7788,44 555

Ini akan cocok dengan:

70,

5,

44,

, 44

Ibz.Shaikh
sumber
0 
(,*[\d]+,*[\d]*)+

Ini akan cocok dengan nomor kecil atau besar sebagai berikut dengan atau tanpa koma

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

atau

1
100
1262
156262
1078999
123456789
phpnerd.dll
sumber