Swift : qu'est-ce que c'est, syntaxe et concepts clés du langage

Qu'est-ce que Swift ?

Swift est un langage de programmation multiparadigme développé par Apple pour iOS, macOS, watchOS, tvOS et visionOS. Les objectifs clés du langage sont : la sécurité, la rapidité et l'expressivité syntaxique. Swift utilise le compilateur LLVM et génère du code machine optimisé, comparable en performance au C++.

Depuis sa sortie en 2014, Swift a connu 6 versions majeures. Swift 6 (2024) a introduit un modèle complet de sécurité contre les data races via un contrôle strict de l'isolation du code concurrent. Selon GitHub Octoverse 2025, Swift fait partie du top 10 des langues à la croissance communautaire la plus rapide, dépassant Rust et Kotlin en vitesse d'adoption sur les plateformes Apple.

Swift est open source et multiplateforme — le code source est publié sur GitHub (Swift Open Source). Outre les plateformes Apple, Swift est utilisé sur Linux et Windows pour le développement serveur (Vapor, Hummingbird), bien que son domaine principal reste le développement mobile et desktop dans l'écosystème Apple.

Pourquoi Swift a remplacé Objective-C

Les principales raisons de la transition : Swift élimine des classes entières d'erreurs possibles dans Objective-C. La sécurité de type empêche les incompatibilités de type à la compilation. Les Optionals éliminent les déréférencements nil. ARC est intégré depuis le premier jour, contrairement à MRC/ARC dans Objective-C. La syntaxe de Swift est plus courte et plus lisible — les études montrent une réduction de 30 à 40 % du volume de code par rapport à Objective-C pour des tâches équivalentes.

Syntaxe et constructions de base

La syntaxe de base de Swift combine des constructions familières de type C avec des éléments de langages fonctionnels. Les variables sont déclarées avec var, les constantes avec let. Le compilateur utilise l'inférence de types, donc l'annotation de type explicite n'est nécessaire qu'en cas d'ambiguïté.

import Foundation

// Constantes et variables
let name = "Swift"
var version = 6.0
var count: Int = 42

// Fonctions avec paramètres par défaut
func greet(person: String, greeting: String = "Hello") -> String {
    return "\(greeting), \(person)!"
}

// Guard-let pour sortie anticipée
func parse(input: String?) -> Int {
    guard let value = input, let number = Int(value) else {
        return 0
    }
    return number
}

Switch et filtrage par motif sont plus puissants en Swift qu'en C et Kotlin. Switch prend en charge la correspondance avec des tuples, des intervalles, des conditions where et la liaison de valeurs. Le compilateur vérifie la couverture exhaustive de tous les cas — l'absence de default n'est pas une erreur si toutes les valeurs possibles sont couvertes.

let point = (x: 3, y: -1)

switch point {
case (0, 0):
    print("Origine")
case let (x, y) where x == y:
    print("X est égal à Y")
case let (x, y) where abs(y) > x:
    print("La valeur absolue de Y est supérieure à X")
default:
    print("Point (\("point.x), \(point.y))")
}

Optionals et travail sécurisé avec nil

Les Optionals sont un concept central de Swift qui résout le problème des références nulles au niveau du système de types. Optional est une énumération avec deux cas : .none (nil) et .some(Wrapped). Le compilateur interdit d'utiliser un Optional sans vérification explicite, ce qui élimine toute une classe d'erreurs d'exécution.

var optionalString: String? = "Hello"
optionalString = nil  // autorisé

// Optional Binding — extraction sécurisée
if let text = optionalString {
    print("Texte : \("text)")
} else {
    print("Valeur absente")
}

// Optional Chaining — accès sécurisé aux propriétés
let length = optionalString?.count ?? 0

// Opérateur nil-coalescing
let greeting = optionalString ?? "Default"

Optional Chaining avec l'opérateur ?. permet d'appeler des méthodes et d'accéder aux propriétés d'une valeur optionnelle en toute sécurité. Si la chaîne est interrompue par nil, le résultat de l'expression entière est nil. Nil-coalescing (??) fournit une valeur par défaut et est largement utilisé dans le code d'interface utilisateur pour afficher du texte de substitution.

Protocoles et extensions

Les protocoles en Swift définissent un contrat — un ensemble de propriétés et de méthodes. Contrairement aux interfaces Java, les protocoles Swift peuvent avoir des implémentations par défaut via les extensions de protocole (protocol extensions). C'est la base de la Programmation Orientée Protocoles, l'approche recommandée par Apple plutôt que l'héritage de classes.

protocol NamedEntity {
    var name: String { get }
    func description() -> String
}

// Implémentation par défaut via extension
extension NamedEntity {
    func description() -> String {
        return "Entity: \(name)"
    }
}

// Conformité via extension
extension String: NamedEntity {
    var name: String { return self }
}

Les extensions de protocole permettent d'ajouter des méthodes à un protocole sans modifier chaque type conforme. C'est particulièrement utile pour ajouter des utilitaires courants : map, filter, reduce pour Sequence, ou Codable pour la sérialisation JSON. Apple a construit de nombreux frameworks (SwiftUI, Combine) sur des protocoles avec extensions.

Closures et chaînes fonctionnelles

Les closures en Swift sont des fonctions anonymes qui capturent des variables du contexte externe. Syntaxiquement, les closures ressemblent aux lambdas en Kotlin mais avec une syntaxe plus flexible : trailing closure, noms d'arguments abrégés ($0, $1) et autoclosures.

// Closure avec capture de contexte
let numbers = [5, 3, 8, 1, 9]

// Trailing closure syntax
let sorted = numbers.sorted { $0 < $1 }

// Chaîne fonctionnelle
let result = numbers
    .filter { $0 > 3 }
    .map { $0 * 2 }
    .reduce(0, +)

// Closure comme paramètre de fonction
func performAsync(completion: @escaping (Result<Data, Error>) -> Void) { }

Les closures @escaping sont utilisées lorsque la closure s'exécute après le retour de la fonction — typiquement pour les requêtes réseau et les opérations asynchrones. @autoclosure encapsule automatiquement une expression dans une closure, utilisé dans assert et la logique de court-circuit.

Structures et classes : comparaison

Le choix entre struct et class est l'une des premières décisions lors de la conception d'un modèle Swift. Apple recommande d'utiliser struct par défaut (type valeur) et de passer à class (type référence) uniquement lorsque l'héritage ou l'identité de référence est nécessaire.

Les types valeur (struct) sont plus sûrs dans les environnements multithreads — chaque thread obtient une copie indépendante. Les types référence (class) sont nécessaires pour travailler avec UIKit (UIView, UIViewController), où l'identité de référence et l'héritage des classes système sont requis.

Gestion de la mémoire ARC

ARC (Automatic Reference Counting) est le système de gestion mémoire de Swift pour les types référence. Le compilateur insère des appels retain/release à l'exécution, en suivant le nombre de références fortes vers un objet. Lorsque le compteur atteint zéro, l'objet est immédiatement libéré.

Le principal problème d'ARC est les cycles de rétention (retain cycles). Lorsque deux objets maintiennent des références fortes l'un vers l'autre, la mémoire n'est jamais libérée. La solution est les références faibles (weak, deviennent automatiquement nil à la libération) et les références unowned (garantissent que l'objet est vivant).

class ProfileViewController: UIViewController {
    var onLogout: (() -> Void)?
    
    func setupHandler() {
        // [weak self] empêche le retain cycle
        onLogout = { [weak self] in
            guard let self else { return }
            self.dismiss(animated: true)
        }
    }
}

Pour prévenir les cycles de rétention dans les closures, utilisez [weak self] avec guard let self = self else { return }. Cette règle est particulièrement importante dans UIKit, où le ViewController maintient des références fortes vers ses propriétés et les closures à l'intérieur de ces propriétés référencent le ViewController.