Aller au contenu
Encyclopédie informatique Édition 2026

Le langage Swift

Partie 2 sur 5

Niveau de lecture :

4Les bases du langage

4.1let et var

Comme Kotlin, Swift distingue les constantes, déclarées avec let, et les variables, déclarées avec var. Le compilateur conseille d’utiliser let dès qu’une valeur ne change pas. Les types sont déduits de la valeur, et une variable doit toujours être initialisée avant d’être lue : la lecture d’une mémoire au contenu aléatoire, fréquente en C, est impossible (voir les variables).

let ville = "Lyon"              // String, constante
var visiteurs = 0               // Int, modifiable
visiteurs += 1
let prix: Double = 9.5
print("À \(ville), le billet coûte \(prix) euros")

La syntaxe \( … ) insère une valeur dans un texte. Swift vérifie aussi les calculs : un entier qui dépasse sa capacité arrête le programme au lieu de « faire le tour » silencieusement, ce qui évite des erreurs de calcul exploitables.

4.2Collections et boucles

Les trois collections de base sont le tableau (Array), le dictionnaire (Dictionary), qui associe des clés à des valeurs, et l’ensemble (Set), sans doublons (voir les structures de données). Un accès en dehors d’un tableau arrête le programme proprement au lieu de lire la mémoire voisine.

var notes = [12, 7, 15]
notes.append(18)
let capitales = ["France": "Paris", "Gabon": "Libreville"]

for n in notes where n >= 10 {
    print(n)
}
for i in 1...3 { print("Tour \(i)") }      // de 1 à 3 inclus

4.3Fonctions et étiquettes

Une particularité de Swift, héritée de l’Objective-C, est l’étiquette des arguments : à l’appel, chaque argument est précédé d’un nom, ce qui rend les appels lisibles comme des phrases. On peut distinguer le nom utilisé à l’appel et le nom utilisé dans la fonction, ou supprimer l’étiquette avec un tiret bas :

func deplacer(de depart: String, vers arrivee: String, en minutes: Int = 30) -> String {
    "Trajet de \(depart) à \(arrivee) en \(minutes) min"
}

deplacer(de: "Gare", vers: "Musée")             // durée par défaut
deplacer(de: "Gare", vers: "Musée", en: 12)

Une fonction dont le corps est une seule expression renvoie directement sa valeur, sans return. Les fermetures (en anglais closures), de petites fonctions anonymes, s’écrivent entre accolades et s’utilisent beaucoup avec les collections : notes.filter { $0 >= 10 }, où $0 désigne le premier paramètre.

4.4Un switch puissant

L’instruction switch de Swift n’a rien à voir avec celle du C : elle compare des intervalles, des tuples, des motifs, et doit être exhaustive, c’est-à-dire couvrir tous les cas possibles ; elle ne « tombe » pas d’un cas au suivant par oubli d’un break.

switch age {
case ..<12:   print("enfant")
case 12..<18: print("adolescent")
default:      print("adulte")
}

Pour s’exercer

Exercice 1 : constantes et variables

Quelles lignes le compilateur refuse-t-il ?

let tva = 0.2
tva = 0.055
var total: Int
print(total)
var nom = "Léa"
nom = 42
Voir la réponse

Trois lignes sont refusées. tva = 0.055 : tva est une constante, déclarée avec let. print(total) : la variable est lue avant d’avoir reçu une valeur ; en C, on aurait affiché un nombre aléatoire. nom = 42 : nom a été déduit comme String, on ne peut pas y ranger un entier. Ces trois erreurs auraient pu passer inaperçues dans des langages moins stricts.

5Les optionnels

5.1Une valeur ou rien

En Swift, une variable ordinaire contient toujours une valeur. Pour représenter une valeur qui peut manquer, on utilise un optionnel, noté avec un point d’interrogation : String? contient soit un texte, soit nil, qui signifie « rien ». Un optionnel est comme une boîte qu’il faut déballer avant d’en utiliser le contenu, et le compilateur refuse qu’on l’oublie (figure 2).

nom : String? soit "Ana" soit nil (rien) if let nom { … } on n’entre que s’il y a une valeur guard let nom else { return } on sort tout de suite sinon nom ?? "inconnu" valeur par défaut nom! forcer : plantage si nil Une valeur facultative doit être « déballée » avant usage : Swift l’impose dès la compilation.
Figure 2. Déballer un optionnel : trois façons sûres, une façon risquée.

5.2Déballer

let saisie = "42"
let nombre = Int(saisie)          // Int? : la conversion peut échouer

if let nombre {                   // seulement si la conversion a réussi
    print("Le double vaut \(nombre * 2)")
} else {
    print("Ce n'est pas un nombre")
}

func afficherProfil(nom: String?) {
    guard let nom else {          // sortie immédiate si nom est absent
        print("Profil incomplet")
        return
    }
    print("Bonjour \(nom)")       // ici, nom est un String
}

let pseudo = utilisateur.pseudo ?? "Invité"
let longueur = utilisateur.adresse?.ville.count

if let exécute un bloc seulement si la valeur existe ; guard let fait l’inverse : il sort de la fonction si la valeur manque, ce qui évite d’imbriquer les conditions ; l’opérateur ?? fournit une valeur par défaut ; le chaînage optionnel ?. enchaîne des accès qui peuvent chacun échouer, et donne nil dès que l’un d’eux échoue.

Reste le point d’exclamation, nom!, qui force le déballage : si la valeur est absente, le programme s’arrête brutalement. On le réserve aux cas où l’absence serait une erreur de programmation, jamais aux données venues de l’utilisateur ou du réseau.

Pour s’exercer

Exercice 2 : déballer sans risque

On dispose de let saisie: String = champAge.text ?? "". Écrivez le code qui convertit la saisie en âge et affiche « majeur » ou « mineur », ou « âge invalide » si la saisie n’est pas un nombre, sans aucun point d’exclamation.

Voir la réponse

if let age = Int(saisie), age >= 0 {
    print(age >= 18 ? "majeur" : "mineur")
} else {
    print("âge invalide")
}

Int(saisie) renvoie un Int?, qui vaut nil si le texte n’est pas un nombre. Le if let déballe la valeur et, grâce à la virgule, ajoute une seconde condition qui écarte les nombres négatifs. Écrire Int(saisie)! aurait fait planter l’application dès qu’un utilisateur tape une lettre.