Dans cette fiche :
Avec Swift, les mots-clés var et let permettent de déclarer respectivement des variables et des constantes.
var nom = "Annie"
let iterations = 10
Lorsque le type peut être déduit à partir de la valeur d'initialisation, Swift effectue automatiquement une inférence de type. Il n’est donc pas nécessaire de préciser le type, comme dans l'exemple précédent.
Si désiré, il est tout de même possible de spécifier le type.
var nom: String = "Annie"
let iterations: Int = 10
Dans le cas où le type de la variable ne peut pas être déterminé automatiquement, il est obligatoire de le préciser.
var nom: String
var montant: Decimal = 10.99 // sans le type, la variable aurait été de type Double
Les types de base en Swift sont :
Fait intéressant : on peut convertir une chaîne de caractères en tableau comme suit :
let tableauLettres = Array(nom) // ["A", "n", "n", "i", "e"]
Si vous développez une application qui doit travailler avec des valeurs monétaires, le type par excellence est Decimal.
Decimal évite les erreurs d’arrondi associées aux nombres à virgule flottante.
let prix: Decimal = 69.44
Si on initialise une variable de type Decimal à partir d'une chaîne, il faut tenir compte que le résultat pourrait être nil si la chaîne n'était pas conforme.
Dans cet exemple, il est sécuritaire d'utiliser l'opérateur de déballage forcé (!) puisque la chaîne est codée en dur et qu'on est certains que la valeur pourra être convertie en Decimal.
let prix = Decimal(string: "69.44")!
Dans d'autres contextes, il est préférable d'utiliser if let.
if let prix = Decimal(string: prixSaisi) {
// ici, on a l'assurance que le prix est valide.
} else {
message = "Veuillez spécifier un prix valide (ex : 12.50)"
}
Notez que pour convertir une chaîne en Decimal, ceci ne fonctionne pas car la structure Decimal n'a pas de constructeur avec un paramètre non nommé de type String.
let montantTexte = "12.25"
if let montantDecimal = {
...
}
Pour que ça fonctionne, il faut préciser que le nom du premier paramètre est string.
let montantTexte = "12.25"
if let montantDecimal = Decimal(string: montantTexte) {
...
}
Le type CGFloat est très utilisé dans le développement d’interfaces graphiques. Il représente un nombre à virgule flottante optimisé pour les calculs graphiques.
SwiftUI utilise CGFloat pour :
let largeur: CGFloat = 120
let opacite: CGFloat = 0.5
Techniquement, CGFloat est très proche de Double. Son avantage est qu'il s'adapte automatiquement à l'architecture de l'appareil (32 ou 64 bits).
Dans cet exemple, les paramètres pour .frame() et pour .opacity() sont automatiquement convertis en CGFloat.
Circle()
.frame(width: 100, height: 100)
.opacity(0.5)
Par contre, si les valeurs étaient lues dans des variables, il faudrait s'assurer que le type de la variable est correctement spécifié ou qu'il a été correctement inféré.
let largeur = 100 // ici, le type inféré est Int
...
Circle()
// erreur : Cannot convert value of type 'Int' to expected argument type 'CGFloat'
Pour régler ce problème, plusieurs approches sont possibles :
let largeur: CGFloat = 100
...
Circle()
.frame(width: largeur)
ou
let largeur = 100
...
Circle()
.frame(width: CGFloat(largeur))
ou encore
let largeur = 100.0 // ici, le type inféré est Double
...
Circle()
.frame(width: largeur) // SwiftUI est souvent capable de faire une conversion automatique entre Double et CGFloat
Les mots-clés var et let permettent également de déclarer des instances de structures et de classes.
Petite mise en garde : si une instance d'une structure est déclarée avec let, l’instance devient entièrement immuable.
L'instance ainsi que toutes ses propriétés ne pourront pas être réassignées.
let monInstance = MaStructure()
Ce code générera l'erreur « Cannot assign to property: 'monInstance' is a 'let' constant ».
Notez que ce comportement est différent de ce qu'on retrouve dans d'autres langages, par exemple JavaScript.
Les classes réagissent différemment.
let monInstance = MaClasse()
monInstance.unePropriete = "abc"
Lorsqu'on a une instance d'une classe, il est possible de modifier ses propriétés même si l'instance a été déclarée avec let, à condition que la propriété ait elle-même été déclarée avec var dans la classe.
Quand on déclare une variable, il est possible de lui donner un type opaque, c'est-à-dire de ne pas spécifier le type précis d'une variable.
Ceci sera fait à l'aide du mot-clé some suivi d'un protocole.
var body: some View {
...
}
Ici, on voit que la variable body est d'un type qui répond au protocole View mais on ne connaît pas son type précis. Ce pourrait être un Text, un VStack, etc.
Sans entrer dans les détails techniques, disons que les types opaques permettent de régler une problématique en n'exposant pas le type précis d'une variable.
Les variables et constantes qui doivent être utilisées dans toute une vue seront déclarées directement dans la structure de la vue, avant le body.
Dans l'exemple qui suit, le contexte dicte qu'on doit utiliser une constante.
struct ContentView: View {
let nom: String = "Annie"
var body: some View {
...
}
}
Il est possible de déclarer les variables et constantes avec une portée plus petite, par exemple direction dans l'action d'un bouton.
La variable ou constante n'existera pas en dehors du code de ce bouton.
Button(action: {
var nom: String = "Annie"
...
}) {
Text("Vérifier")
}
« The Basics - Constants and Variables ». Swift. https://docs.swift.org/swift-book/LanguageGuide/TheBasics.html#ID310
« Swift Integer Quick Guide ». Use Your Loaf. https://useyourloaf.com/blog/swift-integer-quick-guide/
« Swift – Integer, Floating-Point Numbers ». Geeks for Geeks. https://www.geeksforgeeks.org/swift-integer-floating-point-numbers/
« Constants, Variables and Types ». Dimitri Racordon. https://kyouko-taiga.github.io/swift-thoughts/tutorial/chapter-1/
▼Publicité
