如何搜索在某个字符串的索引之前开始的正则表达式匹配？

Question

Let's say I have a regular expression

let regexString = "\\s{1,3}(---+)\\s*"
let regex = try? NSRegularExpression(pattern: regexString)

and a string

let string = "Space --- the final frontier --- these are the voyages..."

and let's further assume that the string was really long and continued after the ellipses ( ... ) over several thousands of characters.

Now I want to find the first match for the regular expression regex , but I want to stop searching after a certain index for efficiency reasons.

Example:

index:  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
string: S  p  a  c  e     -  -  -     t  h  e     f  i  n  a  l     f  r  o  n  t  i  e  r
range:  +  +  +  +  +  +  +  +  +  +  +  +  +  +  +  ⬆︎ -  -  -  -  -  -  -  -  -  -  -  -
                                                     max 

This would mean that I only search the string for a regular expression match that starts before index 15 .

---

The behavior described above is different from searching only a subrange of the string. Here's why:

✅ Should match:

The following example should produce a match at range [5–9], because the match starts before the max index (= 7).

index:  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
string: S  p  a  c  e     -  -  -     t  h  e     f  i  n  a  l     f  r  o  n  t  i  e  r
range:  +  +  +  +  +  +  +  ⬆︎ -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -
                             max 

❎ Should, but would not match:

If I only searched a substring up to the max index (= 7), the regular expression would not be able to match because part of the match would be truncated.

index:  0  1  2  3  4  5  6  7  
string: S  p  a  c  e     -  -  
range:  +  +  +  +  +  +  +  ⬆︎ 
                             max 

How can I achieve this?

Answer 1

Since you are using a capture group I'm assuming that is the string you are looking for. You can change your expression to this: ^.{0,6}\\\\s{1,3}(---+)\\\\s* . I added the following:

• ^ beginning of string.
• .{0,6} to match from zero to six characters.

Changing the expression like this will match what you are looking for, your original expression will match if it starts at most at position 6 , this is your max . The difference is that the whole match contains those optional characters, but the first capture group will only contain the dashes you are looking for.

I use the following code at a playground to test the new expression:

let regexString = "^.{0,6}\\s{1,3}(---+)\\s*"
let regex = try? NSRegularExpression(pattern: regexString)
let string = "Space --- the final frontier --- these are the voyages of the     
             starship Enterprise. Its continuing mission: to explore strange 
             new worlds. To seek out new life and new civilizations. To boldly   
             go where no one has gone before!"

let matches = regex?.matches(in: string, options: [], range: NSRange(location: 0, length: string.count))
if let firstMatch = matches?.first {
    print("Whole regex match starts at index: \(firstMatch.range.lowerBound)")
    print("Whole match: \(String(string[Range(firstMatch.range, in: string)!]))")
    print("Capture group start at index: \(firstMatch.range(at: 1).lowerBound)")
    print("Capture group string: \(String(string[Range(firstMatch.range(at: 1), in: string)!]))")
} else {
    print("No matches")
}

Running the code above shows the following results:

Whole regex match starts at index: 0

Whole match: Space ---

Capture group start at index: 6

Capture group string: ---

If string is change like this: let string = "The space --- the final frontier --- these are the ... the result is:

No matches

since the \\\\s{1,3} is starting at index 10 .

Hope this works for you.