Wie Sie die Gruppe suchen, reguläre Ausdrücke mit swift

In regulären Ausdrücken können Sie die Gruppe verschiedene Spiele zu leicht "pattern match" ein Spiel.

while match != nil {
  match = source.rangeOfString(regex, options: .RegularExpressionSearch)
  if let m = match {
    result.append(source.substringWithRange(m)
      source.replaceRange(m, with: "") 
  }
}

Den oben genannten Werken zu finden zu finden, eine Reihe von dem Spiel, aber kann es nicht sagen, mich der Gruppe. Zum Beispiel, wenn ich nach Worten suchen, eingekapselt in "" ich möchte das Spiel "Wort", das aber schnell Holen nur das Wort

Ist es möglich, dies zu tun in swift?

InformationsquelleAutor chrs | 2014-11-21
  1. 33

    Swift ist ziemlich hässlich, jetzt mit regulären Ausdrücken-wir hoffen auf mehr-native Unterstützung bald! Die Methode, die auf NSRegularExpression Sie wollen, ist matchesInString. Hier ist, wie es zu benutzen:

    let string = "This is my \"string\" of \"words\"."
let re = NSRegularExpression(pattern: "\"(.+?)\"", options: nil, error: nil)!
let matches = re.matchesInString(string, options: nil, range: NSRange(location: 0, length: string.utf16Count))

println("number of matches: \(matches.count)")

for match in matches as [NSTextCheckingResult] {
    //range at index 0: full match
    //range at index 1: first capture group
    let substring = (string as NSString).substringWithRange(match.rangeAtIndex(1))
    println(substring)
}

    Ausgabe:

    number of matches: 2
string
words
    • danke. Dies jetzt zu tun. Ich hatte gehofft, für eine native Lösung, aber naja swift ist und sein wird "- Erweiterung basiert", so dass ich nicht denke, es wird in Naher Zukunft umgesetzt, mit Ausnahme der 3. Teil Entwickler
    InformationsquelleAutor Nate Cook
  2. 7

    Diese können Sie verwenden, wenn Sie sammeln möchten, die übereinstimmenden Zeichenfolgen.
    (Meine Antwort ist abgeleitet von Nate Kocht sehr hilfreiche Antwort.)

    Aktualisiert für Swift 2.1

    extension String {
    func regexMatches(pattern: String) -> Array<String> {
        let re: NSRegularExpression
        do {
            re = try NSRegularExpression(pattern: pattern, options: [])
        } catch {
            return []
        }

        let matches = re.matchesInString(self, options: [], range: NSRange(location: 0, length: self.utf16.count))
        var collectMatches: Array<String> = []
        for match in matches {
            //range at index 0: full match
            //range at index 1: first capture group
            let substring = (self as NSString).substringWithRange(match.rangeAtIndex(1))
            collectMatches.append(substring)
        }
        return collectMatches
    }
}

    Aktualisiert für Swift 3.0 

    extension String {
func regexMatches(pattern: String) -> Array<String> {
    let re: NSRegularExpression
    do {
        re = try NSRegularExpression(pattern: pattern, options: [])
    } catch {
        return []
    }

    let matches = re.matches(in: self, options: [], range: NSRange(location: 0, length: self.utf16.count))
    var collectMatches: Array<String> = []
    for match in matches {
        //range at index 0: full match
        //range at index 1: first capture group
        let substring = (self as NSString).substring(with: match.rangeAt(1))
        collectMatches.append(substring)
    }
    return collectMatches
}}
    • Das ist großartig, ich danke Ihnen sehr. Es ist buggy, mit dem folgenden aber: "This is my \"string\" of \"words\".".regexMatches("(my )|(of )\"(.+?)\""). Die zwei Bereiche, die es findet, sind: ["(8,3)", "(9223372036854775807,0)"]
    InformationsquelleAutor zekel
  3. 4

    wie über diese Leute, fügen Sie als Erweiterung zu String? )) alle Spiele, alle Gruppen ) selbst = String, wenn Sie hinzufügen wollen, nicht als Erweiterung fügen Sie die String-parameter, und ersetzen Sie alle selbst auf Ihre parameter 🙂

     func matchesForRegexInTextAll(regex: String!) -> [[String]] {

    do {
        let regex = try NSRegularExpression(pattern: regex, options: [])
        let nsString = self as NSString

        var resultsFinal = [[String]]()

        let results = regex.matchesInString(self,
            options: [], range: NSMakeRange(0, nsString.length))

        for result in results {
            var internalString = [String]()
            for var i = 0; i < result.numberOfRanges; ++i{
                internalString.append(nsString.substringWithRange(result.rangeAtIndex(i)))
            }
            resultsFinal.append(internalString)
        }

        return resultsFinal
    } catch let error as NSError {
        print("invalid regex: \(error.localizedDescription)")
        return []
    }
}
    InformationsquelleAutor Stepan Maksymov
  4. 3

    Alle Antworten sind gut, aber dennoch werde ich zu bieten meine String extension geschrieben in Swift 2.2.

    Bemerkt Unterschiede:

    • verwenden Sie nur die erste übereinstimmung
    • unterstützt mehrere Gruppen erfasst
    • ein genauer name der Funktion (es ist die capture-Gruppen, nicht entspricht)

    .

    extension String {
    func capturedGroups(withRegex pattern: String) -> [String]? {
        var regex: NSRegularExpression
        do {
            regex = try NSRegularExpression(pattern: pattern, options: [])
        } catch {
            return nil
        }

        let matches = regex.matchesInString(self, options: [], range: NSRange(location:0, length: self.characters.count))

        guard let match = matches.first else { return nil }

        //Note: Index 1 is 1st capture group, 2 is 2nd, ..., while index 0 is full match which we don't use
        let lastRangeIndex = match.numberOfRanges - 1
        guard lastRangeIndex >= 1 else { return nil }

        var results = [String]()

        for i in 1...lastRangeIndex {
            let capturedGroupIndex = match.rangeAtIndex(i)
            let matchedString = (self as NSString).substringWithRange(capturedGroupIndex)
            results.append(matchedString)
        }

        return results
    }
}

    Verwenden:

    //Will match "bcde"
"abcdefg".capturedGroups(withRegex: "a(.*)f")
    • Ich von Ihnen positiv bewertet werden, aber schließlich ist dieser code nicht zuverlässig. Mit dem Muster "([NSEW]|\\-?)\\s*([0-9]{1,3}(\\.[0-9]+)?)(,\\s*|\\s+)([NSEW]|\\-?)\\s*([0-9]{1,3}(\\.[0-9]+)?)" und der string "1 2" es stürzt ab (capturedGroupIndex.Position ist zu hoch für das Letzte Spiel).
    • Hinzufügen eines check zu capturedGroupIndex.Lage != NSNotFound und die Rückgabe ein leerer string das problem behoben. Bitte aktualisieren Sie Ihre Antwort für die anderen.
    InformationsquelleAutor samwize
  5. 1

    Aktualisiert Swift 4

    /**
 String extension that extract the captured groups with a regex pattern

 - parameter pattern: regex pattern
 - Returns: captured groups
 */
public func capturedGroups(withRegex pattern: String) -> [String] {
    var results = [String]()

    var regex: NSRegularExpression
    do {
        regex = try NSRegularExpression(pattern: pattern, options: [])
    } catch {
        return results
    }
    let matches = regex.matches(in: self, options: [], range: NSRange(location:0, length: self.count))

    guard let match = matches.first else { return results }

    let lastRangeIndex = match.numberOfRanges - 1
    guard lastRangeIndex >= 1 else { return results }

    for i in 1...lastRangeIndex {
        let capturedGroupIndex = match.range(at: i)
        let matchedString = (self as NSString).substring(with: capturedGroupIndex)
        results.append(matchedString)
    }

    return results
}

    Verwenden:

    //Will match "bcde"
"abcdefg".capturedGroups(withRegex: "a(.*)f")

    Gist auf github: https://gist.github.com/unshapedesign/1b95f78d7f74241f706f346aed5384ff

    InformationsquelleAutor Heiko
Schreibe einen Kommentar