Swift выдерживает регулярные выражения

Question

Swift выдерживает регулярные выражения

Я хочу извлечь подстроки из строки, которые соответствуют шаблону регулярных выражений.

Поэтому я ищу что-то вроде этого:

func matchesForRegexInText(regex: String!, text: String!) -> [String] {
   ???
}

Итак, вот что у меня есть:

func matchesForRegexInText(regex: String!, text: String!) -> [String] {

    var regex = NSRegularExpression(pattern: regex, 
        options: nil, error: nil)

    var results = regex.matchesInString(text, 
        options: nil, range: NSMakeRange(0, countElements(text))) 
            as Array<NSTextCheckingResult>

    /// ???

    return ...
}

Проблема в том, что matchesInString доставляет мне массив NSTextCheckingResult, где NSTextCheckingResult.range имеет тип NSRange,

NSRange несовместимо с Range<String.Index>так что это мешает мне использовать text.substringWithRange(...)

Любая идея, как достичь этой простой вещи в Swift без слишком много строк кода?

232

ios swift regex string

Источник

user1867854 10 янв '15 в 20:04

16 ответов

Решение

Мой ответ основан на данных ответах, но делает сопоставление регулярных выражений более надежным, добавив дополнительную поддержку:

Возвращает не только совпадения, но и все группы захвата для каждого совпадения (см. Примеры ниже)
Вместо того, чтобы возвращать пустой массив, это решение поддерживает необязательные совпадения
Избегает do/catch не печатая на консоль и использует guard сооружать
Добавляет matchingStrings как продолжение String

Свифт 3

//: Playground - noun: a place where people can play

import Foundation

extension String {
    func matchingStrings(regex: String) -> [[String]] {
        guard let regex = try? NSRegularExpression(pattern: regex, options: []) else { return [] }
        let nsString = self as NSString
        let results  = regex.matches(in: self, options: [], range: NSMakeRange(0, nsString.length))
        return results.map { result in
            (0..<result.numberOfRanges).map { result.rangeAt($0).location != NSNotFound
                ? nsString.substring(with: result.rangeAt($0))
                : ""
            }
        }
    }
}

"prefix12 aaa3 prefix45".matchingStrings(regex: "fix([0-9])([0-9])")
// Prints: [["fix12", "1", "2"], ["fix45", "4", "5"]]

"prefix12".matchingStrings(regex: "(?:prefix)?([0-9]+)")
// Prints: [["prefix12", "12"]]

"12".matchingStrings(regex: "(?:prefix)?([0-9]+)")
// Prints: [["12", "12"]], other answers return an empty array here

// Safely accessing the capture of the first match (if any):
let number = "prefix12suffix".matchingStrings(regex: "fix([0-9]+)su").first?[1]
// Prints: Optional("12")

Swift 2

extension String {
    func matchingStrings(regex: String) -> [[String]] {
        guard let regex = try? NSRegularExpression(pattern: regex, options: []) else { return [] }
        let nsString = self as NSString
        let results  = regex.matchesInString(self, options: [], range: NSMakeRange(0, nsString.length))
        return results.map { result in
            (0..<result.numberOfRanges).map { result.rangeAtIndex($0).location != NSNotFound
                ? nsString.substringWithRange(result.rangeAtIndex($0))
                : ""
            }
        }
    }
}

75

Источник

user543875 14 окт '16 в 10:06

Самый быстрый способ вернуть все совпадения и группы захвата в Swift 5

extension String {
    func match(_ regex: String) -> [[String]] {
        let nsString = self as NSString
        return (try? NSRegularExpression(pattern: regex, options: []))?.matches(in: self, options: [], range: NSMakeRange(0, count)).map { match in
            (0..<match.numberOfRanges).map { match.range(at: $0).location == NSNotFound ? "" : nsString.substring(with: match.range(at: $0)) }
        } ?? []
    }
}

Возвращает двумерный массив строк:

"prefix12suffix fix1su".match("fix([0-9]+)su")

возвращается...

[["fix12su", "12"], ["fix1su", "1"]]

// First element of sub-array is the match
// All subsequent elements are the capture groups

38

Источник

user10312920 16 июн '19 в 10:33

Если вы хотите извлечь подстроки из строки, а не только из позиции (но из фактической строки, включая эмодзи). Тогда следующее, возможно, более простое решение.

extension String {
  func regex (pattern: String) -> [String] {
    do {
      let regex = try NSRegularExpression(pattern: pattern, options: NSRegularExpressionOptions(rawValue: 0))
      let nsstr = self as NSString
      let all = NSRange(location: 0, length: nsstr.length)
      var matches : [String] = [String]()
      regex.enumerateMatchesInString(self, options: NSMatchingOptions(rawValue: 0), range: all) {
        (result : NSTextCheckingResult?, _, _) in
        if let r = result {
          let result = nsstr.substringWithRange(r.range) as String
          matches.append(result)
        }
      }
      return matches
    } catch {
      return [String]()
    }
  }
}

Пример использования:

"someText ⚽️ pig".regex("⚽️")

Вернет следующее:

["⚽️"]

Примечание, используя "\w+", может привести к неожиданному ""

"someText ⚽️ pig".regex("\\w+")

Вернет этот массив строк

["someText", "️", "pig"]

15

Источник

user904032 06 ноя '15 в 13:20

Обновление для iOS 16:`Regex`, ‍♀️

Xcode ранее поддерживал Regex сFind and Searchвкладка Многие нашли AppleNSRegularExpressions Swift API многословный и громоздкий, поэтому Apple выпустилаRegex literalподдержку и в этом году.

API был упрощен, чтобы убрать сложныеStringлогика синтаксического анализа на основе диапазона в iOS 16 / macOS 13, а также повысить производительность.

Литералы RegEx в Swift 5.7

      func parseLine(_ line: Substring) throws -> MailmapEntry {

    let regex = /\h*([^<#]+?)??\h*<([^>#]+)>\h*(?:#|\Z)/

    guard let match = line.prefixMatch(of: regex) else {
        throw MailmapError.badLine
    }

    return MailmapEntry(name: match.1, email: match.2)
}

На данный момент мы можем сопоставить, используяprefixMatchилиwholeMatchчтобы найти одно совпадение, но в будущем API может улучшиться для нескольких совпадений.

RegexBuilder в Swift 5.7

RegexBuilder — это новый API, выпущенный Apple, предназначенный для упрощения написания кода RegEx в Swift. Мы можем перевести литерал Regex/\h*([^<#]+?)??\h*<([^>#]+)>\h*(?:#|\Z)/сверху в более декларативную форму с помощью RegexBuilder, если мы хотим большей читабельности.

Обратите внимание, что мы можем использовать необработанные строки в RegexBuilder, а также чередовать литералы регулярных выражений в построителе, если мы хотим сбалансировать читабельность с краткостью.

      import RegexBuilder

let regex = Regex {
    ZeroOrMore(.horizontalWhitespace)
    Optionally {
        Capture(OneOrMore(.noneOf("<#")))
    }
        .repetitionBehavior(.reluctant)
    ZeroOrMore(.horizontalWhitespace)
    "<"
    Capture(OneOrMore(.noneOf(">#")))
    ">"
    ZeroOrMore(.horizontalWhitespace)
    /#|\Z/
}

Литерал регулярного выражения/£|\Z/эквивалентно:

      ChoiceOf {
   "#"
   Anchor.endOfSubjectBeforeNewline
}

Составной

RegexBuilderСинтаксис подобен SwiftUI также с точки зрения возможности компоновки, потому что мы можем повторно использовать s в другихRegexComponentс:

      struct MailmapLine: RegexComponent {
    @RegexComponentBuilder
    var regex: Regex<(Substring, Substring?, Substring)> {
        ZeroOrMore(.horizontalWhitespace)
        Optionally {
            Capture(OneOrMore(.noneOf("<#")))
        }
            .repetitionBehavior(.reluctant)
        ZeroOrMore(.horizontalWhitespace)
        "<"
        Capture(OneOrMore(.noneOf(">#")))
        ">"
        ZeroOrMore(.horizontalWhitespace)
        ChoiceOf {
           "#"
            Anchor.endOfSubjectBeforeNewline
        }
    }
}

13

Источник

user4995828 07 июн '22 в 18:24

Я обнаружил, что решение для принятого ответа, к сожалению, не компилируется в Swift 3 для Linux. Вот модифицированная версия, которая делает:

import Foundation

func matches(for regex: String, in text: String) -> [String] {
    do {
        let regex = try RegularExpression(pattern: regex, options: [])
        let nsString = NSString(string: text)
        let results = regex.matches(in: text, options: [], range: NSRange(location: 0, length: nsString.length))
        return results.map { nsString.substring(with: $0.range) }
    } catch let error {
        print("invalid regex: \(error.localizedDescription)")
        return []
    }
}

Основными отличиями являются:

Swift на Linux, кажется, требует удаления NS префикс на объектах Foundation, для которых нет аналога Swift-native. (См. Предложение Swift Evolution № 86.)
Swift на Linux также требует указания options аргументы для обоих RegularExpression инициализация и matches метод.
По какой-то причине, принуждая String в NSString не работает в Swift на Linux, но инициализирует новый NSString с String как источник работает

Эта версия также работает с Swift 3 на macOS / Xcode, за исключением того, что вы должны использовать имя NSRegularExpression вместо RegularExpression,

12

Источник

user4802001 17 окт '16 в 18:45

Swift 4 без NSString.

extension String {
    func matches(regex: String) -> [String] {
        guard let regex = try? NSRegularExpression(pattern: regex, options: [.caseInsensitive]) else { return [] }
        let matches  = regex.matches(in: self, options: [], range: NSMakeRange(0, self.count))
        return matches.map { match in
            return String(self[Range(match.range, in: self)!])
        }
    }
}

7

Источник

user428022 27 фев '19 в 07:23

@p4bloch, если вы хотите захватить результаты из серии скобок захвата, то вам нужно использовать rangeAtIndex(index) метод NSTextCheckingResult, вместо range, Вот метод @MartinR для Swift2 сверху, адаптированный для захвата скобок. В возвращаемом массиве первый результат [0] весь захват, а затем отдельные группы захвата начинаются с [1], Я закомментировал map операции (чтобы было легче увидеть, что я изменил) и заменил его на вложенные циклы.

func matches(for regex: String!, in text: String!) -> [String] {

    do {
        let regex = try NSRegularExpression(pattern: regex, options: [])
        let nsString = text as NSString
        let results = regex.matchesInString(text, options: [], range: NSMakeRange(0, nsString.length))
        var match = [String]()
        for result in results {
            for i in 0..<result.numberOfRanges {
                match.append(nsString.substringWithRange( result.rangeAtIndex(i) ))
            }
        }
        return match
        //return results.map { nsString.substringWithRange( $0.range )} //rangeAtIndex(0)
    } catch let error as NSError {
        print("invalid regex: \(error.localizedDescription)")
        return []
    }
}

Пример использования может быть, скажем, вы хотите разделить строку title year Например, "В поисках Дори 2016" вы можете сделать это:

print ( matches(for: "^(.+)\\s(\\d{4})" , in: "Finding Dory 2016"))
// ["Finding Dory 2016", "Finding Dory", "2016"]

5

Источник

user5519821 06 авг '16 в 19:18

Большинство приведенных выше решений дают полное совпадение, игнорируя группы захвата, например: ^\d+\s+(\d+)

Чтобы получить совпадения группы захвата, как и ожидалось, вам нужно что-то вроде (Swift4):

public extension String {
    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
    }
}

4

Источник

user314546 06 дек '17 в 10:05

Это очень простое решение, которое возвращает массив строк с совпадениями

Свифт 3.

internal func stringsMatching(regularExpressionPattern: String, options: NSRegularExpression.Options = []) -> [String] {
        guard let regex = try? NSRegularExpression(pattern: regularExpressionPattern, options: options) else {
            return []
        }

        let nsString = self as NSString
        let results = regex.matches(in: self, options: [], range: NSMakeRange(0, nsString.length))

        return results.map {
            nsString.substring(with: $0.range)
        }
    }

2

Источник

user8709353 02 окт '17 в 15:47

Вот как я это сделал, я надеюсь, что это даст новую перспективу, как это работает на Swift.

В этом примере ниже я получу любую строку между []

var sample = "this is an [hello] amazing [world]"

var regex = NSRegularExpression(pattern: "\\[.+?\\]"
, options: NSRegularExpressionOptions.CaseInsensitive 
, error: nil)

var matches = regex?.matchesInString(sample, options: nil
, range: NSMakeRange(0, countElements(sample))) as Array<NSTextCheckingResult>

for match in matches {
   let r = (sample as NSString).substringWithRange(match.range)//cast to NSString is required to match range format.
    println("found= \(r)")
}

2

Источник

user1959948 04 ноя '15 в 17:18

В iOS 16 появился новый синтаксис, который упрощает этот процесс. Например, для всего, что находится в скобках в этой строке

      let randomLog = "2493875469750,1678798470864,{latitude: 50, longitude: 43}"

if let match = randomLog.firstMatch(of: /\{.*\}/) {
    print(match.output)
}

Это печатает

      "{"latitude": 50, "longitude": 43}"

Чтобы стать Swift Regex Pro или просто получить дополнительную информацию, посетите WWDC 2022:https://developer.apple.com/videos/play/wwdc2022/110357/

2

Источник

user1620701 15 мар '23 в 15:43

обновить @Mike Chirico's до Swift 5

      extension String{



  func regex(pattern: String) -> [String]?{
    do {
        let regex = try NSRegularExpression(pattern: pattern, options: NSRegularExpression.Options(rawValue: 0))
        let all = NSRange(location: 0, length: count)
        var matches = [String]()
        regex.enumerateMatches(in: self, options: NSRegularExpression.MatchingOptions(rawValue: 0), range: all) {
            (result : NSTextCheckingResult?, _, _) in
              if let r = result {
                    let nsstr = self as NSString
                    let result = nsstr.substring(with: r.range) as String
                    matches.append(result)
              }
        }
        return matches
    } catch {
        return nil
    }
  }
}

2

Источник

user10332481 13 фев '21 в 22:57

Большое спасибо Lars Blumberg его ответ за сбор групп и полные матчи со Swift 4, которые мне очень помогли. Я также сделал дополнение к нему для людей, которые хотят получить ответ error.localizedDescription, когда их регулярное выражение недопустимо:

extension String {
    func matchingStrings(regex: String) -> [[String]] {
        do {
            let regex = try NSRegularExpression(pattern: regex)
            let nsString = self as NSString
            let results  = regex.matches(in: self, options: [], range: NSMakeRange(0, nsString.length))
            return results.map { result in
                (0..<result.numberOfRanges).map {
                    result.range(at: $0).location != NSNotFound
                        ? nsString.substring(with: result.range(at: $0))
                        : ""
                }
            }
        } catch let error {
            print("invalid regex: \(error.localizedDescription)")
            return []
        }
    }
}

Для меня наличие localizedDescription в качестве ошибки помогло понять, что пошло не так с экранированием, так как оно показывает, какой последний regex swift пытается реализовать.

1

Источник

user8970591 05 дек '18 в 18:00

Вы можете использоватьmatching(regex:)в строке типа:

      let array = try "Your String To Search".matching(regex: ".")

используя это простое расширение:

      public extension String {
    func matching(regex: String) throws -> [String] {
        let regex = try NSRegularExpression(pattern: regex)
        let results = regex.matches(in: self, range: NSRange(startIndex..., in: self))
        return results.map { String(self[Range($0.range, in: self)!]) }
    }
}

1

Источник

user5623035 23 янв '23 в 10:37

сопоставление основного номера телефона

      let phoneNumbers = ["+79990001101", "+7 (800) 000-11-02", "+34 507 574 147 ", "+1-202-555-0118"]

let match: (String) -> String = {
    $0.replacingOccurrences(of: #"[^\d+]"#, with: "", options: .regularExpression)
}

print(phoneNumbers.map(match))
// ["+79990001101", "+78000001102", "+34507574147", "+12025550118"]

1

Источник

user13887646 14 дек '21 в 08:37

Другие вопросы по тегам ios swift regex string

user1187415 10 янв '15 в 20:12 2015-01-10 20:12 · Accepted Answer · 2015-01-10 20:12

Даже если matchesInString() метод занимает String в качестве первого аргумента, он работает внутри NSStringи параметр диапазона должен быть задан с помощью NSString длина, а не как длина строки Swift. В противном случае произойдет сбой для "расширенных кластеров графем", таких как "флаги".

Начиная с Swift 4 (Xcode 9), стандартная библиотека Swift предоставляет функции для преобразования между Range<String.Index> а также NSRange,

func matches(for regex: String, in text: String) -> [String] {

    do {
        let regex = try NSRegularExpression(pattern: regex)
        let results = regex.matches(in: text,
                                    range: NSRange(text.startIndex..., in: text))
        return results.map {
            String(text[Range($0.range, in: text)!])
        }
    } catch let error {
        print("invalid regex: \(error.localizedDescription)")
        return []
    }
}

Пример:

let string = "€4€9"
let matched = matches(for: "[0-9]", in: string)
print(matched)
// ["4", "9"]

Примечание: принудительное развертывание Range($0.range, in: text)! безопасно, потому что NSRange ссылается на подстроку данной строки text, Однако, если вы хотите избежать этого, используйте

        return results.flatMap {
            Range($0.range, in: text).map { String(text[$0]) }
        }

вместо.

(Старый ответ для Swift 3 и ранее:)

Таким образом, вы должны преобразовать данную строку Swift в NSString а затем извлечь диапазоны. Результат будет преобразован в строковый массив Swift автоматически.

(Код для Swift 1.2 можно найти в истории редактирования.)

Swift 2 (Xcode 7.3.1):

func matchesForRegexInText(regex: String, text: String) -> [String] {

    do {
        let regex = try NSRegularExpression(pattern: regex, options: [])
        let nsString = text as NSString
        let results = regex.matchesInString(text,
                                            options: [], range: NSMakeRange(0, nsString.length))
        return results.map { nsString.substringWithRange($0.range)}
    } catch let error as NSError {
        print("invalid regex: \(error.localizedDescription)")
        return []
    }
}

Пример:

let string = "€4€9"
let matches = matchesForRegexInText("[0-9]", text: string)
print(matches)
// ["4", "9"]

Swift 3 (Xcode 8)

func matches(for regex: String, in text: String) -> [String] {

    do {
        let regex = try NSRegularExpression(pattern: regex)
        let nsString = text as NSString
        let results = regex.matches(in: text, range: NSRange(location: 0, length: nsString.length))
        return results.map { nsString.substring(with: $0.range)}
    } catch let error {
        print("invalid regex: \(error.localizedDescription)")
        return []
    }
}

Пример:

let string = "€4€9"
let matched = matches(for: "[0-9]", in: string)
print(matched)
// ["4", "9"]

Swift выдерживает регулярные выражения

16 ответов

Самый быстрый способ вернуть все совпадения и группы захвата в Swift 5

Обновление для iOS 16:Regex, ‍♀️

Литералы RegEx в Swift 5.7

RegexBuilder в Swift 5.7

Составной

Обновление для iOS 16:`Regex`, ‍♀️