रेगेक्स का उपयोग करके उन्हें मिलान करने के बजाय स्ट्रिंग्स का उपयोग

Question

मैं जावा उपयोगिता लिख ​​रहा हूं जो मुझे प्रदर्शन परीक्षण के लिए डेटा लोड करने में मदद करता है। यह वास्तव में स्ट्रिंग्स के लिए रेगेक्स निर्दिष्ट करने में सक्षम होने के लिए अच्छा होगा ताकि मेरा जनरेटर इस बात से मेल खा सके। क्या वहां कुछ ऐसा है जो पहले से ही बेक्ड है जिसे मैं ऐसा करने के लिए उपयोग कर सकता हूं? या क्या एक पुस्तकालय है जो मुझे वहां से सबसे अधिक रास्ता देता है?

धन्यवाद

Answer 1

संपादित करें:

टिप्पणी में उल्लेख किया है, वहाँ इस हासिल करने के लिए गूगल कोड पर एक पुस्तकालय उपलब्ध है: http://code.google.com/p/xeger

भी देखें https://github.com/mifmif/Generex रूप Mifmif

मूल संदेश ने सुझाव दिया :

सबसे पहले, बुद्धि एच एक जटिल पर्याप्त regexp, मुझे विश्वास है कि यह असंभव हो सकता है। लेकिन आप सरल regexps के लिए कुछ एक साथ रखने में सक्षम होना चाहिए।

यदि आप क्लास java.util.regex.Pterntern के स्रोत कोड को देखते हैं, तो आप देखेंगे कि यह नोड उदाहरणों का आंतरिक प्रतिनिधित्व करता है। प्रत्येक अलग-अलग पैटर्न घटकों में नोड सबक्लास का अपना कार्यान्वयन होता है। इन नोड्स को एक पेड़ में व्यवस्थित किया जाता है।

इस पेड़ को पार करने वाले विज़िटर का उत्पादन करके, आप एक ओवरलोडेड जेनरेटर विधि या किसी प्रकार का बिल्डर कॉल करने में सक्षम होना चाहिए जो कुछ एक साथ जोड़ता है।

Answer 2

आप अपनी खुद की पार्सर लिखने के लिए स्ट्रिंग के लेखक की तरह होगा :: रैंडम (पर्ल) किया था। वास्तव में, वह उस मॉड्यूल में कहीं भी रेगेक्स का उपयोग नहीं करता है, यह सिर्फ पर्ल-कोडर का उपयोग किया जाता है।

दूसरी तरफ, हो सकता है कि आप कुछ पॉइंटर्स प्राप्त करने के लिए the source पर एक नज़र डाल सकें।

---

संपादित करें: अरे, ब्लेयर मुझे पंच के लिए 15 सेकंड से हराया।

Answer 3

विजुअल स्टूडियो टीम सिस्टम में ऐसा कुछ शामिल है। Check it out

जावा के लिए बहुत मदद नहीं, हालांकि क्षमा करें।

Answer 4

stackoverflow पॉडकास्ट 11 पर:

Spolsky: हां। एक नया उत्पाद भी है, यदि आप टीम सिस्टम का उपयोग नहीं करना चाहते हैं तो रेडगेट में हमारे दोस्तों के पास SQL ​​डेटा जनरेटर [http://www.red-gate.com/products/sql_data_generator/index.htm] नामक एक उत्पाद है। यह $ 2 9 5 है, और यह सिर्फ कुछ यथार्थवादी परीक्षण डेटा उत्पन्न करता है। और यह वास्तव में शहर के कॉलम में वास्तविक शहरों को उत्पन्न करता है जो वास्तव में मौजूद हैं, और फिर जब यह उत्पन्न होता है तो यह राज्य को सही करने के बजाय, राज्यों को जर्मन शहरों और सामानों जैसे राज्यों को सही तरीके से प्राप्त करेगा ... आप जानते हैं, यह बहुत यथार्थवादी दिखने वाला डेटा उत्पन्न करता है। मुझे सच में यकीन नहीं है कि सभी सुविधाएं क्या हैं।

शायद यह नहीं है कि आप क्या खोज रहे हैं, लेकिन यह आपके स्वयं के निर्माण के बजाय एक अच्छा प्रारंभिक बिंदु हो सकता है।

मुझे Google में कुछ भी नहीं मिल रहा है, इसलिए मैं काम की छोटी इकाइयों (\ w, [xx], \ d, आदि) में दी गई नियमित अभिव्यक्ति को पार्स करके समस्या का सामना करने का सुझाव दूंगा और कुछ लिख रहा हूं उन नियमित अभिव्यक्ति वाक्यांशों का समर्थन करने के लिए बुनियादी विधियां।

तो \ w के लिए आपके पास एक विधि होगी RandomLetter() जो किसी भी यादृच्छिक पत्र को वापस लाती है, और आपको RandomLetter (char startLetter, char endLetter) भी मिल जाएगा जो आपको दो मानों के बीच एक यादृच्छिक अक्षर देता है।

Answer 5

मैं वहाँ पहले से ही एक स्वीकृत जवाब पता है, लेकिन मैं Redgate की डेटा जेनरेटर (क्रेग की जवाब में वर्णित) का उपयोग किया गया है और यह सब कुछ मैं इसे पर फेंके गए हैं के लिए वास्तव में अच्छी तरह से काम करता है। यह तेज़ है और यह मुझे एक ही रेगेक्स का उपयोग करने के लिए छोड़ देता है ताकि पंजीकरण कोड जैसे चीजों के लिए वास्तविक डेटा उत्पन्न हो सके।

ऐसा लगता है कि एक regex लेता है:

[A-Z0-9]{3,3}-[A-Z0-9]{3,3} 

और ऐसा लगता है अद्वितीय कोड की टन उत्पन्न करता है:

LLK-32U 

यह कुछ बड़े रहस्य एल्गोरिथ्म कि Redgate पता लगा है और हम सभी से बाहर हो भाग्य या यह ऐसा कुछ है जो हम केवल प्राणियों को वास्तव में कर सकते हैं?

Answer 6

यह एक पूर्ण पीसीआरई रेगेक्सपी का समर्थन करने से बहुत दूर है, लेकिन मैंने रेजीएक्स की तरह स्ट्रिंग लेने के लिए निम्नलिखित रूबी विधि लिखी और उस पर एक भिन्नता उत्पन्न की। (के लिए भाषा के आधार पर कॅप्चा।)

# q = "(How (much|many)|What) is (the (value|result) of)? :num1 :op :num2?" 
# values = { :num1=>42, :op=>"plus", :num2=>17 } 
# 4.times{ puts q.variation(values) } 
# => What is 42 plus 17? 
# => How many is the result of 42 plus 17? 
# => What is the result of 42 plus 17? 
# => How much is the value of 42 plus 17? 
class String 
    def variation(values={}) 
    out = self.dup 
    while out.gsub!(/\(([^())?]+)\)(\?)?/){ 
     ($2 && (rand > 0.5)) ? '' : $1.split('|').random 
    }; end 
    out.gsub!(/:(#{values.keys.join('|')})\b/){ values[$1.intern] } 
    out.gsub!(/\s{2,}/, ' ') 
    out 
    end 
end 

class Array 
    def random 
    self[ rand(self.length) ] 
    end 
end

Answer 7

मुझे लगता है कि के लिए मेरे own पुस्तकालय रोलिंग की जड़ में चले गए हैं (ग # में लेकिन एक जावा डेवलपर के लिए समझने में आसान होना चाहिए)।

Rxrdg वास्तविक जीवन प्रोजेक्ट के लिए परीक्षण डेटा बनाने की समस्या के समाधान के रूप में शुरू हुआ। बुनियादी विचार यह है कि ऐसे पैटर्न के अनुरूप यादृच्छिक डेटा बनाने के लिए मौजूदा (नियमित अभिव्यक्ति) सत्यापन पैटर्न का लाभ उठाना है। इस तरह वैध यादृच्छिक डेटा बनाया गया है।

सरल रेगेक्स पैटर्न के लिए एक पार्सर लिखना मुश्किल नहीं है। तार उत्पन्न करने के लिए एक सार वाक्यविन्यास पेड़ का उपयोग करना और भी आसान होना चाहिए।

Answer 8

Xeger (Java) के रूप में अच्छे ढंग से करने में सक्षम है:

String regex = "[ab]{4,6}c"; 
Xeger generator = new Xeger(regex); 
String result = generator.generate(); 
assert result.matches(regex); 

Answer 9

मैं उड़ान पर हूँ और सिर्फ सवाल देखा: मैं सबसे आसान लेकिन अक्षम और अधूरा समाधान लिखा है। मुझे आशा है कि यह अपनी खुद की पार्सर लेखन शुरू करने में मदद कर सकते हैं:

public static void main(String[] args) { 

    String line = "[A-Z0-9]{16}"; 
    String[] tokens = line.split(line); 
    char[] pattern = new char[100]; 
    int i = 0; 
    int len = tokens.length; 
    String sep1 = "[{"; 
    StringTokenizer st = new StringTokenizer(line, sep1); 

    while (st.hasMoreTokens()) { 
     String token = st.nextToken(); 
     System.out.println(token); 

     if (token.contains("]")) { 
      char[] endStr = null; 

      if (!token.endsWith("]")) { 
       String[] subTokens = token.split("]"); 
       token = subTokens[0]; 

       if (!subTokens[1].equalsIgnoreCase("*")) { 
        endStr = subTokens[1].toCharArray(); 
       } 
      } 

      if (token.startsWith("^")) { 
       String subStr = token.substring(1, token.length() - 1); 
       char[] subChar = subStr.toCharArray(); 
       Set set = new HashSet<Character>(); 

       for (int p = 0; p < subChar.length; p++) { 
        set.add(subChar[p]); 
       } 

       int asci = 1; 

       while (true) { 
        char newChar = (char) (subChar[0] + (asci++)); 

        if (!set.contains(newChar)) { 
         pattern[i++] = newChar; 
         break; 
        } 
       } 
       if (endStr != null) { 
        for (int r = 0; r < endStr.length; r++) { 
         pattern[i++] = endStr[r]; 
        } 
       } 

      } else { 
       pattern[i++] = token.charAt(0); 
      } 
     } else if (token.contains("}")) { 
      char[] endStr = null; 

      if (!token.endsWith("}")) { 
       String[] subTokens = token.split("}"); 
       token = subTokens[0]; 

       if (!subTokens[1].equalsIgnoreCase("*")) { 
        endStr = subTokens[1].toCharArray(); 
       } 
      } 

      int length = Integer.parseInt((new StringTokenizer(token, (",}"))).nextToken()); 
      char element = pattern[i - 1]; 

      for (int j = 0; j < length - 1; j++) { 
       pattern[i++] = element; 
      } 

      if (endStr != null) { 
       for (int r = 0; r < endStr.length; r++) { 
        pattern[i++] = endStr[r]; 
       } 
      } 
     } else { 
      char[] temp = token.toCharArray(); 

      for (int q = 0; q < temp.length; q++) { 
       pattern[i++] = temp[q]; 
      } 
     } 
    } 

    String result = ""; 

    for (int j = 0; j < i; j++) { 
     result += pattern[j]; 
    } 

    System.out.print(result); 
} 

Answer 10

यह मूल पोस्टर मदद करने के लिए बहुत देर हो चुकी है, लेकिन यह एक नवागंतुक मदद कर सकता है। Generex एक उपयोगी जावा लाइब्रेरी है जो स्ट्रिंग्स उत्पन्न करने के लिए रेगेक्स का उपयोग करने के लिए कई सुविधाएं प्रदान करती है (यादृच्छिक पीढ़ी, इसकी अनुक्रमणिका के आधार पर एक स्ट्रिंग उत्पन्न करना, सभी तारों को उत्पन्न करना ...)।

उदाहरण:

Generex generex = new Generex("[0-3]([a-c]|[e-g]{1,2})"); 

// generate the second String in lexicographical order that matches the given Regex. 
String secondString = generex.getMatchedString(2); 
System.out.println(secondString);// it print '0b' 

// Generate all String that matches the given Regex. 
List<String> matchedStrs = generex.getAllMatchedStrings(); 

// Using Generex iterator 
Iterator iterator = generex.iterator(); 
while (iterator.hasNext()) { 
    System.out.print(iterator.next() + " "); 
} 
// it prints 0a 0b 0c 0e 0ee 0e 0e 0f 0fe 0f 0f 0g 0ge 0g 0g 1a 1b 1c 1e 
// 1ee 1e 1e 1f 1fe 1f 1f 1g 1ge 1g 1g 2a 2b 2c 2e 2ee 2e 2e 2f 2fe 2f 2f 2g 
// 2ge 2g 2g 3a 3b 3c 3e 3ee 3e 3e 3f 3fe 3f 3f 3g 3ge 3g 3g 1ee 

// Generate random String 
String randomStr = generex.random(); 
System.out.println(randomStr);// a random value from the previous String list 

Answer 11

आप "निर्णायक" तार उत्पन्न करना चाहते हैं, तो आप विचार कर सकते हैं:

सफ़ेद बगुला http://elarson.pythonanywhere.com/ कि उत्पन्न करता है "" बुराई तार अपने रेगुलर एक्सप्रेशन को कवर

MUTREX http://cs.unibg.it/mutrex/ जो रेगेक्स उत्परिवर्तन

द्वारा गलती-पहचान तारों को उत्पन्न करता है 210

दोनों अकादमिक उपकरण हैं (मैं उत्तरार्द्ध के लेखकों में से एक हूं) और उचित रूप से अच्छी तरह से काम करता हूं।

Answer 12

यह प्रश्न बहुत पुराना है, लेकिन मैंने अपनी खोज पर इसे भर दिया, इसलिए मैं उन लोगों के लिए कुछ लिंक शामिल करूंगा जो अन्य भाषाओं में समान कार्यक्षमता की खोज कर रहे हैं।

• यहाँ एक Node.js पुस्तकालय है: https://packagist.org/packages/fzaninotto/faker