Variables de fonction statiques dans Swift

J'essaie de comprendre comment déclarer une variable statique portée uniquement localement à une fonction dans Swift.

En C, cela pourrait ressembler à ceci:

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

En Objective-C, c'est fondamentalement la même chose:

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

Mais je n'arrive pas à faire quelque chose comme ça dans Swift. J'ai essayé de déclarer la variable de la manière suivante:

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

Mais tout cela entraîne des erreurs.

• Le premier se plaint "Les propriétés statiques ne peuvent être déclarées que sur un type".
• Le second se plaint "Déclaration attendue" (où staticest) et "Modèle attendu" (où timesCalledBest)
• Le troisième se plaint "Les instructions consécutives sur une ligne doivent être séparées par ';'" (dans l'espace entre les deux points et static) et "Type attendu" (où staticest)
• Le quatrième se plaint "Les déclarations consécutives sur une ligne doivent être séparées par ';'" (dans l'espace entre Intet static) et "Déclaration attendue" (sous le signe égal)

Je ne pense pas que Swift prend en charge la variable statique sans l'avoir attachée à une classe / structure. Essayez de déclarer une structure privée avec une variable statique.

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

Une autre solution

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 avec Xcode 6.3 prend désormais en charge statique comme prévu. À partir des notes de version bêta de Xcode 6.3:

Les méthodes et propriétés «statiques» sont désormais autorisées dans les classes (en tant qu'alias pour «class final»). Vous êtes maintenant autorisé à déclarer des propriétés stockées statiques dans des classes, qui ont un stockage global et sont initialisées paresseusement au premier accès (comme les variables globales). Les protocoles déclarent désormais les exigences de type comme des exigences «statiques» au lieu de les déclarer comme des exigences de «classe». (17198298)

Il semble que les fonctions ne peuvent pas contenir de déclarations statiques (comme demandé en question). Au lieu de cela, la déclaration doit être faite au niveau de la classe.

Exemple simple montrant une propriété statique incrémentée dans une fonction de classe (aka statique), bien qu'une fonction de classe ne soit pas requise:

class StaticThing
{
    static var timesCalled = 0

    class func doSomething()
    {
        timesCalled++

        println(timesCalled)
    }
}

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

Production:

1
2
3

Une autre solution

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