Statische Funktionsvariablen in Swift

Ich versuche herauszufinden, wie eine statische Variable deklariert wird, die nur lokal für eine Funktion in Swift gültig ist.

In C könnte dies ungefähr so ​​aussehen:

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

In Objective-C ist es im Grunde dasselbe:

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

Aber ich kann so etwas in Swift scheinbar nicht machen. Ich habe versucht, die Variable folgendermaßen zu deklarieren:

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

Dies alles führt jedoch zu Fehlern.

• Die erste Beschwerde "Statische Eigenschaften dürfen nur für einen Typ deklariert werden".
• Der zweite beschwert sich über "Erwartete Deklaration" (wo staticist) und "Erwartetes Muster" (wo timesCalledBist)
• Der dritte beschwert sich über "Aufeinanderfolgende Anweisungen in einer Zeile müssen durch ';'" (im Leerzeichen zwischen Doppelpunkt und static) und "Erwarteter Typ" (wo staticist) getrennt werden.
• Die vierte Beschwerde lautet "Aufeinanderfolgende Anweisungen in einer Zeile müssen durch ';'" (im Leerzeichen zwischen Intund static) und "Erwartete Deklaration" (unter dem Gleichheitszeichen) getrennt werden.

Ich glaube nicht, dass Swift statische Variablen unterstützt, ohne sie an eine Klasse / Struktur anzuhängen. Versuchen Sie, eine private Struktur mit einer statischen Variablen zu deklarieren.

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

Eine andere Lösung

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 mit Xcode 6.3 unterstützt jetzt wie erwartet statisch. Aus den Versionshinweisen zur Beta-Version von Xcode 6.3:

"Statische" Methoden und Eigenschaften sind jetzt in Klassen zulässig (als Alias ​​für "class final"). Sie können jetzt statisch gespeicherte Eigenschaften in Klassen deklarieren, die über globalen Speicher verfügen und beim ersten Zugriff träge initialisiert werden (wie globale Variablen). Protokolle deklarieren jetzt Typanforderungen als "statische" Anforderungen, anstatt sie als "Klassen" -Anforderungen zu deklarieren. (17198298)

Es scheint, dass Funktionen keine statischen Deklarationen enthalten können (wie in Frage gestellt). Stattdessen muss die Deklaration auf Klassenebene erfolgen.

Einfaches Beispiel für eine statische Eigenschaft, die innerhalb einer Klassenfunktion (auch als statische Funktion bezeichnet) inkrementiert wurde, obwohl eine Klassenfunktion nicht erforderlich ist:

class StaticThing
{
    static var timesCalled = 0

    class func doSomething()
    {
        timesCalled++

        println(timesCalled)
    }
}

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

Ausgabe:

1
2
3

Eine andere Lösung

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