String handling in Swift has been a moving target. While following the evolution of performing certain string operations in Swift, I’ve been reminded of the post Joel Spolsky wrote over a decade ago admonishing all of us to get with the program and support Unicode in our applications from day one. While Swift 1.0 didn’t ignore the request, it certainly did make it easier to use “natural” expressions to extract substrings with ranges. Swift 2.0 tossed that out the window, and a top-rated answer on Stackoverflow becomes useless.
Don’t try this at home, it won’t work, but it sure would be nice if it did:
|
1 2 3 |
var helloWorld = "Hello, world!" let hello = helloWorld[0...4] print(hello) |
I mean, it works for Python with hello = helloWorld[0:5], why can’t it work in Swift?
Like we said, Swift 2 is taking Joel’s 2003 plea to heart, and working to make us all (painfully) more aware that these aren’t your father’s strings. There is a great summary as to the rationale at mikeash.com so there’s no reason for me to rehash characters vs. graphemes here. And while I “get it”, there’s no doubt its an aggravation trying to remember what magic I need to invoke to get a substring out of what I know is going to be a const char* C-style ASCII-based string. So, I won’t bother trying to remember, I’ll just write it here for you and for me.
A Simple Substring
I’ve been looking at ways to blend more Swift programming in my day-to-day Linux tasks. I really think it has an opportunity to displace some other languages for quick scripts and “devops”-oriented tasks. In this case I wanted a quick way to print out the git revisions of the projects that make up an open source Swift build. Here’s what I came up with:
|
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 28 29 30 |
import Glibc func getGitRevision(dirname:String) -> String { let BUFSIZE = 128 let cwd = String.fromCString(getcwd(nil, 0))! var rc = chdir(dirname) guard rc == 0 else { return "ERROR" } var rev = "" let pipe = popen("/usr/bin/git rev-parse HEAD", "r") var buf = [CChar](count:BUFSIZE, repeatedValue:CChar(0)) while fgets(&buf, Int32(BUFSIZE), pipe) != nil { rev = String.fromCString(buf)! } rev = rev[rev.startIndex...rev.startIndex.advancedBy(9)] chdir(cwd) return rev } let dirs = ["swift", "llvm", "clang", "lldb", "cmark", "llbuild", "swiftpm", "swift-corelibs-xctest", "swift-corelibs-foundation", "swift-integration-tests"] for dir in dirs { let rev = getGitRevision(dir) print("\(dir):\(rev)") } |
Getting the first 10 characters of the git revision hash with rev = rev[rev.startIndex...rev.startIndex.advancedBy(9)] is a little more verbose than it should be, but if you are dealing with what you know to be a C-style string, it gets the job done.
Extend It
Fortunately for us, Swift supports extensions, that awesome feature that allows you to tack on some methods to a class you didn’t write and don’t have source access to. Many folks have posted gists of this particular extension which provides a little syntactic sugar for accessing substrings:
|
1 2 3 4 5 6 7 8 9 10 |
extension String { subscript (r: Range<Int>) -> String { get { let startIndex = self.startIndex.advancedBy(r.startIndex) let endIndex = self.startIndex.advancedBy(r.endIndex) return self[Range(start: startIndex, end: endIndex)] } } } |
With our extension we can indeed write:
|
1 2 3 4 |
let helloWorld = "Hello, world!" var hello = helloWorld[0...4] print(hello) |
Life is good.
You say you read Mike Ash’s post, but to have done so would have negated a fair bit of this post. Please don’t add a subscript to String, it’ll regularly do the wrong thing, especially from a performance standpoint. The Swift team didn’t add it just to be difficult.
In this particular case, just using the “fromCString” factory method does not guarantee anything about the makeup of the resulting String. If you want to guarantee C-style semantics, use String.UTF8View. Furthermore, taking the first 9 of any collection can be done with the instance method “prefix”, which can be used on the CharactersView of the String (which is still probably not what you want), or the UTF8View as well.
Zachary, to the contrary, nothing I’ve done negates Mike Ash’s post. Like I said, I “get it” but I know what is coming across the wire with that
fgets, a 40-character ASCII string of a SHA1 hash. No emoji characters, no letters with diacritics. In that case using an extension is no worse than atypealiasfor readability. We’re talking about a simple script to slice up some strings and print them on standard out.Your *hisses angrily* tweet aside, there really is no reason Swift can’t provide a convenience syntax for working with substring extraction, I mean, its not like 40 other languages don’t provide that. https://en.wikipedia.org/wiki/Comparison_of_programming_languages_(string_functions)#substring