Swift Language
Variables & Propriétés

Remarques

Créer une variable

Déclarez une nouvelle variable avec var , suivie d'un nom, d'un type et d'une valeur:

var num: Int = 10

Les variables peuvent avoir leurs valeurs modifiées:

num = 20 // num now equals 20

Sauf s'ils sont définis avec let :

let num: Int = 10 // num cannot change

Swift déduit le type de variable, vous n'avez donc pas toujours à déclarer le type de variable:

let ten = 10 // num is an Int
let pi = 3.14 // pi is a Double
let floatPi: Float = 3.14 // floatPi is a Float

Les noms de variables ne sont pas limités aux lettres et aux chiffres - ils peuvent également contenir la plupart des autres caractères Unicode, bien qu'il existe certaines restrictions.

Les noms constants et variables ne peuvent pas contenir de caractères d'espacement, de symboles mathématiques, de flèches, de points de code Unicode à usage privé (ou non valides), ni de caractères de dessin de lignes et de boîtes. Ils ne peuvent pas non plus commencer par un chiffre

_{Source developer.apple.com}

var π: Double = 3.14159
var 🍎🍏: String = "Apples"

Notions de base de la propriété

Les propriétés peuvent être ajoutées à une classe ou struct (techniquement énumérations aussi, voir exemple « Propriétés) calculée ». Celles-ci ajoutent des valeurs associées aux instances de classes / struct:

class Dog {
    var name = ""
}

Dans le cas ci-dessus, les instances de Dog ont une propriété nommée name de type String . La propriété est accessible et modifiée sur les instances de Dog :

let myDog = Dog()
myDog.name = "Doggy" // myDog's name is now "Doggy"

Ces types de propriétés sont considérés comme des propriétés stockées , car ils stockent quelque chose sur un objet et affectent sa mémoire.

Propriétés stockées paresseuses

Les propriétés stockées paresseuses ont des valeurs qui ne sont pas calculées avant leur première utilisation. Ceci est utile pour économiser de la mémoire lorsque le calcul de la variable est coûteux en calcul. Vous déclarez une propriété lazy avec lazy :

lazy var veryExpensiveVariable = expensiveMethod()

Souvent, il est affecté à une valeur de retour d'une fermeture:

lazy var veryExpensiveString = { () -> String in
    var str = expensiveStrFetch()
    str.expensiveManipulation(integer: arc4random_uniform(5))
    return str
}()

Les propriétés stockées paresseuses doivent être déclarées avec var .

Propriétés calculées

Différentes des propriétés stockées, les propriétés calculées sont construites avec un getter et un setter, exécutant le code nécessaire lorsque vous y accédez et définissez. Les propriétés calculées doivent définir un type:

var pi = 3.14

class Circle {
    var radius = 0.0
    var circumference: Double {
        get {
            return pi * radius * 2
        }
        set {
            radius = newValue / pi / 2
        }
    }
}

let circle = Circle()
circle.radius = 1
print(circle.circumference) // Prints "6.28"
circle.circumference = 14
print(circle.radius) // Prints "2.229..."

Une propriété calculée en lecture seule est toujours déclarée avec un var :

var circumference: Double {
    get {
        return pi * radius * 2
    }
}

Les propriétés calculées en lecture seule peuvent être raccourcies pour exclure get :

var circumference: Double {
    return pi * radius * 2
}

Variables locales et globales

Les variables locales sont définies dans une fonction, une méthode ou une fermeture:

func printSomething() {
    let localString = "I'm local!"
    print(localString)
}

func printSomethingAgain() {
    print(localString) // error
}

Les variables globales sont définies en dehors d'une fonction, d'une méthode ou d'une fermeture et ne sont pas définies dans un type (pensez en dehors de tous les crochets). Ils peuvent être utilisés n'importe où:

let globalString = "I'm global!"
print(globalString)

func useGlobalString() {
    print(globalString) // works!
}

for i in 0..<2 {
    print(globalString) // works!
}

class GlobalStringUser {
    var computeGlobalString {
        return globalString // works!
    }
}

Les variables globales sont définies paresseusement (voir exemple "Propriétés paresseuses").

Propriétés du type

Les propriétés de type sont des propriétés sur le type même, pas sur l'instance. Ils peuvent être à la fois des propriétés stockées ou calculées. Vous déclarez une propriété de type avec static :

struct Dog {
    static var noise = "Bark!"
}

print(Dog.noise) // Prints "Bark!"

Dans une classe, vous pouvez utiliser le mot class clé class au lieu de static pour le rendre remplaçable. Cependant, vous ne pouvez appliquer cela que sur les propriétés calculées:

class Animal {
    class var noise: String {
        return "Animal noise!"
    }
}
class Pig: Animal {
    override class var noise: String {
        return "Oink oink!"
    }
}

Ceci est souvent utilisé avec le modèle singleton .

Observateurs de propriété

Les observateurs de propriétés répondent aux modifications apportées à la valeur d'une propriété.

var myProperty = 5 {
    willSet {
        print("Will set to \(newValue). It was previously \(myProperty)")
    }
    didSet {
        print("Did set to \(myProperty). It was previously \(oldValue)")
    }
}
myProperty = 6
// prints: Will set to 6, It was previously 5
// prints: Did set to 6. It was previously 5

• willSet est appelé avant que myProperty soit défini. La nouvelle valeur est disponible en tant que newValue et l'ancienne valeur est toujours disponible en tant que myProperty .
• didSet est appelé après que myProperty soit défini. L'ancienne valeur est disponible sous la forme oldValue et la nouvelle valeur est désormais disponible sous la forme myProperty .

Remarque: didSet et willSet ne seront pas appelés dans les cas suivants:

• Assigner une valeur initiale
• Modifier la variable dans son propre didSet ou willSet

• Les noms de paramètres pour oldValue et newValue de didSet et willSet peuvent également être déclarés pour améliorer la lisibilité:

var myFontSize = 10 {
    willSet(newFontSize) {
        print("Will set font to \(newFontSize), it was \(myFontSize)")
    }
    didSet(oldFontSize) {
        print("Did set font to \(myFontSize), it was \(oldFontSize)")
    }
}

Attention: Bien qu'il soit possible de déclarer des noms de paramètres setter, il faut être prudent de ne pas mélanger les noms:

• willSet(oldValue) et didSet(newValue) sont entièrement légaux, mais vont considérablement perturber les lecteurs de votre code.