2012-02-01 16 views
5

की मैं एक आरजीबी स्ट्रिंग है लगता है चलो (प्रारूप: # < 2 हेक्स अंक> < 2 हेक्स अंक> < 2 हेक्स अंक>) इस तरह:Emacs Lisp: कॉम्पैक्ट तरीके से दोहराए गए पैटर्न से मेल खाते हैं?

"#00BBCC" 

और मैं मेल खाते हैं और उसके < पर कब्जा करना चाहते हैं 2 हेक्स अंक> एक अधिक कॉम्पैक्ट ढंग से तत्वों से स्पष्ट का उपयोग करके:

"#\\([[:xdigit:]\\{2\\}]\\)\\([[:xdigit:]\\{2\\}]\\)\\([[:xdigit:]\\{2\\}]\\)" 

मैं कोशिश की है:

"#\\([[:xdigit:]]\\{2\\}\\)\\{3\\}" 

और:

"#\\(\\([[:xdigit:]]\\{2\\}\\)\\{3\\}\\)" 

लेकिन सबसे वे मेल नहीं खाते पहले < 2 हेक्स अंक> तत्व है।

कोई विचार? धन्यवाद।

+0

आप ऐसा क्यों करना चाहते हैं? पठनीयता के लिए? – Thomas

+0

बस जिज्ञासा: मुझे आश्चर्य है कि regexps दोहराए गए पैटर्न से मेल खा सकता है या नहीं। – Elena

+1

समस्या यह है कि आप तब 3 अलग-अलग समूहों को संदर्भित नहीं कर पाएंगे, है ना? तो आप आर, जी, बी मूल्यों को अलग से कैसे निकालेंगे? – Thomas

उत्तर

1

आप आर, जी, बी कब्जा करने के लिए विभिन्न उपसमूहों में, ताकि आप उन्हें (match-string group) का उपयोग कर निकाल सकते हैं चाहते हैं, आप की जरूरत है किसी बिंदु पर आपके regexp में तीन अलग-अलग कोष्ठक समूह होने के लिए।

\(...\)\(...\)\(...\) 

अन्यथा, यदि आप के रूप में

\(...\)\{3\} 

पुनरावृत्ति पैटर्न इस तरह का उपयोग आप केवल एक समूह है, और मैच के बाद यह केवल अंतिम मैच का मूल्य शामिल होंगे। तो, कहते हैं, आप

\([[:xdigit:]]\{2\}\)\{3\} 

की तर्ज पर कुछ ऐसा "A0B1C2" एक स्ट्रिंग से मेल खाएगा, लेकिन (match-string 1) केवल आखिरी मैच में यानी "सी 2" की सामग्री को शामिल होंगे है, क्योंकि regexp परिभाषित करता है केवल एक समूह

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

आप ज्यादातर कोड पठनीयता बारे में चिंतित हैं, तो आप हमेशा tripleee के सुझाव के अनुसार, एक हद तक कम अनावश्यक तरह से इस तरह के एक अधिक जटिल regexp के निर्माण के लिए

(let ((hex2 "\\([[:xdigit:]]\\{2\\}\\)")) 
    (concat "#" hex2 hex2 hex2)) 

की तरह कुछ कर सकता है।

4

आप कुछ अतिरिक्त कोड की कीमत पर regexp कम कर सकते हैं:

(defun match-hex-digits (str) 
    (when (string-match "#[[:xdigit:]]\\{6\\}" str) 
    (list (substring (match-string 0 str) 1 3) 
      (substring (match-string 0 str) 3 5) 
      (substring (match-string 0 str) 5 7)))) 
+1

अच्छा वैकल्पिक विचार, मैं इसे ऊपर उठा रहा हूं। अतिरिक्त कोड को एक फ़ंक्शन में दोबारा क्रियान्वित किया जा सकता है। – Elena

+4

फिर क्यों नहीं (चलो (xx "\\ ([[: xdigit:]] \\ {2 \\} \\)") (स्ट्रिंग-मिलान (concat "#" xx xx xx) str)) '' ? – tripleee

+0

@ ट्रिपली यही वह है जो मैं अपने कोड में उपयोग कर रहा हूं। दरअसल, अब जब मैं इसके बारे में सोचता हूं, इसे शॉन द्वारा सुझाए गए समाधान की तुलना में अधिक सामान्य कार्य में पुन: सक्रिय किया जा सकता है, क्योंकि तब पैटर्न विभिन्न लंबाई के तारों से मेल खाते हैं। – Elena

संबंधित मुद्दे