Préparation entretien iOS

Questions d'entretien iOS

20 questions fréquemment posées en entretien iOS. Le développement iOS est un domaine très recherché axé sur les apps Swift, SwiftUI et UIKit, avec des sujets de lifecycle, concurrence, réseau, stockage, performance, tests et publication sur l'App Store. Les questions couvrent plusieurs niveaux, et vous pouvez vous entraîner à y répondre à voix haute dans notre simulateur d'entretien.

Commencer un entretien IA iOSAucune carte bancaire requise. 1 session gratuite disponible.
Préparation aux entretiens techniques en anglaisUn mode où les non-natifs peuvent s'entraîner à passer des entretiens techniques.

Questions pour débutants

1Qu’est-ce que `@Binding` dans SwiftUI et en quoi diffère-t-il de `@State` ?

`@State` fournit un stockage dont la vue est responsable. `@Binding` permet de lire et d’écrire une valeur gérée ailleurs, par exemple en transmettant `$isEnabled` à une vue enfant. La liaison ne crée pas une deuxième copie de l’état. Une modification est répercutée dans la source et SwiftUI actualise les vues qui en dépendent.

struct ParentView: View {
    @State private var isOn: Bool = false
    
    var body: some View {
        VStack {
            Text("Switch is: \(isOn ? "ON" : "OFF")")
            // Pass binding using $ prefix
            CustomToggle(isOn: $isOn)
        }
    }
}

struct CustomToggle: View {
    @Binding var isOn: Bool
    
    var body: some View {
        Button("Toggle") {
            isOn.toggle() // Modifies parent's @State
        }
    }
}
Essayer de répondre à cette question avec un coach IA

2Quel est le rôle d’un profil d’approvisionnement lors de la publication d’une application iOS ?

Un profil signé par Apple encadre l’autorisation de signer et de distribuer l’application. Il précise l’App ID, qui comprend un préfixe et l’identifiant du paquet, les certificats de signature acceptés, les droits autorisés et la période de validité. La signature de l’application indique les droits qu’elle revendique effectivement. Les profils de développement et de distribution ad hoc identifient les appareils autorisés par leur identifiant unique (UDID). Un profil App Store ne contient pas cette liste, car la distribution se fait par la boutique.

Provisioning Profile (.mobileprovision)
├── App ID / Bundle Identifier (e.g., com.example.app)
├── Certificates (Public key / Distribution Certificate)
├── Entitlements (e.g., Push Notifications, Associated Domains)
└── Device UDIDs (Present for Development/Ad-Hoc; omitted for App Store distribution)
Essayer de répondre à cette question avec un coach IA

3Que signifie exécuter du travail en arrière-plan dans une application iOS, et quelles limites de base le système impose-t-il ?

Il s’agit d’exécuter du code lorsque l’application n’est plus active à l’écran ou visible. Lorsqu’un utilisateur quitte l’application, elle passe du premier plan actif à l’arrière-plan, puis rapidement à l’état suspendu : son exécution est interrompue, mais sa mémoire reste en mémoire vive (RAM). Pour préserver batterie, réactivité et ressources, iOS contrôle strictement cette exécution. Par défaut, seule une courte période déterminée par le système est disponible après le passage en arrière-plan. Une demande de temps d’exécution fini ou une interface de programmation (API) d’arrière-plan appropriée peut accorder du temps supplémentaire, sans durée fixe garantie. Le système réduit les priorités processeur et réseau et peut terminer les applications suspendues en cas de pression mémoire.

import UIKit

NotificationCenter.default.addObserver(
    forName: UIApplication.didEnterBackgroundNotification,
    object: nil,
    queue: .main
) { _ in
    print("App entered background. Code execution will pause soon unless extended.")
}
Essayer de répondre à cette question avec un coach IA

4Dans Combine, en quoi un `Publisher` diffère-t-il d’un `Subscriber` dans un flux iOS ?

Un `Publisher` produit des valeurs de type `Output` et peut signaler une fin normale ou une erreur de type `Failure`. Il peut représenter des réponses réseau, des notifications ou des saisies. Un `Subscriber` reçoit un abonnement, demande un nombre d’éléments et traite les valeurs et la fin. Il peut par exemple mettre à jour l’interface ou enregistrer les données.

import Combine

// Publisher: emits a sequence of integers
let numberPublisher = [1, 2, 3].publisher

// Subscriber: consumes the emitted integers
let cancellable = numberPublisher.sink(
    receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("Finished")
        case .failure(let error):
            print("Error: \(error)")
        }
    },
    receiveValue: { value in
        print("Received: \(value)")
    }
)
Essayer de répondre à cette question avec un coach IA

5Que signifient `async` et `await` en Swift ? Comment appeler une API asynchrone dans une application iOS ?

Une fonction `async` peut suspendre son exécution. `await` indique un point de suspension possible : si la tâche attend, le thread peut faire un autre travail et la tâche reprendra ensuite. Une fonction `async` ne déplace pas automatiquement un calcul synchrone vers un autre thread. Appelez l’API avec `await`, ou `try await` si elle peut lever une erreur, depuis une autre fonction asynchrone ou depuis une tâche créée avec `Task { ... }`. Le code peut rester écrit dans l’ordre logique sans imbriquer des rappels.

func fetchUserData(from url: URL) async throws -> User {
    let (data, response) = try await URLSession.shared.data(from: url)
    
    guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
        throw URLError(.badServerResponse)
    }
    
    return try JSONDecoder().decode(User.self, from: data)
}
Essayer de répondre à cette question avec un coach IA

6Quand utiliser `UserDefaults` dans une application iOS et quelles données conserver ailleurs ?

Utilisez `UserDefaults` pour des préférences et indicateurs légers entre les lancements, comme le thème ou `hasSeenOnboarding`. Il accepte des types compatibles avec les listes de propriétés, dont les chaînes, nombres, booléens, dates, données, tableaux et dictionnaires. Gardez les mots de passe, clés et jetons dans le trousseau. Pour des médias, documents ou gros jeux de données, choisissez des fichiers ou une base. `UserDefaults` est conçu pour des réglages de petite taille et ne fournit pas les garanties d’un coffre de secrets.

// Saving simple preference values
UserDefaults.standard.set(true, forKey: "hasCompletedOnboarding")
UserDefaults.standard.set("dark", forKey: "preferredTheme")

// Reading values back
let hasCompletedOnboarding = UserDefaults.standard.bool(forKey: "hasCompletedOnboarding")
let theme = UserDefaults.standard.string(forKey: "preferredTheme") ?? "system"
Essayer de répondre à cette question avec un coach IA

7Qu’est-ce que le comptage automatique de références (ARC) en Swift ? Comment gère-t-il la durée de vie d’une instance ?

Le compilateur Swift insère et optimise des opérations de gestion des références. À l’exécution, une instance de classe reste vivante tant qu’elle a des références fortes. Lorsque la dernière disparaît, son `deinit` s’exécute avant la libération. Le comptage est continu et ne repose pas sur un balayage périodique. Un cycle de références fortes peut donc maintenir des instances en vie même si le reste du programme n’en a plus besoin.

class User {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name) initialized")
    }
    deinit {
        print("\(name) deallocated")
    }
}

var ref1: User? = User(name: "Alice") // count = 1
var ref2: User? = ref1               // count = 2

ref1 = nil                           // count = 1
ref2 = nil                           // count = 0 -> deinit called
Essayer de répondre à cette question avec un coach IA

8Comment effectuer une requête HTTP GET avec `URLSession` dans une application iOS ?

Créez une `URL`. Dans un contexte asynchrone, utilisez `let (data, response) = try await URLSession.shared.data(from: url)`. Avec un rappel, créez une tâche par `URLSession.shared.dataTask(with: url) { data, response, error in ... }` et lancez-la avec `resume()`. Gérez les erreurs de transport, vérifiez le code de statut de `HTTPURLResponse` avant de traiter les données, puis effectuez les mises à jour de l’interface sur l’acteur principal.

guard let url = URL(string: "https://api.example.com/items") else { return }

let task = URLSession.shared.dataTask(with: url) { data, response, error in
    if let error = error {
        print("Network error: \(error.localizedDescription)")
        return
    }
    
    guard let httpResponse = response as? HTTPURLResponse, (200...299).contains(httpResponse.statusCode) else {
        print("Server error or invalid status code")
        return
    }
    
    if let data = data {
        DispatchQueue.main.async {
            // Update UI on main thread
        }
    }
}
task.resume()
Essayer de répondre à cette question avec un coach IA

9Qu'est-ce qu'Instruments dans Xcode, et comment l'utiliseriez-vous pour analyser un problème simple de performances dans une application iOS ?

Instruments est l’outil de profilage d’Apple. Depuis **Product > Profile**, choisissez une mesure adaptée, comme Time Profiler pour le processeur ou Allocations et Leaks pour la mémoire. Enregistrez le parcours qui pose problème sur un appareil représentatif. Examinez l’arbre d’appels et les piles qui concentrent le coût. Utilisez la trace pour localiser le goulot, puis reproduisez le même parcours après modification pour mesurer le gain.

1. In Xcode, select Product -> Profile (Builds with Release optimizations).
2. Select the 'Time Profiler' template.
3. Click Record and perform the sluggish action in the app.
4. Stop recording.
5. Inspect the Call Tree tab:
   - Enable 'Separate by Thread' and 'Hide System Libraries'.
   - Trace the heaviest call stack on the Main Thread to identify the blocking function.
Essayer de répondre à cette question avec un coach IA

10À quoi sert le service de notifications push d’Apple (APNs) pour une application iOS ?

APNs achemine les notifications distantes des serveurs d’une application vers les appareils Apple. Après l’enregistrement, l’application reçoit un jeton opaque qui l’identifie auprès d’APNs sur cet appareil et le transmet à son serveur. Le serveur envoie à APNs une requête HTTP/2 avec le jeton et le contenu de la notification. Selon le type, les autorisations et l’état du système, iOS peut afficher une alerte ou donner à l’application une occasion de travailler en arrière-plan. La livraison n’est pas garantie.

[Provider Server] ---> (HTTP/2 Request + Device Token + Payload) ---> [APNs]
                                                                           |
                                                               (Persistent APNs Connection)
                                                                           v
                                                                    [iOS Device / App]
Essayer de répondre à cette question avec un coach IA

Questions intermédiaires

11Comment intégrer les nouvelles actualités en tête d’un UITableView sans doublons d’identifiants ?

Construire la liste dans l’ordre reçu, puis ajouter les anciennes entrées aux identifiants non vus. Appliquer sur l’acteur principal et terminer le contrôle de rafraîchissement en réussite comme en échec.

Essayer de répondre à cette question avec un coach IA

12Quelle différence entre un acteur Swift et une classe ordinaire importe lorsque plusieurs tâches partagent des données modifiables ?

Une classe partagée ne protège pas spontanément ses propriétés. L’acteur isole son état et son exécuteur coordonne les accès isolés. Franchir la frontière demande généralement une opération asynchrone, ce qui évite de verrouiller chaque propriété. Il n’a pas de thread dédié et une méthode async entière n’est pas atomique. À un await, une autre tâche peut modifier l’état. Je revérifie les hypothèses à la reprise, regroupe les modifications d’invariants en sections synchrones et utilise versions ou transitions à travers les suspensions. Les membres nonisolated et les valeurs transférées ont leurs propres contraintes. L’ordre métier reste à concevoir.

Essayer de répondre à cette question avec un coach IA

13Comment tester chargement, succès et annulation d’un modèle de vue iOS sans appeler la vraie API ?

J’injecte un faux service conforme à un petit protocole, dont le test contrôle la réponse async. Je lance le chargement, vérifie l’état, termine avec données ou erreur puis contrôle le résultat et les données conservées. Pour l’annulation je vérifie l’arrêt de la tâche, l’indicateur selon le contrat et l’absence d’erreur ordinaire sauf intention contraire. Une réponse tardive permet de prouver qu’une requête obsolète n’écrase pas une nouvelle sélection. Je respecte l’isolation de l’acteur et utilise synchronisation explicite ou horloge contrôlée, sans pauses arbitraires. Je couvre chargements répétés, désallocation et sortie d’écran, en testant le comportement observable sans réseau ni identifiants.

Essayer de répondre à cette question avec un coach IA

14Comment construiriez-vous un pipeline Combine pour un champ de recherche textuel qui temporise les saisies (debounce), ignore les doublons, effectue une requête réseau et met à jour l'UI (User Interface) en toute sécurité ?

Appliquez à `$queryText` une temporisation, par exemple `.debounce(for: .milliseconds(300), scheduler: RunLoop.main)`, et `removeDuplicates()`. Transformez chaque terme retenu en publieur de requête et utilisez `switchToLatest()` : lorsqu’un nouveau publieur arrive après la temporisation, l’ancien abonnement est annulé. Pour ne jamais afficher un résultat d’une saisie déjà dépassée, vérifiez aussi l’identité de la requête au moment de publier l’état. Traitez les erreurs dans le publieur interne avec `catch`, par exemple pour émettre un état d’erreur. Appliquez `receive(on: DispatchQueue.main)` avant la mise à jour de l’interface et conservez l’abonnement pendant la durée voulue.

import Combine
import Foundation

class SearchViewModel: ObservableObject {
    @Published var query: String = ""
    @Published var searchResults: [String] = []
    private var cancellables = Set<AnyCancellable>()
    
    init() {
        $query
            .debounce(for: .milliseconds(300), scheduler: RunLoop.main)
            .removeDuplicates()
            .map { query -> AnyPublisher<[String], Never> in
                guard !query.trimmingCharacters(in: .whitespaces).isEmpty else {
                    return Just([]).eraseToAnyPublisher()
                }
                return self.performSearch(query)
                    .catch { _ in Just([]) }
                    .eraseToAnyPublisher()
            }
            .switchToLatest()
            .receive(on: DispatchQueue.main)
            .assign(to: &$searchResults)
    }
    
    private func performSearch(_ term: String) -> AnyPublisher<[String], Error> {
        let url = URL(string: "https://api.example.com/search?q=\(term)")!
        return URLSession.shared.dataTaskPublisher(for: url)
            .map(\.data)
            .decode(type: [String].self, decoder: JSONDecoder())
            .eraseToAnyPublisher()
    }
}
Essayer de répondre à cette question avec un coach IA

15Comment utiliseriez-vous async/await et l'annulation de `Task` en Swift pour implémenter un écran qui charge des données depuis le réseau et évite de mettre à jour l'interface utilisateur (UI, User Interface) après que l'utilisateur a quitté l'écran ?

Exposez un chargement `async` et liez la tâche à l’écran. Dans UIKit, conservez `var loadTask: Task<Void, Never>?` et annulez-la au départ de l’écran ou avant un nouveau chargement. Dans SwiftUI, `.task` ou `.task(id:)` lie cette annulation à la disparition ou au changement d’identifiant. Gérez séparément l’annulation et les autres erreurs. Après les opérations suspendues, vérifiez l’annulation et, si une demande peut en remplacer une autre, comparez son identifiant avec celui qui est encore actif. Appliquez les résultats sur `@MainActor` ou via `await MainActor.run`.

@MainActor
final class UsersViewController: UIViewController {
    private var loadTask: Task<Void, Never>?
    private let service: UserService

    override func viewDidLoad() {
        super.viewDidLoad()
        loadUsers()
    }

    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        loadTask?.cancel()
    }

    private func loadUsers() {
        loadTask?.cancel()
        loadingView.isHidden = false

        loadTask = Task { [weak self] in
            do {
                let users = try await self?.service.fetchUsers() ?? []
                try Task.checkCancellation()

                guard let self else { return }
                self.loadingView.isHidden = true
                self.tableModel = users
                self.tableView.reloadData()
            } catch is CancellationError {
                // User navigated away or a new load replaced this one; do not update UI.
            } catch {
                guard let self else { return }
                self.loadingView.isHidden = true
                self.showError(error)
            }
        }
    }
}
Essayer de répondre à cette question avec un coach IA

16Comment choisiriez-vous entre UserDefaults, Keychain, fichiers, SQLite et Core Data pour différents types de données applicatives ?

Le choix dépend de la sensibilité, du volume, des relations, des requêtes et du cycle de sauvegarde. Keychain convient aux jetons, mots de passe et clés : il chiffre le stockage et applique des contrôles d’accès. Les modèles biométriques restent gérés par le système et ne sont pas exposés aux applications. Keychain ne protège pas contre du code disposant des accès autorisés de l’application ; la persistance après réinstallation ne constitue pas un contrat de stockage. UserDefaults convient aux petites préférences et indicateurs non sensibles, comme hasCompletedOnboarding ou le thème, pas aux gros jeux de données, médias ou jetons sensibles. Le système de fichiers convient aux fichiers distincts et gros objets binaires, comme images, audio et PDF. Documents contient les fichiers destinés à l’utilisateur et sauvegardés dans iCloud ; Caches les contenus supprimables et retéléchargeables ; Application Support les fichiers persistants internes. SQLite convient aux données structurées tabulaires nécessitant requêtes indexées rapides, opérations en masse ou partage multiplateforme sans le coût d’un graphe d’objets. Core Data ou SwiftData convient aux graphes complexes avec relations, suivi des changements, chargement différé, annulation et intégration UIKit avec NSFetchedResultsController ou SwiftUI avec @Query.

- Auth tokens / API keys          -> Keychain (Hardware-backed encrypted store)
- App settings / UI flags         -> UserDefaults (Lightweight key-value, non-sensitive)
- Downloaded videos / PDFs        -> File System (Documents / Caches directory)
- 50k items with complex queries   -> SQLite / Core Data / SwiftData (Indexed, relationship-aware)
Essayer de répondre à cette question avec un coach IA

17Comment choisir entre une capture forte, `[weak self]` et `[unowned self]` dans les rappels d’un écran UIKit ?

Si le contrôleur possède le modèle de vue qui conserve le rappel, une capture forte du contrôleur boucle la chaîne de propriété. Utilisez `[weak self]` si le rappel peut survivre à l’écran, puis gérez le cas `nil`. `[unowned self]` exige une garantie de durée de vie à chaque appel. Un accès après libération provoque une erreur d’exécution. Une capture forte convient à une fermeture non échappante ou brève, si le maintien temporaire de l’objet est voulu et qu’aucun cycle durable ne se forme.

final class ProfileViewController: UIViewController {
    private let viewModel: ProfileViewModel

    init(viewModel: ProfileViewModel) {
        self.viewModel = viewModel
        super.init(nibName: nil, bundle: nil)
    }

    required init?(coder: NSCoder) { fatalError() }

    override func viewDidLoad() {
        super.viewDidLoad()
        
        // VM stores the callback -> capture weak self to break retain cycle
        viewModel.onDataUpdated = { [weak self] state in
            guard let self else { return }
            self.updateUI(with: state)
        }
    }

    private func updateUI(with state: ProfileState) { /* Update views */ }
}
Essayer de répondre à cette question avec un coach IA

Questions avancées

18Comment introduire SwiftUI écran par écran dans une grande application UIKit ?

Je choisis un écran délimité aux entrées et sorties claires et l’héberge dans UIHostingController en conservant navigation et cycle de vie UIKit. La logique métier et les dépôts restent indépendants, avec un propriétaire explicite par état. Pour un contrôle ou contrôleur UIKit dans SwiftUI, j’emploie UIViewRepresentable ou UIViewControllerRepresentable et au besoin un coordinateur pour les rappels. Je vérifie navigation, fermeture, focus, accessibilité, thèmes et versions compatibles. Je teste comportement et transitions, compare apparence et performances et garde un point d’entrée réversible si nécessaire. Je répète sans dupliquer les sources de vérité.

Essayer de répondre à cette question avec un coach IA

19Comment déployer une mise à jour iOS à fort trafic qui modifie à la fois une base locale et l’API serveur ?

Déployez d’abord une API compatible avec les anciennes versions, puis testez les montées depuis toutes les versions encore utilisées. Faites les migrations locales de façon transactionnelle et reprenable, hors du thread principal si possible. Préservez les données et mesurez l’issue de la migration au lancement. Livrez la fonctionnalité désactivée, puis activez-la progressivement par cohorte après contrôle de la santé. Surveillez migrations, lancements, plantages, erreurs et latence API. En cas d’incident, suspendez les mises à jour automatiques et désactivez la fonction. Ces mesures ne restaurent ni les binaires déjà installés ni les magasins déjà migrés. Prévoyez un chemin de réparation compatible.

Phase 1 (Backend Expand): Deploy API v2 supporting both new and legacy payloads.
Phase 2 (Client Distribution & Migration): Release client v2.0 via App Store Phased Release (1% -> 100%). DB migrates safely on first launch. Feature flag remains OFF.
Phase 3 (Validation & Feature Enablement): Monitor crash rates & migration success. Incrementally ramp Remote Config flag (10% -> 50% -> 100%).
Phase 4 (Backend Contract): Once legacy app adoption drops below deprecation threshold, sunset API v1.
Essayer de répondre à cette question avec un coach IA

20Vous concevez la synchronisation d’une application de notes privilégiant le hors ligne : les modifications doivent converger entre appareils, mais iOS peut différer ou annuler le travail en arrière-plan. Quelle architecture d’exécution choisissez-vous ?

La base locale, SQLite, Core Data ou SwiftData, est la source de vérité immédiate de l’interface. Les mutations sont ajoutées à une boîte d’envoi persistante sur disque pour que les modifications non envoyées survivent à la mort du processus. L’exécution opportuniste et non déterministe d’iOS exige plusieurs niveaux. Au passage en arrière-plan, UIApplication.shared.beginBackgroundTask(expirationHandler:) permet de terminer des mutations en cours ou rapides. BGTaskScheduler programme BGAppRefreshTask pour les métadonnées ou deltas légers et BGProcessingTask pour des opérations plus lourdes. Les ressources volumineuses sont transférées hors processus par une URLSessionConfiguration d’arrière-plan, avec envois et téléchargements de fichiers. Les notifications silencieuses content-available: 1 offrent des réveils opportunistes déclenchés par le serveur. Toute opération doit porter une clé d’idempotence générée côté client, par exemple un identifiant universellement unique (UUID), car une tâche peut être interrompue ou reprogrammée à tout moment. Si expirationHandler est appelé, annulez immédiatement le travail en cours, remettez les opérations non validées en attente et appelez setTaskCompleted(success: false). Synchronisez aussi au premier plan et après les modifications locales, sous la responsabilité d’un coordinateur unique. Aucun lancement en arrière-plan n’est garanti : ne promettez pas de délai fixe de convergence. Poursuivez la cohérence à terme avec des types de données répliqués sans conflit (CRDT), des vecteurs de versions associés à une politique de fusion ou une stratégie dernière écriture gagnante avec marqueurs de suppression, en empêchant les deltas distants d’écraser les mutations locales non validées de la boîte d’envoi.

import BackgroundTasks
import Foundation

final class NoteSyncCoordinator {
    static let shared = NoteSyncCoordinator()
    private let syncTaskID = "com.notesapp.sync.refresh"

    func registerSyncTask() {
        BGTaskScheduler.shared.register(forTaskWithIdentifier: syncTaskID, using: nil) { task in
            guard let refreshTask = task as? BGAppRefreshTask else { return }
            self.handleAppRefresh(task: refreshTask)
        }
    }

    func scheduleNextSync() {
        let request = BGAppRefreshTaskRequest(identifier: syncTaskID)
        request.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60)
        try? BGTaskScheduler.shared.submit(request)
    }

    private func handleAppRefresh(task: BGAppRefreshTask) {
        scheduleNextSync()
        let syncTask = Task {
            do {
                try await SyncEngine.shared.flushPersistentOutboxAndFetchDeltas()
                task.setTaskCompleted(success: true)
            } catch {
                task.setTaskCompleted(success: false)
            }
        }

        task.expirationHandler = {
            syncTask.cancel()
        }
    }
}
Essayer de répondre à cette question avec un coach IA

Préparez vos entretiens sur mobile : Développeur iOS

Répondez à voix haute et recevez les retours de l’IA dans l’app Android.

Télécharger EngineerSpeak sur Google Play
Scannez pour télécharger