Comment réussir un entretien Swift : top questions et réponses

Introduction

Un entretien pour un poste de développeur iOS/macOS ne se limite pas à vérifier vos connaissances des frameworks UIKit ou SwiftUI. Avant tout, l'employeur évalue votre compréhension du langage Swift : sa syntaxe, ses particularités de gestion de la mémoire, son fonctionnement avec la multithreading et son système de typage. Même si vous écrivez des applications avec assurance, sans une base théorique solide, il est facile d'échouer à un entretien technique.

Dans cet article, nous avons rassemblé les questions les plus fréquemment posées lors des entretiens Swift en 2025. Chaque question est accompagnée d'une explication détaillée et d'un exemple de code. Ce contenu sera utile aussi bien aux juniors qu'aux développeurs expérimentés souhaitant rafraîchir leurs connaissances.

1. Types optionnels (Optionals) et sécurité

Pourquoi Swift utilise-t-il les Optionals ?

Swift est un langage à typage strict, et les types optionnels sont sa fonctionnalité clé pour travailler en toute sécurité avec nil. Contrairement à Objective-C, où nil est simplement un pointeur nul, en Swift, Optional est une énumération (enum) avec deux cas : none (nil) et some(Wrapped). Cela oblige le développeur à gérer explicitement l'absence de valeur, évitant ainsi les crashes.

Comment extraire une valeur d'un Optional ?

Il existe plusieurs méthodes :

• Force unwrapping — l'opérateur !. À utiliser uniquement lorsque vous êtes absolument certain que la valeur n'est pas nil.
• Optional binding — la construction if let ou guard let.
• Nil-coalescing operator — ?? pour définir une valeur par défaut.

var name: String? = "Alice"

// Force unwrapping (dangereux !)print(name!)

// Optional bindingif let unwrappedName = name {    print("Hello, \\(unwrappedName)")}

// Nil-coalescinglet displayName = name ?? "Guest"print(displayName)

Que sont les Implicitly Unwrapped Optionals (IUO) ?

Ce sont des types optionnels qui se déballent automatiquement lors de l'accès. Ils sont déclarés avec ! après le type. Utilisés principalement pour les propriétés qui sont initialisées après init (par exemple, IBOutlet dans UIKit). Cependant, dans Swift moderne (5.x), les IUO se comportent comme des Optionals ordinaires, et le compilateur avertit des risques.

2. Gestion de la mémoire : ARC et cycles de références fortes

Comment fonctionne ARC en Swift ?

Automatic Reference Counting (ARC) est un mécanisme de comptage de références. Chaque instance de classe possède un compteur de références. Lorsque le compteur tombe à zéro, l'objet est supprimé de la mémoire. ARC fonctionne uniquement avec les reference types (classes, closures). Les value types (structures, énumérations) sont stockés sur la pile et gérés par copie.

Qu'est-ce qu'un cycle de références fortes (retain cycle) ?

Un cycle se produit lorsque deux objets se référencent mutuellement via des références fortes, et ARC ne peut pas les libérer. Cela entraîne une fuite de mémoire. La solution consiste à utiliser des références faibles (weak) ou non possédées (unowned).

class Person {    let name: String    var apartment: Apartment?    init(name: String) { self.name = name }    deinit { print("\\(name) deallocated") }}

class Apartment {    let unit: String    weak var tenant: Person?  // weak — empêche le cycle    init(unit: String) { self.unit = unit }    deinit { print("Apartment \\(unit) deallocated") }}

var john: Person? = Person(name: "John")var unit4A: Apartment? = Apartment(unit: "4A")

john?.apartment = unit4Aunit4A?.tenant = john

john = nilunit4A = nil// Les deux objets seront libérés

Quand utiliser weak et quand utiliser unowned ?

• weak — toujours optionnel, devient automatiquement nil lorsque l'objet est libéré. Utilisé lorsque la durée de vie de la référence peut être plus courte que celle du propriétaire.
• unowned — non-optionnel, suppose que l'objet vivra aussi longtemps ou plus longtemps. Dangereux : si l'objet est libéré, y accéder