Swift Language
स्विफ्ट में NSRegularExpression

टिप्पणियों

   *?+[(){}^$|\./

सरल पैटर्न मिलान करने के लिए स्ट्रिंग का विस्तार करना

extension String {
    func matchesPattern(pattern: String) -> Bool {
        do {
            let regex = try NSRegularExpression(pattern: pattern,
                                                options: NSRegularExpressionOptions(rawValue: 0))
            let range: NSRange = NSMakeRange(0, self.characters.count)
            let matches = regex.matchesInString(self, options: NSMatchingOptions(), range: range)
            return matches.count > 0
        } catch _ {
            return false
        }
    }
}

// very basic examples - check for specific strings
dump("Pinkman".matchesPattern("(White|Pinkman|Goodman|Schrader|Fring)"))

// using character groups to check for similar-sounding impressionist painters
dump("Monet".matchesPattern("(M[oa]net)"))
dump("Manet".matchesPattern("(M[oa]net)"))
dump("Money".matchesPattern("(M[oa]net)"))     // false

// check surname is in list
dump("Skyler White".matchesPattern("\\w+ (White|Pinkman|Goodman|Schrader|Fring)"))

// check if string looks like a UK stock ticker
dump("VOD.L".matchesPattern("[A-Z]{2,3}\\.L"))
dump("BP.L".matchesPattern("[A-Z]{2,3}\\.L"))

// check entire string is printable ASCII characters
dump("tab\tformatted text".matchesPattern("^[\u{0020}-\u{007e}]*$"))

// Unicode example: check if string contains a playing card suit
dump("♠︎".matchesPattern("[\u{2660}-\u{2667}]"))
dump("♡".matchesPattern("[\u{2660}-\u{2667}]"))
dump("😂".matchesPattern("[\u{2660}-\u{2667}]"))    // false

// NOTE: regex needs Unicode-escaped characters
dump("♣︎".matchesPattern("♣︎"))           // does NOT work

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

// Pattern validation for a UK postcode.
// This simply checks that the format looks like a valid UK postcode and should not fail on false positives.
private func isPostcodeValid(postcode: String) -> Bool {
    return postcode.matchesPattern("^[A-Z]{1,2}([0-9][A-Z]|[0-9]{1,2})\\s[0-9][A-Z]{2}")
}

// valid patterns (from https://en.wikipedia.org/wiki/Postcodes_in_the_United_Kingdom#Validation)
// will return true
dump(isPostcodeValid("EC1A 1BB"))
dump(isPostcodeValid("W1A 0AX"))
dump(isPostcodeValid("M1 1AE"))
dump(isPostcodeValid("B33 8TH"))
dump(isPostcodeValid("CR2 6XH"))
dump(isPostcodeValid("DN55 1PT"))

// some invalid patterns
// will return false
dump(isPostcodeValid("EC12A 1BB"))
dump(isPostcodeValid("CRB1 6XH"))
dump(isPostcodeValid("CR 6XH"))

मूल उपयोग

स्विफ्ट में रेगुलर एक्सप्रेशन लागू करते समय कई विचार हैं।

let letters = "abcdefg"
let pattern = "[a,b,c]"
let regEx = try NSRegularExpression(pattern: pattern, options: [])
let nsString = letters as NSString
let matches = regEx.matches(in: letters, options: [], range: NSMakeRange(0, nsString.length))
let output = matches.map {nsString.substring(with: $0.range)}
//output = ["a", "b", "c"]

एक सटीक श्रेणी लंबाई प्राप्त करने के लिए जो सभी प्रकार के प्रकारों का समर्थन करता है इनपुट स्ट्रिंग को NSString में बदलना चाहिए।

सुरक्षा के लिए एक पैटर्न के खिलाफ मिलान विफलता को संभालने के लिए एक कैच ब्लॉक में संलग्न होना चाहिए

let numbers = "121314"
let pattern = "1[2,3]"
do {
    let regEx = try NSRegularExpression(pattern: pattern, options: [])
    let nsString = numbers as NSString
    let matches = regEx.matches(in: numbers, options: [], range: NSMakeRange(0, nsString.length))
    let output = matches.map {nsString.substring(with: $0.range)}
    output
} catch let error as NSError {
    print("Matching failed")
}
//output = ["12", "13"]

नियमित अभिव्यक्ति की कार्यक्षमता अक्सर चिंताओं को अलग करने के लिए एक विस्तार या सहायक में डाल दी जाती है।

सबस्ट्रिंग की जगह

पैटर्न का उपयोग इनपुट स्ट्रिंग के भाग को बदलने के लिए किया जा सकता है।

नीचे दिए गए उदाहरण डॉलर प्रतीक के साथ प्रतिशत प्रतीक को प्रतिस्थापित करता है।

var money = "¢¥€£$¥€£¢"
let pattern = "¢"
do {
    let regEx = try NSRegularExpression (pattern: pattern, options: [])
    let nsString = money as NSString
    let range = NSMakeRange(0, nsString.length)
    let correct$ = regEx.stringByReplacingMatches(in: money, options: .withTransparentBounds, range: range, withTemplate: "$")
} catch let error as NSError {
    print("Matching failed")
}
//correct$ = "$¥€£$¥€£$"

विशेष वर्ण

विशेष वर्णों का मिलान करने के लिए डबल बैकलैश का उपयोग किया जाना चाहिए \. becomes \\.

जिन वर्णों से आपको बचना होगा उनमें शामिल हैं

(){}[]/\+*$>.|^?

नीचे दिए गए उदाहरण को तीन प्रकार के शुरुआती कोष्ठक मिलते हैं

let specials = "(){}[]"
let pattern = "(\\(|\\{|\\[)"
do {
    let regEx = try NSRegularExpression(pattern: pattern, options: [])
    let nsString = specials as NSString
    let matches = regEx.matches(in: specials, options: [], range: NSMakeRange(0, nsString.length))
    let output = matches.map {nsString.substring(with: $0.range)}
} catch let error as NSError {
    print("Matching failed")
}
//output = ["(", "{", "["]

मान्यकरण

मिलानों की संख्या की गणना करके इनपुट को मान्य करने के लिए नियमित अभिव्यक्तियों का उपयोग किया जा सकता है।

var validDate = false

let numbers = "35/12/2016"
let usPattern =  "^(0[1-9]|1[012])[-/.](0[1-9]|[12][0-9]|3[01])[-/.](19|20)\\d\\d$"
let ukPattern = "^(0[1-9]|[12][0-9]|3[01])[-/](0[1-9]|1[012])[-/](19|20)\\d\\d$"
do {
    let regEx = try NSRegularExpression(pattern: ukPattern, options: [])
    let nsString = numbers as NSString
    let matches = regEx.matches(in: numbers, options: [], range: NSMakeRange(0, nsString.length))
    
    if matches.count > 0 {
        validDate = true
    }
    
    validDate
    
} catch let error as NSError {
    print("Matching failed")
}
//output = false

मेल सत्यापन के लिए NSRegularExpression

func isValidEmail(email: String) -> Bool {

    let emailRegEx = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,4}"
    
    let emailTest = NSPredicate(format:"SELF MATCHES %@", emailRegEx)
    return emailTest.evaluate(with: email)
}

या आप स्ट्रिंग एक्सटेंशन का उपयोग इस तरह कर सकते हैं:

extension String
{
    func isValidEmail() -> Bool {

        let emailRegEx = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,4}"
        
        let emailTest = NSPredicate(format:"SELF MATCHES %@", emailRegEx)
        return emailTest.evaluate(with: self)
    }
}