Extremely slow parsing text with Swift - ios

Question

I'm trying to parse a 46k characters text document and it takes forever to do so. Here's what I do :
for i in 0..<html.length() - SEARCH_START.length() {
if html.substring(i, end: i+SEARCH_START.length()) == SEARCH_START {
start = i + SEARCH_START.length();
break;
}
if i % 1000 == 0 {
NSLog("i = \(i)")
}
}
extension String {
public func length () -> Int {
return self.characters.count
}
public func substring(_ start : Int, end : Int) -> String {
if self.characters.count <= 0 {
return ""
}
let realEnd = end>0 ? end : 0
return self.substring(with: self.index(self.startIndex, offsetBy: start)..<self.index(self.startIndex, offsetBy: realEnd))
}
}
Sorry, had to extend String class to do less rewriting from Android.
So, Log is being triggered each 6.5 seconds for a next thousand means almost 5 minutes to get to the end. The wole process should take milliseconds. What's the deal? Any way to speed it up?

Answer 1

You Int indexing extension is the problem. To get a substring at position n, it needs to go through all the characters 0..n. Therefore your algorithm has O(n^2) (quadratic) complexity instead of the expected O(n) (linear) complexity.
Don't use that extension.
To search for a substring, there is a native method
if let range = html.range(of: SEARCH_START) {
let integerIndex = html.distance(from: html.startIndex, to: range.upperBound)
print(integerIndex)
}
If you really want to work with integers, you should convert your string to an array of characters first:
let chars = Array(html.characters)
and work with subarrays instead of substrings.
Edit:
To better understand what happens in your extension:
self.substring(with: self.index(self.startIndex, offsetBy: start)..<self.index(self.startIndex, offsetBy: realEnd))
In Java, where String is an array and supports random indexing this would be a constant (fast) operation. However, in Swift this is composed from 3 steps:
self.index(self.startIndex, offsetBy: start) iterates from the first character until it finds the character at index start.
self.index(self.startIndex, offsetBy: realEnd)) iterates from the first character until it finds the character at index realEnd.
Gets the substring (fast)
In short, for every substring at start position n, the algorithm has to iterate over 2n characters. To get a single substring at index 20000, you need 40000 operations!