函数中的Swift常数（带有计算）？

Question

Here's a simple Swift function

fileprivate func test()->String{
    let c = Array("abc".characters)
    let k = UInt32(c.count)
    let r = Int(arc4random_uniform(k))
    return String(c[r])
}

(I chose this example because, obviously, it's something you may call billions of times to generate some sort of output; so you might be concerned for performance in setting up the two constants.)

Note that it has to do a bit of calculation to get c , and indeed to get k it has to use c .

My question is simple: every time you call this function

test()
test()
test()

in fact does it calculate k , and/or c every time I call it, or indeed are they only calculated once ?

(if "only once", then as a curiosity: it does that the first time I call the function? or perhaps the compiler arranges to have it done separately at startup time? or for that matter does it know it can compute them during compilation?)

---

I often use global calculated properties, rather like this

let basicDF : DateFormatter = {
    print("this will only be done once per launch of the app")
    let formatter = DateFormatter()
    formatter.dateFormat = "yyyy-MM-dd"
    return formatter 
}()

(perhaps with fileprivate ) If the answer to the above question is "no, c and 'k' are calculated every time you call test", then in that case how can you put a kind of static computed property inside a function??

Answer 1

No, in your particular case, the compiler currently doesn't optimise c and/or k to constant expressions that are only evaluated once (this can be seen by examining the IR in an optimised build) – although this is all subject to change with future versions of the language.

However it's worth noting that it can currently do this for simpler expressions, for example:

func foo() -> Int {
    return 2 + 4
}

The compiler can evaluate the addition at compile-time so the function just does return 6 (and then this can be inlined). But of course, you should only be worrying about such optimisations in the first place if you've actually identified the given function as a performance bottleneck.

One nice trick to get static constants in a function is to define a case-less enum with static properties in the function scope, in which you can define your constant expressions:

func test() -> String {

    enum Constants {
        static let c = Array("abc".characters)
        static let k = UInt32(c.count)
    }

    let r = Int(arc4random_uniform(Constants.k))
    return String(Constants.c[r])
}

Now both the initialiser expressions for c and k will only be evaluated once, and this will be done when they are first used (ie when the function is first called).

And of course, as you show, you can use an immediately-evalutated closure in order to have a multi-line initialisation expression:

enum Constants {
    static let c: [Character] = {
        // ...
        return Array("abc".characters)
    }()
    // ...
}

Answer 2

I think you should assume that c and k are calculated every time. The calculation might be optimized away as an implementation detail of the compiler, but I wouldn't count on that if I were you.

Swift has no equivalent to a C static local variable (that is, an "automatic" variable within a function whose value is maintained between calls to the function).

If you really want to put the effort into making sure that k is only calculated once, make it a true constant (ie at class level). Of course you will then also have to do the same for c , as you need it in your later calculations. It seems like a silly example in this case, but I often do this when the thing being created is heavyweight, like an image or view that will be used over and over:

class MyView : UIView {
    lazy var arrow : UIImage = self.arrowImage()
    func arrowImage () -> UIImage {
        // ... big image-generating code goes here ...
    }
}

I was calling arrowImage() over and over until I said to myself, wait, I can make this a constant (here expressed as a lazy var ) and calculate it just once, namely the first time arrow is accessed.