web-dev-qa-db-fra.com

Quand utiliser constante statique et variable dans Swift?

Quelques articles expliquent comment écrire le code pour static constant et static variable dans Swift. Mais il est difficile de savoir quand utiliser static constant et static variable plutôt que constant et variable. Quelqu'un peut-il expliquer?

iosswiftvariablesstaticconstants
23
Mike

Lorsque vous définissez une var/let statique dans une classe (ou une structure), ces informations seront partagées entre toutes les instances (ou valeurs).

Partage d'informations

class Animal {
    static var nums = 0

    init() {
        Animal.nums += 1
    }
}

let dog = Animal()
Animal.nums // 1
let cat = Animal()
Animal.nums // 2

Comme vous pouvez le voir ici, j'ai créé 2 instances distinctes de Animal mais les deux partagent la même variable statique nums.

Singleton

Souvent, une constante statique est utilisée pour adopter le modèle Singleton. Dans ce cas, nous souhaitons allouer au maximum 1 instance d'une classe . Pour cela, nous sauvegardons la référence à l'instance partagée à l'intérieur d'une constante et nous masquons l'initialiseur.

class Singleton {
    static let sharedInstance = Singleton()

    private init() { }

    func doSomething() { }
}

Maintenant, quand nous avons besoin de l'instance Singleton, nous écrivons

Singleton.sharedInstance.doSomething()
Singleton.sharedInstance.doSomething()
Singleton.sharedInstance.doSomething()

Cette approche nous permet d’utiliser toujours la même instance, même à différents endroits de l’application.

61
Luca Angeletti

Quelques articles expliquent comment écrire du code pour une constante statique et une variable statique dans Swift. Mais il est difficile de savoir quand utiliser statique constante et variable statique plutôt que constante et variable. Quelqu'un peut-il expliquer? Lorsque vous définissez une var/let statique dans une classe (ou une structure), cette valeur est partagée entre toutes les instances (ou valeurs).

les variables/classes statiques sont des variables accessibles sans la nécessité de créer une instance/un objet.

class Human {
    static let numberOfEyes = 2 //human have only 2 eyes
    static var eyeDefect = false //whether human have side-effect or not. he can have defect later so its variable

    //other variables and functions
}

//you can access numberOfEyes like below no object of Human is created
print(Human.numberOfEyes)
print(Human.eyeDefect)

//Object of Human
let john = Human()

Je pense que vous connaissez la différence entre constante et variable. En bref, constante est celle dont la valeur ne change jamais; numberOfEyes dans l'exemple ci-dessus et variable est celui dont la valeur change; eyeDefect dans l'exemple ci-dessus.

constante statique ou les variables sont placées en mémoire (RAM) séparément puis les objets. c'est-à-dire que numberOfEyes a un espace mémoire alloué différent de celui de l'objet John, ce n'est pas à l'intérieur de John.

maintenant, quand utiliser des constantes/variables statiques:

  1. Lorsque vous utilisez un modèle de conception singleton: static let sharedInstance = APIManager ()

    class APIManager(){
    static let sharedInstance = APIManager()
    //Your other variables/functions here below
}
//Use it as to get singleton instance of APIManager from anywhere in your application
let instanceOfAPIManager = APIManager.sharedInstance

  2. Lorsque vous avez besoin de la valeur de tout ce qui est globalement identique sans avoir besoin de créer une instance de la classe sous laquelle elle est définie comme numberOfEyes dans human class.

  3. L'utilisation de variables/constantes statiques n'est pas très recommandée en raison de problèmes de mémoire, car une fois instanciée/affectée, elle reste en mémoire jusqu'à ce que votre application soit supprimée de la mémoire. J'ai trouvé jusqu'à présent que le meilleur endroit pour utiliser des variables/constantes statiques est uniquement lorsque vous créez un modèle singleton et que les pointeurs d'autres variables et constantes normales n'utilisent pas statique car: problème de mémoire, il sera difficile d'exécuter des tests unitaires dans votre code avec des variables/constantes statiques. Non recommandé d'utiliser comme comme dans la classe humaine aussi. à la place, utilisez-les en tant que constantes ou variables et accédez-y en créant un exemple.

    class Human {
 let numberOfEyes = 2 //human have only 2 eyes
 var eyeDefect = false //whether human have side-effect or not. he can have defect later so its variable

   //other variables and functions
 }

//you can access numberOfEyes like below if you need just those values.
print(Human().numberOfEyes)
print(Human().eyeDefect)
9
Dari

Les constantes statiques et les variables appartiennent à la classe elle-même et non à une instance particulière. Une classe peut également avoir des méthodes statiques qui peuvent être appelées sans créer d'instance de classe.

Ainsi, lorsque vous avez une classe MyClass avec une variable statique x, vous pouvez également y accéder directement via MyClass.x. x sera partagé entre toutes les instances d'une classe

3
Julia Will

C'est plus un commentaire important: 

class Person {
    static var name = "Static John" // a property of Person 'type'
    var name = "Alex" // a property of Person 'instance'

    var nonStaticName = "Peter"
    static var staticName = "Sara"



    static func statFunc() {
        let x = Person.name // Static John
        let y = name // Static John or Alex?!  Static John!!!!
        let r = staticName // Sara
        let k = nonStaticName // ERROR: instance member 'nonStaticName' cannot be used on type 'Person'
        // The compiler is like: I'm referrting to the `nonStaticName` property of which instance?! There is no instance! Sorry can't do!

    }

    func nonStaticFunc() {
        let x = Person.name // Static John
        let y = name // Static John or Alex?! Alex!!! Because we're in a instance scope...
        let k = nonStaticName // Obviously works
        let r = staticName // ERROR: static member 'staticName' cannot be used on instance of type 'Person'. Person.staticName will work
    }
}

Observations intéressantes: 

Premier: 

static var name = "Static John" // a property of Person 'type'
var name = "Alex" // a property of Person 'instance'

crée pas de conflits. 

Seconde:

Vous ne pouvez jamais utiliser de variables d'instance dans des variables statiques. Vous pouvez utiliser des variables statiques dans fonctions d'instance si vous vous y référez en le préfixant avec le type ie do Person.name,

il est possible d'accéder aux variables statiques dans static fonctions avec ou sans préfixe du type, par exemple Person.staticName ou staticName, les deux fonctionnent 

0
Honey