दिलचस्प पोस्ट
एनजीएनएक्स में एक यूआरएल रीराइट लिखने के लिए कैसे? क्या यह मेमोकैश में PHP सत्रों को संग्रहीत करने की सिफारिश की है? क्या जावा को ब्लॉकों को कसकर संभव के रूप में स्कॉच करने का प्रयास करना चाहिए? PHP में निर्देशिका आकार कैसे प्राप्त करें मैं $ स्कोप का उपयोग कैसे करूं? $ Watch और $ scope.AngularJS में $ लागू होते हैं? Django में क्लाइंट-साइड कैशिंग लड़ रहा है दो एक-आयामी NumPy arrays को शामिल करना Android में थ्रेडिंग उदाहरण सॉकेट.आईओ – मैं जुड़ा सॉकेट / क्लाइंट की एक सूची कैसे प्राप्त करूं? के लिए PHP शॉर्टहैड क्या है: print var if var अस्तित्व में है क्या सॉर्टेड सूची <कश्मीर, वी> पर एक निचला बाउंड फ़ंक्शन है? कैसे Windows में एक प्रक्रिया को निलंबित / पुनः आरंभ करें? मैटप्ललिब में पाठ का आंशिक रंग एक UIView पर एकाधिक UITableViews पूर्ण पथ से संबंधित पथ कैसे प्राप्त करें

पाठ में बिना अल्पविराम और बिना दशमलव अंकों के मिलान करने के लिए नियमित अभिव्यक्ति

मैं पाठ के एक भाग में सभी नंबरों को ढूंढने और बदलने की कोशिश कर रहा हूं मैंने कुछ उदाहरण regex पाया है, जो लगभग समस्या का समाधान करते हैं, लेकिन कोई भी अभी तक सही नहीं है मेरे पास समस्या यह है कि मेरे पाठ की संख्या में दशमलव और अल्पविराम नहीं हो सकते हैं या नहीं। उदाहरण के लिए:

"5000 एलबी। लोमड़ी 99,999.9 9998713 फुट बाड़ पर कूद गए।"

Regex " 5000 " और " 99,999.99998713 " वापस करना चाहिए। उदाहरण मैंने अल्पविराम पर नंबरों को तोड़ने या दो दशमलव स्थानों तक सीमित कर दिया है। मैं regex के पर्याप्त समझने के लिए शुरू कर रहा हूँ कि क्यों कुछ उदाहरण दो दशमलव स्थानों तक सीमित हैं, लेकिन मैंने अभी तक इसे कैसे दूर नहीं किया है और पूरी श्रृंखला पाने के लिए अल्पविराम भी शामिल नहीं किया है

यहां मेरा नवीनतम संस्करण है:

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

जो उपरोक्त पाठ के लिए " 5000 ", " 99,99 ", " 9.99 ", और " 998713 " देता है

Solutions Collecting From Web of "पाठ में बिना अल्पविराम और बिना दशमलव अंकों के मिलान करने के लिए नियमित अभिव्यक्ति"

संपादित करें: चूंकि इसने बहुत सारे विचार प्राप्त किए हैं, मुझे उन सभी को देकर शुरू करना चाहिए जो वे इसके लिए 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 , 9 9,9,9 , या यहां तक ​​कि .,,. । यह तय करने के लिए काफी आसान है, भले ही संख्या अन्य पाठ में एम्बेड की गई हो। आईएमएचओ जो कुछ भी 1,234.56 और 1234 को खींचने में विफल रहता है- और केवल उन संख्याएं- abc22 1,234.56 9.9.9.9 def 1234 का एक गलत जवाब है।

सबसे पहले, यदि आपको यह सब एक रेगेक्स में करने की ज़रूरत नहीं है, तो नहीं। दो अलग-अलग नंबर स्वरूपों के लिए एक एकल regex बनाए रखने में कठिनाई होती है, भले ही वे अन्य टेक्स्ट में एम्बेड न हों आपको वास्तव में क्या करना चाहिए, पूरी जगह को सफेद स्थान पर विभाजित किया जाता है, फिर परिणाम पर दो या तीन छोटे रीजेक्स चलाएं। अगर यह आपके लिए कोई विकल्प नहीं है, तो पढ़ना जारी रखें।

मूल पैटर्न

आपके द्वारा दिए गए उदाहरणों को ध्यान में रखते हुए, यहां एक सरल regex है जो कि 0000 प्रारूप में बहुत अधिक पूर्णांक या दशमलव की अनुमति देता है और बाकी सब कुछ ब्लॉक करता है:

 ^\d*\.?\d+$ 

यहां एक है जिसकी आवश्यकता है 0,000 प्रारूप:

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

उन्हें एक साथ रखो, और अल्पकालिक अल्पकालिक रूप में वैकल्पिक हो जाते हैं, क्योंकि वे संगत हैं:

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

एंबेडेड संख्याएं

ऊपर दिए गए पैटर्नों को पूरे इनपुट को एक संख्या होने की आवश्यकता होती है। आप पाठ में एम्बेड किए गए नंबरों की तलाश कर रहे हैं, इसलिए आपको उस भाग को ढीला करना होगा। दूसरी तरफ, आप इसे नहीं देखते हैं कि यह catch22 और आपको लगता है कि यह नंबर 22 पाया गया है। अगर आप कुछ देख रहे हैं (जैसे .नेट), यह बहुत आसान है: ^ (?<!\S) और $ (?!\S) और आप जाने के लिए अच्छा कर रहे हैं:

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

यदि आप जावास्क्रिप्ट या रूबी या कुछ चीज़ों के साथ काम कर रहे हैं, तो चीजें अधिक जटिल दिखना शुरू कर देंगी:

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

आपको कब्जा समूहों का उपयोग करना होगा; मैं बिना किसी आधार के समर्थन के विकल्प के बारे में सोच सकता हूं जो नंबर आप चाहते हैं वे समूह 1 में होंगे (मान लें कि पूरे मैच समूह 0 है)।

मान्यकरण और अधिक जटिल नियम

मुझे लगता है कि आपके प्रश्न को शामिल किया गया है, इसलिए यदि आपको ये सिर्फ ज़रूरत है, तो अब पढ़ना बंद करो अगर आप चाहें तो फंतासी प्राप्त करना चाहते हैं, चीजें बहुत जल्दी से बहुत जटिल हो जाती हैं आपकी स्थिति के आधार पर, आप निम्न में से किसी भी या सभी को अवरुद्ध कर सकते हैं:

  • रिक्त इनपुट
  • अग्रणी शून्य (जैसे 000123)
  • अनुरेखण शून्य (उदाहरण 1.2340000)
  • दशांश अंक से शुरु होने वाले दशमलव (उदाहरण के लिए 0.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 

इस रीजेक्स को सरल और छोटा बनाने के कई तरीके हैं, लेकिन यह समझते हैं कि पैटर्न को बदलने से वह संख्या को मान लेगा।

चूंकि कई रेगेक्स इंजन (उदाहरण के लिए जावास्क्रिप्ट और रूबी) नकारात्मक रूप से पीछे नहीं हटते हैं, इसलिए यह सही ढंग से करने का एकमात्र तरीका कैप्चर समूहों के साथ है:

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

जिन संख्या आप खोज रहे हैं वे कैप्चर ग्रुप 1 में होंगे

यहां टेस्ट किया गया: http://rubular.com/r/3HCSkndzhT

एक अंतिम नोट

जाहिर है, यह एक विशाल, जटिल, निकट-अपठनीय regex है। मुझे चुनौती का मज़ा आया, लेकिन आपको इस बात पर विचार करना चाहिए कि क्या आप वास्तव में इसका उपयोग उत्पादन वातावरण में करना चाहते हैं। एक ही कदम में सब कुछ करने की कोशिश करने के बजाय, आप इसे दो में कर सकते हैं: किसी भी चीज को पकड़ने के लिए एक regex, जो एक संख्या हो सकती है, फिर दूसरा एक जो कुछ भी नहीं है, बाहर निकल जाए। या आप कुछ बुनियादी प्रसंस्करण कर सकते हैं, फिर अपनी भाषा के अंतर्निर्मित संख्या पार्सिंग फ़ंक्शन का उपयोग करें। आपकी पंसद।

कुछ दिन पहले, मैंने संख्याओं की स्ट्रिंग से पीछे शून्य को हटाने की समस्या पर काम किया।

उस समस्या की निरंतरता में, मुझे यह एक दिलचस्प लगता है क्योंकि यह समस्या अल्पविरामों की संख्याओं को बढ़ाती है।

मैंने उस पिछली समस्या में मैंने लिखा है कि मैंने रेगेक्स के पैटर्न को ले लिया है और मैंने इसे सुधार किया है ताकि यह संख्याओं को इस समस्या के लिए उत्तर के रूप में अल्पविराम से इलाज कर सके।

मुझे अपने उत्साह और रेगेक्सस की पसंद के साथ ले जाया गया है। मुझे नहीं पता कि परिणाम माइकल प्रेस्कॉट द्वारा व्यक्त की जाने वाली जरूरतों के अनुरूप है। मुझे उन बिंदुओं को जानने में दिलचस्पी होगी जो मेरे रेगेक्स में अधिक या कम हैं, और इसे आपके लिए अधिक उपयुक्त बनाने के लिए इसे ठीक करने के लिए।

अब, इस रेगेक्स पर काम करने के एक लंबे सत्र के बाद, मेरे पास मस्तिष्क में एक तरह का वजन है, इसलिए मैं काफी स्पष्टीकरण देने के लिए पर्याप्त ताज़ा नहीं हूं। यदि अंक अस्पष्ट हैं, और यदि कोई भी पर्याप्त रुचि ले सकता है, तो कृपया मुझसे पूछें।

रैगेक्स को उस क्रम में बनाया गया है कि यह वैज्ञानिक संकेतन 2 ई 10 या 5,22,454.12 ई -0.0478 में व्यक्त की गई संख्याओं को भी पता लगा सकता है, ऐसे संख्याओं के दो हिस्सों में अनावश्यक शून्य को भी हटा सकता है। यदि एक एक्सपोनेंट शून्य के बराबर है, तो संख्या को संशोधित किया जाता है ताकि कोई और अधिक एक्सपोनेंट न हो।

मैंने कुछ सत्यापन को पैटर्न में रखा है ताकि कुछ विशेष मामलों का मिलान न हो, उदाहरण के लिए '12 ..57 ' मैच नहीं होगा। लेकिन '111' स्ट्रिंग '111' मैचों में क्योंकि पूर्ववर्ती अल्पविराम किसी अल्पविराम के रूप में नहीं माना जाता है, लेकिन वाक्य के अल्पविराम।

मुझे लगता है कि अल्पविरामों के प्रबंधन में सुधार किया जाना चाहिए, क्योंकि मुझे लगता है कि भारतीय संख्याओं में कॉमा के बीच केवल 2 अंक हैं। यह सही करने के लिए अलग नहीं होगा, मुझे लगता है

इसके बाद एक कोड दिखाया गया है कि मेरा रेजेक्स कैसे काम करता है। इसके अनुसार, दो कार्य हैं, यदि कोई चाहता है कि '.1245' को '0.1245' में परिवर्तित किया जाए या नहीं यदि कोई त्रुटि या अवांछित मैचिंग या अनमाइचिंग संख्या स्ट्रिंग के कुछ मामलों में रहेगी तो मुझे आश्चर्य नहीं होगा; तो मैं इन मामलों को समझने और कमी को समझना चाहता हूं।

मैं पायथन में लिखी गई इस कोड के लिए खेद है, लेकिन regexes पार लंगर हैं और मुझे लगता है कि सब reex के पैटर्न undertsanding करने में सक्षम हो जाएगा

 import re regx = re.compile('(?<![\d.])(?!\.\.)(?<![\d.][eE][+-])(?<![\d.][eE])(?<!\d[.,])' '' #--------------------------------- '([+-]?)' '(?![\d,]*?\.[\d,]*?\.[\d,]*?)' '(?:0|,(?=0)|(?<!\d),)*' '(?:' '((?:\d(?!\.[1-9])|,(?=\d))+)[.,]?' '|\.(0)' '|((?<!\.)\.\d+?)' '|([\d,]+\.\d+?))' '0*' '' #--------------------------------- '(?:' '([eE][+-]?)(?:0|,(?=0))*' '(?:' '(?!0+(?=\D|\Z))((?:\d(?!\.[1-9])|,(?=\d))+)[.,]?' '|((?<!\.)\.(?!0+(?=\D|\Z))\d+?)' '|([\d,]+\.(?!0+(?=\D|\Z))\d+?))' '0*' ')?' '' #--------------------------------- '(?![.,]?\d)') def dzs_numbs(x,regx = regx): # ds = detect and zeros-shave if not regx.findall(x): yield ('No match,', 'No catched string,', 'No groups.') for mat in regx.finditer(x): yield (mat.group(), ''.join(mat.groups('')), mat.groups('')) def dzs_numbs2(x,regx = regx): # ds = detect and zeros-shave if not regx.findall(x): yield ('No match,', 'No catched string,', 'No groups.') for mat in regx.finditer(x): yield (mat.group(), ''.join(('0' if n.startswith('.') else '')+n for n in mat.groups('')), mat.groups('')) NS = [' 23456000and23456000. or23456000.000 00023456000 s000023456000. 000023456000.000 ', 'arf 10000 sea10000.+10000.000 00010000-00010000. kant00010000.000 ', ' 24: 24, 24. 24.000 24.000, 00024r 00024. blue 00024.000 ', ' 8zoom8. 8.000 0008 0008. and0008.000 ', ' 0 00000M0. = 000. 0.0 0.000 000.0 000.000 .000000 .0 ', ' .0000023456 .0000023456000 ' ' .0005872 .0005872000 .00503 .00503000 ', ' .068 .0680000 .8 .8000 .123456123456 .123456123456000 ', ' .657 .657000 .45 .4500000 .7 .70000 0.0000023230000 000.0000023230000 ', ' 0.0081000 0000.0081000 0.059000 0000.059000 ', ' 0.78987400000 snow 00000.78987400000 0.4400000 00000.4400000 ', ' -0.5000 -0000.5000 0.90 000.90 0.7 000.7 ', ' 2.6 00002.6 00002.60000 4.71 0004.71 0004.7100 ', ' 23.49 00023.49 00023.490000 103.45 0000103.45 0000103.45000 ', ' 10003.45067 000010003.45067 000010003.4506700 ', ' +15000.0012 +000015000.0012 +000015000.0012000 ', ' 78000.89 000078000.89 000078000.89000 ', ' .0457e10 .0457000e10 00000.0457000e10 ', ' 258e8 2580000e4 0000000002580000e4 ', ' 0.782e10 0000.782e10 0000.7820000e10 ', ' 1.23E2 0001.23E2 0001.2300000E2 ', ' 432e-102 0000432e-102 004320000e-106 ', ' 1.46e10and0001.46e10 0001.4600000e10 ', ' 1.077e-300 0001.077e-300 0001.077000e-300 ', ' 1.069e10 0001.069e10 0001.069000e10 ', ' 105040.03e10 000105040.03e10 105040.0300e10 ', ' +286E000024.487900 -78.4500e.14500 .0140E789. ', ' 081,12.40E07,95.0120 0045,78,123.03500e-0.00 ', ' 0096,78,473.0380e-0. 0008,78,373.066000E0. 0004512300.E0000 ', ' ..18000 25..00 36...77 2..8 ', ' 3.8..9 .12500. 12.51.400 ', ' 00099,111.8713000 -0012,45,83,987.26+0.000,099,88,44.or00,00,00.00must', ' 00099,44,and 0000,099,88,44.bom', '00,000,00.587000 77,98,23,45., this,that ', ' ,111 145.20 +9,9,9 0012800 .,,. 1 100,000 ', '1,1,1.111 000,001.111 -999. 0. 111.110000 1.1.1.111 9.909,888'] for ch in NS: print 'string: '+repr(ch) for strmatch, modified, the_groups in dzs_numbs2(ch): print strmatch.rjust(20),'',modified,'',the_groups print 

परिणाम

 string: ' 23456000and23456000. or23456000.000 00023456000 s000023456000. 000023456000.000 ' 23456000 23456000 ('', '23456000', '', '', '', '', '', '', '') 23456000. 23456000 ('', '23456000', '', '', '', '', '', '', '') 23456000.000 23456000 ('', '23456000', '', '', '', '', '', '', '') 00023456000 23456000 ('', '23456000', '', '', '', '', '', '', '') 000023456000. 23456000 ('', '23456000', '', '', '', '', '', '', '') 000023456000.000 23456000 ('', '23456000', '', '', '', '', '', '', '') string: 'arf 10000 sea10000.+10000.000 00010000-00010000. kant00010000.000 ' 10000 10000 ('', '10000', '', '', '', '', '', '', '') 10000. 10000 ('', '10000', '', '', '', '', '', '', '') 10000.000 10000 ('', '10000', '', '', '', '', '', '', '') 00010000 10000 ('', '10000', '', '', '', '', '', '', '') 00010000. 10000 ('', '10000', '', '', '', '', '', '', '') 00010000.000 10000 ('', '10000', '', '', '', '', '', '', '') string: ' 24: 24, 24. 24.000 24.000, 00024r 00024. blue 00024.000 ' 24 24 ('', '24', '', '', '', '', '', '', '') 24, 24 ('', '24', '', '', '', '', '', '', '') 24. 24 ('', '24', '', '', '', '', '', '', '') 24.000 24 ('', '24', '', '', '', '', '', '', '') 24.000 24 ('', '24', '', '', '', '', '', '', '') 00024 24 ('', '24', '', '', '', '', '', '', '') 00024. 24 ('', '24', '', '', '', '', '', '', '') 00024.000 24 ('', '24', '', '', '', '', '', '', '') string: ' 8zoom8. 8.000 0008 0008. and0008.000 ' 8 8 ('', '8', '', '', '', '', '', '', '') 8. 8 ('', '8', '', '', '', '', '', '', '') 8.000 8 ('', '8', '', '', '', '', '', '', '') 0008 8 ('', '8', '', '', '', '', '', '', '') 0008. 8 ('', '8', '', '', '', '', '', '', '') 0008.000 8 ('', '8', '', '', '', '', '', '', '') string: ' 0 00000M0. = 000. 0.0 0.000 000.0 000.000 .000000 .0 ' 0 0 ('', '0', '', '', '', '', '', '', '') 00000 0 ('', '0', '', '', '', '', '', '', '') 0. 0 ('', '0', '', '', '', '', '', '', '') 000. 0 ('', '0', '', '', '', '', '', '', '') 0.0 0 ('', '', '0', '', '', '', '', '', '') 0.000 0 ('', '', '0', '', '', '', '', '', '') 000.0 0 ('', '', '0', '', '', '', '', '', '') 000.000 0 ('', '', '0', '', '', '', '', '', '') .000000 0 ('', '', '0', '', '', '', '', '', '') .0 0 ('', '', '0', '', '', '', '', '', '') string: ' .0000023456 .0000023456000 .0005872 .0005872000 .00503 .00503000 ' .0000023456 0.0000023456 ('', '', '', '.0000023456', '', '', '', '', '') .0000023456000 0.0000023456 ('', '', '', '.0000023456', '', '', '', '', '') .0005872 0.0005872 ('', '', '', '.0005872', '', '', '', '', '') .0005872000 0.0005872 ('', '', '', '.0005872', '', '', '', '', '') .00503 0.00503 ('', '', '', '.00503', '', '', '', '', '') .00503000 0.00503 ('', '', '', '.00503', '', '', '', '', '') string: ' .068 .0680000 .8 .8000 .123456123456 .123456123456000 ' .068 0.068 ('', '', '', '.068', '', '', '', '', '') .0680000 0.068 ('', '', '', '.068', '', '', '', '', '') .8 0.8 ('', '', '', '.8', '', '', '', '', '') .8000 0.8 ('', '', '', '.8', '', '', '', '', '') .123456123456 0.123456123456 ('', '', '', '.123456123456', '', '', '', '', '') .123456123456000 0.123456123456 ('', '', '', '.123456123456', '', '', '', '', '') string: ' .657 .657000 .45 .4500000 .7 .70000 0.0000023230000 000.0000023230000 ' .657 0.657 ('', '', '', '.657', '', '', '', '', '') .657000 0.657 ('', '', '', '.657', '', '', '', '', '') .45 0.45 ('', '', '', '.45', '', '', '', '', '') .4500000 0.45 ('', '', '', '.45', '', '', '', '', '') .7 0.7 ('', '', '', '.7', '', '', '', '', '') .70000 0.7 ('', '', '', '.7', '', '', '', '', '') 0.0000023230000 0.000002323 ('', '', '', '.000002323', '', '', '', '', '') 000.0000023230000 0.000002323 ('', '', '', '.000002323', '', '', '', '', '') string: ' 0.0081000 0000.0081000 0.059000 0000.059000 ' 0.0081000 0.0081 ('', '', '', '.0081', '', '', '', '', '') 0000.0081000 0.0081 ('', '', '', '.0081', '', '', '', '', '') 0.059000 0.059 ('', '', '', '.059', '', '', '', '', '') 0000.059000 0.059 ('', '', '', '.059', '', '', '', '', '') string: ' 0.78987400000 snow 00000.78987400000 0.4400000 00000.4400000 ' 0.78987400000 0.789874 ('', '', '', '.789874', '', '', '', '', '') 00000.78987400000 0.789874 ('', '', '', '.789874', '', '', '', '', '') 0.4400000 0.44 ('', '', '', '.44', '', '', '', '', '') 00000.4400000 0.44 ('', '', '', '.44', '', '', '', '', '') string: ' -0.5000 -0000.5000 0.90 000.90 0.7 000.7 ' -0.5000 -0.5 ('-', '', '', '.5', '', '', '', '', '') -0000.5000 -0.5 ('-', '', '', '.5', '', '', '', '', '') 0.90 0.9 ('', '', '', '.9', '', '', '', '', '') 000.90 0.9 ('', '', '', '.9', '', '', '', '', '') 0.7 0.7 ('', '', '', '.7', '', '', '', '', '') 000.7 0.7 ('', '', '', '.7', '', '', '', '', '') string: ' 2.6 00002.6 00002.60000 4.71 0004.71 0004.7100 ' 2.6 2.6 ('', '', '', '', '2.6', '', '', '', '') 00002.6 2.6 ('', '', '', '', '2.6', '', '', '', '') 00002.60000 2.6 ('', '', '', '', '2.6', '', '', '', '') 4.71 4.71 ('', '', '', '', '4.71', '', '', '', '') 0004.71 4.71 ('', '', '', '', '4.71', '', '', '', '') 0004.7100 4.71 ('', '', '', '', '4.71', '', '', '', '') string: ' 23.49 00023.49 00023.490000 103.45 0000103.45 0000103.45000 ' 23.49 23.49 ('', '', '', '', '23.49', '', '', '', '') 00023.49 23.49 ('', '', '', '', '23.49', '', '', '', '') 00023.490000 23.49 ('', '', '', '', '23.49', '', '', '', '') 103.45 103.45 ('', '', '', '', '103.45', '', '', '', '') 0000103.45 103.45 ('', '', '', '', '103.45', '', '', '', '') 0000103.45000 103.45 ('', '', '', '', '103.45', '', '', '', '') string: ' 10003.45067 000010003.45067 000010003.4506700 ' 10003.45067 10003.45067 ('', '', '', '', '10003.45067', '', '', '', '') 000010003.45067 10003.45067 ('', '', '', '', '10003.45067', '', '', '', '') 000010003.4506700 10003.45067 ('', '', '', '', '10003.45067', '', '', '', '') string: ' +15000.0012 +000015000.0012 +000015000.0012000 ' +15000.0012 +15000.0012 ('+', '', '', '', '15000.0012', '', '', '', '') +000015000.0012 +15000.0012 ('+', '', '', '', '15000.0012', '', '', '', '') +000015000.0012000 +15000.0012 ('+', '', '', '', '15000.0012', '', '', '', '') string: ' 78000.89 000078000.89 000078000.89000 ' 78000.89 78000.89 ('', '', '', '', '78000.89', '', '', '', '') 000078000.89 78000.89 ('', '', '', '', '78000.89', '', '', '', '') 000078000.89000 78000.89 ('', '', '', '', '78000.89', '', '', '', '') string: ' .0457e10 .0457000e10 00000.0457000e10 ' .0457e10 0.0457e10 ('', '', '', '.0457', '', 'e', '10', '', '') .0457000e10 0.0457e10 ('', '', '', '.0457', '', 'e', '10', '', '') 00000.0457000e10 0.0457e10 ('', '', '', '.0457', '', 'e', '10', '', '') string: ' 258e8 2580000e4 0000000002580000e4 ' 258e8 258e8 ('', '258', '', '', '', 'e', '8', '', '') 2580000e4 2580000e4 ('', '2580000', '', '', '', 'e', '4', '', '') 0000000002580000e4 2580000e4 ('', '2580000', '', '', '', 'e', '4', '', '') string: ' 0.782e10 0000.782e10 0000.7820000e10 ' 0.782e10 0.782e10 ('', '', '', '.782', '', 'e', '10', '', '') 0000.782e10 0.782e10 ('', '', '', '.782', '', 'e', '10', '', '') 0000.7820000e10 0.782e10 ('', '', '', '.782', '', 'e', '10', '', '') string: ' 1.23E2 0001.23E2 0001.2300000E2 ' 1.23E2 1.23E2 ('', '', '', '', '1.23', 'E', '2', '', '') 0001.23E2 1.23E2 ('', '', '', '', '1.23', 'E', '2', '', '') 0001.2300000E2 1.23E2 ('', '', '', '', '1.23', 'E', '2', '', '') string: ' 432e-102 0000432e-102 004320000e-106 ' 432e-102 432e-102 ('', '432', '', '', '', 'e-', '102', '', '') 0000432e-102 432e-102 ('', '432', '', '', '', 'e-', '102', '', '') 004320000e-106 4320000e-106 ('', '4320000', '', '', '', 'e-', '106', '', '') string: ' 1.46e10and0001.46e10 0001.4600000e10 ' 1.46e10 1.46e10 ('', '', '', '', '1.46', 'e', '10', '', '') 0001.46e10 1.46e10 ('', '', '', '', '1.46', 'e', '10', '', '') 0001.4600000e10 1.46e10 ('', '', '', '', '1.46', 'e', '10', '', '') string: ' 1.077e-300 0001.077e-300 0001.077000e-300 ' 1.077e-300 1.077e-300 ('', '', '', '', '1.077', 'e-', '300', '', '') 0001.077e-300 1.077e-300 ('', '', '', '', '1.077', 'e-', '300', '', '') 0001.077000e-300 1.077e-300 ('', '', '', '', '1.077', 'e-', '300', '', '') string: ' 1.069e10 0001.069e10 0001.069000e10 ' 1.069e10 1.069e10 ('', '', '', '', '1.069', 'e', '10', '', '') 0001.069e10 1.069e10 ('', '', '', '', '1.069', 'e', '10', '', '') 0001.069000e10 1.069e10 ('', '', '', '', '1.069', 'e', '10', '', '') string: ' 105040.03e10 000105040.03e10 105040.0300e10 ' 105040.03e10 105040.03e10 ('', '', '', '', '105040.03', 'e', '10', '', '') 000105040.03e10 105040.03e10 ('', '', '', '', '105040.03', 'e', '10', '', '') 105040.0300e10 105040.03e10 ('', '', '', '', '105040.03', 'e', '10', '', '') string: ' +286E000024.487900 -78.4500e.14500 .0140E789. ' +286E000024.487900 +286E24.4879 ('+', '286', '', '', '', 'E', '', '', '24.4879') -78.4500e.14500 -78.45e0.145 ('-', '', '', '', '78.45', 'e', '', '.145', '') .0140E789. 0.014E789 ('', '', '', '.014', '', 'E', '789', '', '') string: ' 081,12.40E07,95.0120 0045,78,123.03500e-0.00 ' 081,12.40E07,95.0120 81,12.4E7,95.012 ('', '', '', '', '81,12.4', 'E', '', '', '7,95.012') 0045,78,123.03500 45,78,123.035 ('', '', '', '', '45,78,123.035', '', '', '', '') string: ' 0096,78,473.0380e-0. 0008,78,373.066000E0. 0004512300.E0000 ' 0096,78,473.0380 96,78,473.038 ('', '', '', '', '96,78,473.038', '', '', '', '') 0008,78,373.066000 8,78,373.066 ('', '', '', '', '8,78,373.066', '', '', '', '') 0004512300. 4512300 ('', '4512300', '', '', '', '', '', '', '') string: ' ..18000 25..00 36...77 2..8 ' No match, No catched string, No groups. string: ' 3.8..9 .12500. 12.51.400 ' No match, No catched string, No groups. string: ' 00099,111.8713000 -0012,45,83,987.26+0.000,099,88,44.or00,00,00.00must' 00099,111.8713000 99,111.8713 ('', '', '', '', '99,111.8713', '', '', '', '') -0012,45,83,987.26 -12,45,83,987.26 ('-', '', '', '', '12,45,83,987.26', '', '', '', '') 00,00,00.00 0 ('', '', '0', '', '', '', '', '', '') string: ' 00099,44,and 0000,099,88,44.bom' 00099,44, 99,44 ('', '99,44', '', '', '', '', '', '', '') 0000,099,88,44. 99,88,44 ('', '99,88,44', '', '', '', '', '', '', '') string: '00,000,00.587000 77,98,23,45., this,that ' 00,000,00.587000 0.587 ('', '', '', '.587', '', '', '', '', '') 77,98,23,45. 77,98,23,45 ('', '77,98,23,45', '', '', '', '', '', '', '') string: ' ,111 145.20 +9,9,9 0012800 .,,. 1 100,000 ' ,111 111 ('', '111', '', '', '', '', '', '', '') 145.20 145.2 ('', '', '', '', '145.2', '', '', '', '') +9,9,9 +9,9,9 ('+', '9,9,9', '', '', '', '', '', '', '') 0012800 12800 ('', '12800', '', '', '', '', '', '', '') 1 1 ('', '1', '', '', '', '', '', '', '') 100,000 100,000 ('', '100,000', '', '', '', '', '', '', '') string: '1,1,1.111 000,001.111 -999. 0. 111.110000 1.1.1.111 9.909,888' 1,1,1.111 1,1,1.111 ('', '', '', '', '1,1,1.111', '', '', '', '') 000,001.111 1.111 ('', '', '', '', '1.111', '', '', '', '') -999. -999 ('-', '999', '', '', '', '', '', '', '') 0. 0 ('', '0', '', '', '', '', '', '', '') 111.110000 111.11 ('', '', '', '', '111.11', '', '', '', '') 

आवश्यकताओं के साथ एक निश्चित स्वतंत्रता लेना, आप के लिए देख रहे हैं

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

लेकिन ध्यान दें यह 11,11,1 जैसे मैच होगा

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

यह मानता है कि किसी भी अल्पविराम या दशमलव के पहले या बाद में कम से कम एक अंक भी होता है और यह भी मानता है कि अधिक से अधिक एक दशमलव है और यह कि सभी अल्पविराम दशमलव से पहले हैं।

नीचे regex आपके उदाहरण से दोनों नंबरों से मेल खाएगा।

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

यह 5000 और 99,999.99998713 – आपकी आवश्यकताओं के अनुरूप होगा।

यहां एक और निर्माण होता है जो सरल संख्या प्रारूप से शुरू होता है और फिर, गैर-अतिव्यापी तरीके से, उत्तरोत्तर अधिक जटिल संख्या प्रारूपों को जोड़ता है:

जावा रेपिप:

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

एक जावा स्ट्रिंग के रूप में (ध्यान दें कि अतिरिक्त और \ से बचने के लिए जरूरी है, क्योंकि \ और जब उनके स्वयं के होने पर रेगेक्स में विशेष अर्थ होता है):

 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 है जहां ए, बी, सी, डी, ई, एफ स्वतः ही regexps हैं जो ओवरलैप नहीं करते हैं। आम तौर पर, मैं सरलतम संभव मैचों के साथ शुरू करना आसान करता हूं, ए। यदि कोई आपसे मेल खाता है, तो एक बी बनाएं, जो कि ए के एक छोटे संशोधन है और इसमें कुछ भी शामिल है जो आप चाहते हैं। फिर, बी के आधार पर, एक सी बनाएँ जो अधिक पकड़ता है, आदि। मुझे यह भी regexps बनाने में आसान लगता है जो ओवरलैप नहीं करते; अधिक जटिल मिलान वाले कुछ regexps के बजाय ओआरएस के साथ जुड़े 20 साधारण गैर-ओवरलैपिंग regexps के साथ एक regexp समझना आसान है। लेकिन अपने स्वयं के लिए प्रत्येक!

  2. ए (\ d) है और 0,1,2,3,4,5,6,7,8,9 में से एक से मेल खाता है जो कि आसान नहीं हो सकता!

  3. बी ([1- 9] \ d +) है और केवल 2 या उससे अधिक अंकों वाले नंबर से मेल खाता है, पहले छोड़कर 0 बी 10,11,12 में से एक के बराबर है, … बी एक ओवरलैप नहीं करता है लेकिन ए का एक छोटा संशोधन है।

  4. सी है (। \ D +) और केवल एक या अधिक अंक के बाद दशमलव के साथ मेल खाता है। सी .0.1 .2 .3 .4.5 .6 .7 .8 .9 .00 .01 .02 में से ठीक से मेल खाता है …। .23000 … सी दाईं तरफ इरोस को पीछे छोड़ देता है जो मुझे पसंद है: अगर यह मापन डेटा है, तो अनुक्रमांक शून्य की संख्या सटीक स्तर का संकेत देती है। यदि आप सही पर पीछे वाले शून्य नहीं चाहते हैं, तो (। \ D * [1-9]) को बदलकर (। \ D * [1-9]) बदल सकते हैं लेकिन यह इसमें शामिल नहीं है .0 जो मुझे लगता है कि अनुमति दी जानी चाहिए। सी ए के एक छोटे संशोधन भी है।

  5. डी है (\ 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 * [1-9]) में बदल दें, लेकिन इसमें 2.0 को शामिल नहीं किया गया है जो मुझे लगता है कि इसमें शामिल होना चाहिए। डी ए, बी या सी ओवरलैप नहीं करता है

  6. ई है ([1- 9] \ d +। \ D *) जो दाईं ओर अनुक्रमित शून्य के साथ बी प्लस डेसिमल है। यदि आप "13." को बाहर करना चाहते हैं, उदाहरण के लिए, फिर ई ([1- 9] \ d +। \ D +) को बदलें। ई ए, बी, सी या डी। ओवरलैप नहीं करता 10. 10.0 10.0100 …. 99.9999999999 … ट्रेलिंग शून्य को 4 और 5 के रूप में नियंत्रित किया जा सकता है।

  7. एफ ([1- 9] \ d {0}} ((\ d {3}) + (। \ D *)?) और केवल कॉमा के साथ संख्याओं को मेल खाता है और संभवत: दशमलव के दाईं ओर अनुक्रमित शून्य को अनुमति देता है। पहला समूह ([1- 9] \ d {0,2}) शून्य से एक शून्य अंकों से मेल खाता है, शून्य या एक या दो अंकों के बाद। दूसरा समूह (, \ d {3}) + एक 4 वर्ण समूह (बिल्कुल तीन अंकों के बाद एक अल्पविराम) के साथ मेल खाता है और यह समूह एक या अधिक बार मेल कर सकता है (कोई भी मैच नहीं है कोई अल्पविराम!)। अंत में, (। \ D *)? कुछ भी नहीं, या मैचों से मेल खाता है अपने आप से, या दशमलव से मेल खाता है किसी भी संख्या के बाद, शायद कोई नहीं Again, to exclude things like "1,111.", change (.\d*) to (.\d+). Trailing zeros can be handled as in 4. or 5. F does not overlap A,B,C,D, or E. I couldn't think of an easier regexp for F.

Let me know if you are interested and I can edit above to handle the trailing zeros on the right as desired.

Here is what matches regexp and what does not:

 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 

यह regex:

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

Matched every number in the 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

Here's a regex:

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

that accepts numbers:

  • without spaces and/or decimals, eg. 123456789 , 123.123
  • with commas or spaces as thousands separator and/or decimals, eg. 123 456 789 , 123 456 789.100 , 123,456 , 3,232,300,000.00

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