खोज…
जब अभिव्यक्ति में Regex मिलान के लिए मुहावरे
अपरिवर्तनीय स्थानीय लोगों का उपयोग करना:
"अनाम अस्थायी" टेम्पलेट की तुलना में कम क्षैतिज स्थान लेकिन अधिक ऊर्ध्वाधर स्थान का उपयोग करता है। when "लूप में अभिव्यक्ति" हो तो "अनाम अस्थायी" टेम्पलेट पर अधिमानतः - उस स्थिति में, रेगेक्स परिभाषाओं को लूप के बाहर रखा जाना चाहिए।
import kotlin.text.regex
var string = /* some string */
val regex1 = Regex( /* pattern */ )
val regex2 = Regex( /* pattern */ )
/* etc */
when {
regex1.matches(string) -> /* do stuff */
regex2.matches(string) -> /* do stuff */
/* etc */
}
अनाम अस्थायी का उपयोग करना:
"अपरिवर्तनीय स्थानीय लोगों" टेम्पलेट की तुलना में कम ऊर्ध्वाधर स्थान लेकिन अधिक क्षैतिज स्थान का उपयोग करता है। तब उपयोग नहीं किया जाना चाहिए यदि तब when अभिव्यक्ति एक लूप में हो।
import kotlin.text.regex
var string = /* some string */
when {
Regex( /* pattern */ ).matches(string) -> /* do stuff */
Regex( /* pattern */ ).matches(string) -> /* do stuff */
/* etc */
}
विज़िटर पैटर्न का उपयोग करना:
वाक्यविन्यास when "तर्क-पूर्ण" का बारीकी से अनुकरण करने का लाभ मिलता है। यह फायदेमंद है क्योंकि यह अधिक स्पष्ट रूप से when अभिव्यक्ति के तर्क को इंगित करता है, और कुछ प्रोग्रामर गलतियों को भी रोकता है, जो कि हर when whenEntry में तर्क को whenEntry । या तो "अपरिवर्तनीय स्थानीय लोगों" या "अनाम अस्थायी" टेम्पलेट का उपयोग विज़िटर पैटर्न को लागू करने के साथ किया जा सकता है।
import kotlin.text.regex
var string = /* some string */
when (RegexWhenArgument(string)) {
Regex( /* pattern */ ) -> /* do stuff */
Regex( /* pattern */ ) -> /* do stuff */
/* etc */
}
और when अभिव्यक्ति तर्क के लिए आवरण वर्ग की न्यूनतम परिभाषा:
class RegexWhenArgument (val whenArgument: CharSequence) {
operator fun equals(whenEntry: Regex) = whenEntry.matches(whenArgument)
override operator fun equals(whenEntry: Any?) = (whenArgument == whenEntry)
}
कोटलिन में नियमित अभिव्यक्ति का परिचय
यह पोस्ट बताता है कि Regex वर्ग में अधिकांश फ़ंक्शन का उपयोग कैसे किया जाता है, Regex फ़ंक्शन से संबंधित सुरक्षित रूप से नल के साथ काम करते हैं, और कच्चे तार कैसे रेगेक्स पैटर्न को लिखना और पढ़ना आसान बनाते हैं।
RegEx वर्ग
कोटलिन में नियमित अभिव्यक्तियों के साथ काम करने के लिए, आपको उस regex ऑब्जेक्ट पर Regex(pattern: String) वर्ग का उपयोग करने और find(..) या replace(..) जैसे फ़ंक्शन को लागू करने की आवश्यकता है।
यदि input स्ट्रिंग में c या d Regex , तो Regex वर्ग का उपयोग कैसे करें, इस पर एक उदाहरण:
val regex = Regex(pattern = "c|d")
val matched = regex.containsMatchIn(input = "abc") // matched: true
सभी Regex कार्यों के साथ समझने के लिए आवश्यक बात Regex है कि परिणाम रेगेक्स pattern और input स्ट्रिंग के मिलान पर आधारित है। कुछ कार्यों के लिए एक पूर्ण मैच की आवश्यकता होती है, जबकि बाकी के लिए केवल एक आंशिक मैच की आवश्यकता होती है। उदाहरण में उपयोग किए जाने वाले containsMatchIn(..) फ़ंक्शन को आंशिक मिलान की आवश्यकता है और बाद में इस पोस्ट में समझाया गया है।
नियमित अभिव्यक्ति के साथ अशक्त सुरक्षा
दोनों find(..) और matchEntire(..) एक matchEntire(..) लौटेगा MatchResult? वस्तु। ? के बाद चरित्र MatchResult Kotlin संभाल करने के लिए आवश्यक है सुरक्षित रूप से अशक्त ।
एक उदाहरण जो दर्शाता है कि कोटलिन एक Regex फ़ंक्शन से सुरक्षित रूप से नल को कैसे संभालता है, जब find(..) फ़ंक्शन शून्य देता है:
val matchResult =
Regex("c|d").find("efg") // matchResult: null
val a = matchResult?.value // a: null
val b = matchResult?.value.orEmpty() // b: ""
a?.toUpperCase() // Still needs question mark. => null
b.toUpperCase() // Accesses the function directly. => ""
orEmpty() फ़ंक्शन के साथ, b अशक्त और नहीं हो सकता ? जब आप कार्य को b पर कहते हैं तो चरित्र अनावश्यक है।
यदि आप शून्य मानों के इस सुरक्षित संचालन की परवाह नहीं करते हैं, तो कोटलिन आपको जावा जैसे शून्य मानों के साथ काम करने की अनुमति देता है !! पात्र:
a!!.toUpperCase() // => KotlinNullPointerException
रेगेक्स पैटर्न में कच्चे तार
कोटलिन जावा पर एक कच्ची स्ट्रिंग के साथ एक सुधार प्रदान करता है जो डबल बैकस्लैश के बिना शुद्ध रेगेक्स पैटर्न लिखना संभव बनाता है, जो कि जावा स्ट्रिंग के साथ आवश्यक हैं। एक कच्ची स्ट्रिंग को एक ट्रिपल उद्धरण के साथ दर्शाया गया है:
"""\d{3}-\d{3}-\d{4}""" // raw Kotlin string
"\\d{3}-\\d{3}-\\d{4}" // standard Java string
खोजें (इनपुट: चारसुविधा, startIndex: Int): MatchResult?
Regex ऑब्जेक्ट में pattern खिलाफ input स्ट्रिंग का मिलान किया जाएगा। यह एक Matchresult? लौटाता है Matchresult? के बाद सबसे पहले मिलने वाला पाठ के साथ वस्तु startIndex , या null अगर पैटर्न से मेल नहीं खाती input स्ट्रिंग। परिणाम स्ट्रिंग को MatchResult? से पुनर्प्राप्त किया जाता है MatchResult? वस्तु का value संपत्ति। डिफ़ॉल्ट मान 0 के साथ startIndex पैरामीटर वैकल्पिक है।
संपर्क विवरण के साथ एक स्ट्रिंग से पहला वैध फोन नंबर निकालने के लिए:
val phoneNumber :String? = Regex(pattern = """\d{3}-\d{3}-\d{4}""")
.find(input = "phone: 123-456-7890, e..")?.value // phoneNumber: 123-456-7890
input स्ट्रिंग में कोई मान्य फ़ोन नंबर नहीं होने से, चर phoneNumber null हो जाएगा।
findAll (इनपुट: चारसेंसेंस, स्टार्टइंडेक्स: इंट): सीक्वेंस
input स्ट्रिंग से सभी मैच लौटाता है जो रेगेक्स pattern मेल खाता है।
अक्षरों और अंकों के साथ एक पाठ से, अंतरिक्ष के साथ अलग किए गए सभी नंबरों को प्रिंट करने के लिए:
val matchedResults = Regex(pattern = """\d+""").findAll(input = "ab12cd34ef")
val result = StringBuilder()
for (matchedText in matchedResults) {
result.append(matchedText.value + " ")
}
println(result) // => 12 34
matchedResults चर के साथ एक दृश्य है MatchResult वस्तुओं। अंकों के बिना एक input स्ट्रिंग के साथ, findAll(..) फ़ंक्शन एक खाली अनुक्रम लौटाएगा।
माचिसइंटरायर (इनपुट: चारसामेंस): माचिस
यदि input स्ट्रिंग के सभी अक्षर रेगेक्स pattern मेल खाते हैं, तो input बराबर स्ट्रिंग वापस आ जाएगी। वरना, null लौटा दिया जाएगा।
इनपुट स्ट्रिंग लौटाता है अगर पूरा इनपुट स्ट्रिंग एक संख्या है:
val a = Regex("""\d+""").matchEntire("100")?.value // a: 100
val b = Regex("""\d+""").matchEntire("100 dollars")?.value // b: null
माचिस (इनपुट: चारसेंसेंस): बूलियन
यदि पूरा इनपुट स्ट्रिंग रेगेक्स पैटर्न से मेल खाता है, तो सही है। असत्य अन्यथा।
टेस्ट यदि दो स्ट्रिंग्स में केवल अंक होते हैं:
val regex = Regex(pattern = """\d+""")
regex.matches(input = "50") // => true
regex.matches(input = "50 dollars") // => false
मेमैच इन (इनपुट: चारसेंसेंस): बूलियन
यदि इनपुट स्ट्रिंग का हिस्सा रेगेक्स पैटर्न से मेल खाता है, तो सही है। असत्य अन्यथा।
यदि दो तारों में कम से कम एक अंक होता है तो परीक्षण करें:
Regex("""\d+""").containsMatchIn("50 dollars") // => true
Regex("""\d+""").containsMatchIn("Fifty dollars") // => false
विभाजन (इनपुट: चारसुधार, सीमा: Int): सूची
सभी regex मैचों के बिना एक नई सूची देता है।
अंकों के बिना सूची वापस करने के लिए:
val a = Regex("""\d+""").split("ab12cd34ef") // a: [ab, cd, ef]
val b = Regex("""\d+""").split("This is a test") // b: [This is a test]
प्रत्येक विभाजन के लिए सूची में एक तत्व है। पहले input स्ट्रिंग में तीन नंबर होते हैं। तीन तत्वों के साथ एक सूची में यह परिणाम है।
बदलें (इनपुट: चारसुधार, प्रतिस्थापन: स्ट्रिंग): स्ट्रिंग
रिप्लेक्स pattern सभी मिलानों को input स्ट्रिंग में रिप्लेक्स स्ट्रिंग के साथ बदल देता है।
एक x के साथ एक स्ट्रिंग में सभी अंकों को बदलने के लिए:
val result = Regex("""\d+""").replace("ab12cd34ef", "x") // result: abxcdxef