Variabili di funzione statiche in Swift

Sto cercando di capire come dichiarare una variabile statica con scope solo localmente a una funzione in Swift.

In C, questo potrebbe assomigliare a questo:

int foo() {
    static int timesCalled = 0;
    ++timesCalled;
    return timesCalled;
}

In Objective-C, è fondamentalmente lo stesso:

- (NSInteger)foo {
    static NSInteger timesCalled = 0;
    ++timesCalled;
    return timesCalled;
}

Ma non riesco a fare niente del genere in Swift. Ho provato a dichiarare la variabile nei seguenti modi:

static var timesCalledA = 0
var static timesCalledB = 0
var timesCalledC: static Int = 0
var timesCalledD: Int static = 0

Ma tutto ciò si traduce in errori.

• Il primo lamenta "Le proprietà statiche possono essere dichiarate solo su un tipo".
• Il secondo si lamenta "Dichiarazione attesa" (dove si statictrova) e "Modello previsto" (dove si timesCalledBtrova)
• Il terzo si lamenta "Le istruzioni consecutive su una riga devono essere separate da"; "(nello spazio tra i due punti e static) e" Tipo previsto "(dove si statictrova)
• Il quarto reclama "Le dichiarazioni consecutive su una riga devono essere separate da ';'" (nello spazio tra Inte static) e "Dichiarazione prevista" (sotto il segno di uguale)

Non credo che Swift supporti la variabile statica senza averla collegata a una classe / struttura. Prova a dichiarare una struttura privata con una variabile statica.

func foo() -> Int {
    struct Holder {
        static var timesCalled = 0
    }
    Holder.timesCalled += 1
    return Holder.timesCalled
}

  7> foo()
$R0: Int = 1
  8> foo()
$R1: Int = 2
  9> foo()
$R2: Int = 3

Un'altra soluzione

func makeIncrementerClosure() -> () -> Int {
    var timesCalled = 0
    func incrementer() -> Int {
        timesCalled += 1
        return timesCalled
    }
    return incrementer
}

let foo = makeIncrementerClosure()
foo()  // returns 1
foo()  // returns 2

Swift 1.2 con Xcode 6.3 ora supporta statico come previsto. Dalle note di rilascio beta di Xcode 6.3:

I metodi e le proprietà "statici" sono ora consentiti nelle classi (come alias per "class final"). È ora possibile dichiarare proprietà archiviate statiche nelle classi, che hanno una memoria globale e vengono inizializzate pigramente al primo accesso (come le variabili globali). I protocolli ora dichiarano i requisiti di tipo come requisiti "statici" invece di dichiararli come requisiti di "classe". (17198298)

Sembra che le funzioni non possano contenere dichiarazioni statiche (come richiesto in questione). Invece, la dichiarazione deve essere eseguita a livello di classe.

Semplice esempio che mostra una proprietà statica incrementata all'interno di una funzione di classe (nota anche come statica), sebbene una funzione di classe non sia richiesta:

class StaticThing
{
    static var timesCalled = 0

    class func doSomething()
    {
        timesCalled++

        println(timesCalled)
    }
}

StaticThing.doSomething()
StaticThing.doSomething()
StaticThing.doSomething()

Produzione:

1
2
3

Un'altra soluzione

class Myclass {
    static var timesCalled = 0
    func foo() -> Int {
        Myclass.timesCalled += 1
        return Myclass.timesCalled
    }
}