क्या मैं एक नियमित अभिव्यक्ति में एक बुलियन और स्थिति का उपयोग कर सकता हूं?

Question

कहो, अगर मैं एक डी एन स्ट्रिंग, कुछ इस तरह है:

OU=Karen,OU=Office,OU=admin,DC=corp,DC=Fabrikam,DC=COM 

कैसे एक रेगुलर एक्सप्रेशन बनाने के लिए केवल DNS कि दोनों OU=Karen और OU=admin है लेने के लिए?

Answer 1

इस regex अग्रदर्शी समाधान, पूरी स्ट्रिंग मिलान है यदि यह सिर्फ संदर्भ के लिए किसी भी क्रम में आवश्यक भाग हैं। आप विन्यास चर के कुछ प्रकार में पैटर्न की दुकान नहीं है, तो मैं nhahtdh समाधान के साथ है, हालांकि सवाल पर कायम हूँ।

/^(?=.*OU=Karen)(?=.*OU=admin).*$/ 

^  - line start 
(?=  - start zero-width positive lookahead 
.*  - anything or nothing 
OU=Karen - literal 
)  - end zero-width positive lookahead 
     - place as many positive or negative look-aheads as required 
.*  - the whole line 
$  - line end 

Answer 2

आप , या indexOf() सटीक स्ट्रिंग को देखने के लिए शर्तों की संख्या के रूप में कई बार कर सकते हैं। Regex के लिए कोई ज़रूरत नहीं है।

एक्स्टेंसिबल रेगेक्स (जैसा कि इसमें अधिक स्थितियों का समर्थन कर सकता है) आगे देखने के साथ संभव हो सकता है, लेकिन मुझे संदेह है कि यह बेहतर प्रदर्शन करेगा।

आप ही स्ट्रिंग पर कार्रवाई कई बार इस प्रकार की प्रदर्शन करने के लिए चाहते हैं, और वहाँ स्ट्रिंग पर कई टोकन हैं, तो आप स्ट्रिंग और कुछ डेटा संरचना में दुकान पार्स करने पर विचार कर सकते।

Answer 3

नहीं, जब तक आप vi उपयोग कर रहे हैं: यह एक \& ऑपरेटर

/(OU=Karen.*OU=admin|ou=admin.*OU=Karen)/ 

यह काफी पास हो सकता है, हालांकि, या इसी तरह की है।

Answer 4

आप एक regex का उपयोग करना चाहिए, तो आप

/OU=Karen.*?OU=admin|OU=admin.*?OU=Karen/ 

Answer 5

उपयोग कर सकते हैं आपको पता आप एक ही regex के साथ सब कुछ, या यहाँ तक एक regex करने के लिए नहीं है।

इनपुट अभिव्यक्तियों को पकड़ने के लिए नियमित अभिव्यक्ति बहुत अच्छी होती है, लेकिन यदि आपके पास दो पूरी तरह से निश्चित तार हैं, तो आप दोनों के लिए -प्रकार विधि और फिर and परिणामों का उपयोग कर सकते हैं।

वैकल्पिक रूप से, यदि आपको रेगेक्स का उपयोग करने की आवश्यकता है, तो आप दो बार (एक बार प्रति स्ट्रिंग) और and परिणाम एक साथ कर सकते हैं।

आप एक एकल regex के साथ यह सब करने की ज़रूरत है, तो आप की तरह कुछ की कोशिश कर सकते:

,OU=Karen,.*,OU=admin,|,OU=admin,.*,OU=Karen, 

लेकिन आप तब भी जब उन पद प्रारंभ या के अंत में प्रदर्शित के बारे में चिंता करना होगा रेखा, और अन्य किनारे के मामलों के सभी प्रकार (एक या दोनों शुरुआत या अंत में, दोनों एक दूसरे के बगल में, Karen7 या administrator-lesser जैसे नाम, और इसी तरह)।

शायद कुछ राक्षसी की तरह साथ खत्म हो जाएगा सभी संभावनाओं के लिए अनुमति देने के लिए हो रही है:

^OU=Karen(,[^,]*)*,OU=admin,| 
^OU=Karen(,[^,]*)*,OU=admin$| 
,OU=Karen(,[^,]*)*,OU=admin,| 
,OU=Karen(,[^,]*)*,OU=admin$| 
^OU=admin(,[^,]*)*,OU=Karen,| 
^OU=admin(,[^,]*)*,OU=Karen$| 
,OU=admin(,[^,]*)*,OU=Karen,| 
,OU=admin(,[^,]*)*,OU=Karen$ 

हालांकि, एक उन्नत enouge regex इंजन के साथ, इस छोटे कुछ को कम करने योग्य हो सकता है (हालांकि यह संभावना नहीं किया जाएगा सभी आगे दिखने वाले/बैक-ट्रैकिंग की वजह से, किसी भी तेज़ होने के लिए)।

एक तरीका यह है कि एक जटिल regex के बिना सुधार किया जा सकता अपने स्ट्रिंग की मालिश करने से पहले थोड़ा हाथ इतना है कि सीमा के चेक आवश्यकता नहीं है:

newString = "," + origString.replace (",", ",,") + "," 

इतना है कि यह शुरू होता है और एक अल्पविराम के साथ समाप्त होता और यह के भीतर सभी के लिए अल्पविराम दोहराया गया है:

,OU=Karen,,OU=Office,,OU=admin,,DC=corp,,DC=Fabrikam,,DC=COM, 

तो फिर तुम केवल जरूरत है बहुत सरल के लिए जाँच:

,OU=Karen,.*,OU=admin,|,OU=admin,.*,OU=Karen, 

और यह सब संभावित उल्लेख समस्याओं निकालता है:

• या तो स्ट्रिंग के शुरू में।
• या तो स्ट्रिंग के अंत में।
• दोनों एक दूसरे सटे।
• Karen2 जैसे विस्तारित नाम गलती से मेल खाते हैं। यह

  str = "OU=Karen,OU=Office,OU=admin,DC=corp,DC=Fabrikam,DC=COM" 
  elems[] = str.splitOn(",") 
  
  gotKaren = false 
  gotAdmin = false 
  for each elem in elems: 
      if elem = "OU=Karen": gotKaren = true 
      if elem = "OU=admin": gotAdmin = true 
  
  if gotKaren and gotAdmin: 
      weaveYourMagicHere() 
  

  दोनों पर ध्यान नहीं देता:

---

शायद सबसे अच्छा तरीका यह है (अपनी भाषा की अनुमति देता है) बस के लिए अल्पविराम पर स्ट्रिंग विभाजित है और उन्हें जांच करने के लिए, कुछ की तरह है ऑर्डर जिसमें वे प्रकट हो सकते हैं और किनारे के मामलों का पता लगाने के लिए किसी भी रेगेक्स "जिमनास्टिक" को छोड़ सकते हैं।

यह भी शायद बराबर regex :-)

Answer 6

आप (OU \ = करेन की तरह कुछ का उपयोग कर सकते की तुलना में अधिक पठनीय होने का लाभ दिया है