2011-03-08 12 views
9

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

([abc]+|[123]+) 

प्रविष्टि के लिए। मेरी अल्पविराम द्वारा पृथक सूची से मेल करने के लिए, मैं कुछ इस तरह के खिलाफ मिलान कर रहा हूँ:

([abc]+|[123]+)(,([abc]+|[123]+))* 

मैं (यह बजाय कम एक मैं यहाँ उदाहरण के लिए इस्तेमाल किया की मेरी बुरा regex के साथ विशेष रूप से मूर्ख दिखता है) महसूस करें कि प्रविष्टि की दो प्रतियां होने के बजाय एक बेहतर तरीका होना चाहिए - एक बार पहली प्रविष्टि के लिए, फिर से और अल्पविराम/प्रविष्टि जोड़े का पालन करें।

उत्तर

3

कुछ इस शायद की तरह:

((?!=^|,)([abc123]))+ 

खराब हो गई यह है:

(      # start of parent capture 
    (?!=^|,)    # look ahead and find either the start of a line or a comma 
    ([abc123])    # actual pattern to look for (token) 
)+      # say this whole pattern is repeatable 

PHP Demo

+0

मुझे नहीं लगता कि आप आगे बढ़ने में '!' चाहते हैं (जो आगे नकारात्मक दिखने के लिए है), लेकिन वास्तव में एक चरित्र वास्तव में एक चरित्र से मेल नहीं खाता है, इसलिए यह मेल नहीं खाएगा। आपको बिना दिखने के ठीक होना चाहिए '(?: (?:^|,) ([ए-सी 1-3])) + ' – jswolf19

+0

@ jswolf19: मैं मैच में घुमावदार चरित्र से बचने के लिए इसका उपयोग करता हूं। मुझे व्यक्तिगत वरीयता लगता है। - संयोजन मुझे पहले मैच और बाकी दोनों भी देता है। (इसके बिना मैं या तो केवल पहला टोकन प्राप्त करूंगा, या दूसरा-आगे) –

+0

मुझे पता है कि आप मैच में ',' नहीं चाहते हैं, लेकिन इसे मिलान करना होगा: यदि आपके पास 'ए, 1' है, तो आपका regex इसे मेल नहीं करेगा। लुकहेड ',' देखता है, लेकिन जब भी आप 1 से मिलान करने का प्रयास करते हैं तब भी यह वहां होता है क्योंकि लुकहेड ',' को फेंक नहीं देता है। आपको उस '(?:) 'के लिए एक गैर-कैप्चरिंग समूह की आवश्यकता है। – jswolf19

6

ऐसा लगता है कि आप चाहते हैं backreferences (प्रदर्शित करने के लिए जिस तरह से सरल था)।

([abc123])(,\1)* 

इसके अलावा, बस FYI करें, [abc]|[123][abc123] के बराबर है।


संपादित करें: आपके संपादन के आधार, मुझे लगता है कि मैं गलत समझा है कि आप क्या करने की कोशिश कर रहे थे। इस प्रयास करें:

([abc123]+(,|$))* 

या यदि आप कम प्रतिबंधक होना चाहते हैं:

([^,]+(,|$))* 

इस अल्पविराम के द्वारा अलग गैर अल्पविराम वर्ण के तार से मेल खाता है। एक आसान दृष्टिकोण केवल [^,]+ के लिए वैश्विक मिलान होगा। जावास्क्रिप्ट में है कि इस तरह दिखेगा:

myString.match(/[^,]+/g) //or /[abc123]+/g, or whatever 

या फिर आप अल्पविराम के पर विभाजित कर सकते हैं:

myString.split(/,/) 
+0

यह कहने जा रहा है कि अगला टोकन पिछले जैसा ही होना चाहिए, न कि यह पैटर्न को फिट करना चाहिए। (यकीन नहीं है कि ओपी क्या चाहता है, वे केवल उत्सुक हैं अगर उन्हें दो बार पैटर्न निर्दिष्ट करने की आवश्यकता है [मैं गलत हो सकता है ...]) –

+0

@Brad: क्या वह नहीं है कि वह क्या कर रहा है? शायद मैं उलझन में हूँ। –

+0

@ जस्टिनमोरगन: शायद आप सही हैं। मैंने इसे पढ़ा "क्या मुझे दो बार देखने के लिए पैटर्न निर्दिष्ट करने की आवश्यकता है?", और "यदि नहीं, तो मैं ऐसा करने से कैसे बचूं"। –

0

मेरे मामले में मैं पूरी लाइन का परीक्षण कर रहा हूँ।

/(?!^,)^((^|,)([abc]+|[123]+))+$/.test('a,b,c,1,2,3'); 
true 

नकारात्मक लुकहेड प्रारंभिक अल्पविराम को छोड़ देता है।

/(?!^,)^((^|,)([abc]+|[123]+))+$/.test(',a,b,c,1,2,3'); 
false 

यदि आपको व्यक्तिगत घटकों की आवश्यकता है तो सत्यापन के बाद एक सरल विभाजन करें।

मैं पीएलएसएस उपखंड अनुभाग और उपखंडों को मान्य कर रहा हूं।

// Check for one or more Section Specs consisting of an optional 
// subsection followed by an "S" and one or two digits. Multiple 
// Section Specs are separated by space or a comma and optional space. 
// 
// Example: SW/4 SW/4 S1, E/2 S2, N/2 N/2 S12 
// 
// Valid subsections are - 
// (1) [NS][EW]/4\s+[NS][EW]/4 eg. NW/4 SE/4 (40 ac) 
// (2) [NSEW]/2\s+[NS][EW]/4  eg. N/2 SE/4 (80 ac) 
// (3) [NS]/2\s+[NS]/2   eg. N/2 S/2 (160 ac) 
// (4) [EW]/2\s+[EW]/2   eg. E/2 W/2 (160 ac) 
// (5) [NS][EW]/4    eg. NE/4 (160 ac) 
// (6) [NSEW]/2     eg. E/2 (320 ac) 
// (7) 1/1      Shorthand for the full section (640 ac) 
// 
// Expressions like E/2 N/2 are not valid. Use NE/4 instead. 
// Expressions like NW/4 E/2 are not valid. You probably want W/2 NE/4. 

var pat = '' + 
    '(([NS][EW]/4|[NSEW]/2)\\s+)?[NS][EW]/4\\s+' + // (1), (2) & (5) 
    '|([NS]/2\\s+)?[NS]/2\\s+' +      // (3) & part of (6) 
    '|([EW]/2\\s+)?[EW]/2\\s+' +      // (4) & part of (6) 
    '|1/1\\s+';          // (7) 

pat = '(' + pat + ')?' + 'S\\d{1,2}';     // a Section Spec 

// Line anchors, join alternatives and negative lookahead to exclude an initial comma 
pat = '(?!^,)^((^|,\\s*|\\s+)(' + pat + '))+$'; 

var re = new RegExp(pat, 'i'); 

console.log(pat); 
(?!^,)^((^|,\s*|\s+)(((([NS][EW]/4|[NSEW]/2)\s+)?[NS][EW]/4\s+|([NS]/2\s+)?[NS]/2\s+|([EW]/2\s+)?[EW]/2\s+|1/1\s+)?S\d{1,2}))+$ 

एक बार मान्य होने पर मैं सकारात्मक दिखने का उपयोग करके विभाजित हो जाता हूं।

var secs = val.split(/(?<=S\d+)(,\s*|\s+)/i); 
संबंधित मुद्दे