Even if the matchesInString() method takes a String as the first argument,it works internally with NSString, and the range parameter must be given using the NSString length and not as the Swift string length. Otherwise it willfail for "extended grapheme clusters" such as "flags".

As of Swift 4 (Xcode 9), the Swift standardlibrary provides functions to convert between Range<String.Index> and 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 []    }}

Example:

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

Note: The forced unwrap Range($0.range, in: text)! is safe becausethe NSRange refers to a substring of the given string text.However, if you want to avoid it then use

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

instead.

(Older answer for Swift 3 and earlier:)

So you should convert the given Swift string to an NSString and then extract theranges. The result will be converted to a Swift string array automatically.

(The code for Swift 1.2 can be found in the edit history.)

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 []    }}

Example:

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 []    }}

Example:

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

My answer builds on top of given answers but makes regex matching more robust by adding additional support:

• Returns not only matches but returns also all capturing groups for each match (see examples below)
• Instead of returning an empty array, this solution supports optional matches
• Avoids do/catch by not printing to the console and makes use of the guard construct
• Adds matchingStrings as an extension to String

Swift 4.2

//: Playground - noun: a place where people can playimport Foundationextension 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.range(at: $0).location != NSNotFound                    ? nsString.substring(with: result.range(at: $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 3

//: Playground - noun: a place where people can playimport Foundationextension 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))                    : ""            }        }    }}

The fastest way to return all matches and capture groups in 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, nsString.length)).map { match in            (0..<match.numberOfRanges).map { match.range(at: $0).location == NSNotFound ? "" : nsString.substring(with: match.range(at: $0)) }        } ?? []    }}

Returns a 2-dimentional array of strings:

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

returns...

[["fix12su", "12"], ["fix1su", "1"]]// First element of sub-array is the match// All subsequent elements are the capture groups