Questions d'entretien pour développeur mobile senior (iOS) : Guide complet

class Personne {
    var nom: String
    var appartement: Appartement?
    
    init(nom: String) { self.nom = nom }
    deinit { print("\(nom) est en cours de désallocation") }
}

class Appartement {
    var unité: String
    weak var locataire: Personne?  // faible pour briser le cycle de rétention
    
    init(unité: String) { self.unité = unité }
    deinit { print("Appartement \(unité) est en cours de désallocation") }
}

// Fonction générique
func echange<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

// Type générique
struct Pile<Element> {
    private var éléments: [Element] = []
    
    mutating func push(_ élément: Element) {
        éléments.append(élément)
    }
    
    mutating func pop() -> Element? {
        return éléments.popLast()
    }
}

// Contrainte de type
func trouveIndex<T: Equatable>(de valeurÀTrouver: T, dans tableau: [T]) -> Int? {
    for (index, valeur) in tableau.enumerated() {
        if valeur == valeurÀTrouver {
            return index
        }
    }
    return nil
}

class GestionnaireReseau {
    var gestionnairesAchèvement: [() -> Void] = []
    
    // Fermeture escaping - stockée pour plus tard
    func récupèreDonnées(achèvement: @escaping (Data?) -> Void) {
        URLSession.shared.dataTask(with: url) { données, _, _ in
            achèvement(données)  // Appelée après que la fonction retourne
        }.resume()
    }
    
    // Fermeture non-escaping - exécutée immédiatement
    func traiteDonnées(_ données: Data, transformation: (Data) -> String) -> String {
        return transformation(données)  // Appelée avant que la fonction retourne
    }
}

let nombres = [1, 2, 3, 4, 5]

// map
let doublés = nombres.map { $0 * 2 }
// [2, 4, 6, 8, 10]

// compactMap - supprime nil
let chaînes = ["1", "2", "trois", "4"]
let nombresValides = chaînes.compactMap { Int($0) }
// [1, 2, 4]

// flatMap - aplatit les tableaux
let imbriqués = [[1, 2], [3, 4], [5]]
let aplatis = imbriqués.flatMap { $0 }
// [1, 2, 3, 4, 5]

@propertyWrapper
struct Capitalisé {
    private var valeur: String = ""
    
    var wrappedValue: String {
        get { valeur }
        set { valeur = newValue.capitalized }
    }
}

struct Utilisateur {
    @Capitalisé var prénom: String
    @Capitalisé var nom: String
}

var utilisateur = Utilisateur()
utilisateur.prénom = "jean"
print(utilisateur.prénom)  // "Jean"

// Wrapper UserDefaults
@propertyWrapper
struct UserDefault<T> {
    let clé: String
    let valeurParDéfaut: T
    
    var wrappedValue: T {
        get { UserDefaults.standard.object(forKey: clé) as? T ?? valeurParDéfaut }
        set { UserDefaults.standard.set(newValue, forKey: clé) }
    }
}

struct Paramètres {
    @UserDefault(clé: "nomUtilisateur", valeurParDéfaut: "Invité")
    static var nomUtilisateur: String
}

enum ErreurReseau: Error {
    case URLInvalide
    case pasDeDonnées
    case erreurDécodage
}

func récupèreUtilisateur(id: Int, achèvement: @escaping (Result<Utilisateur, ErreurReseau>) -> Void) {
    guard let url = URL(string: "https://api.example.com/utilisateurs/\(id)") else {
        achèvement(.failure(.URLInvalide))
        return
    }
    
    URLSession.shared.dataTask(with: url) { données, réponse, erreur in
        guard let données = données else {
            achèvement(.failure(.pasDeDonnées))
            return
        }
        
        do {
            let utilisateur = try JSONDecoder().decode(Utilisateur.self, from: données)
            achèvement(.success(utilisateur))
        } catch {
            achèvement(.failure(.erreurDécodage))
        }
    }.resume()
}

// Utilisation
récupèreUtilisateur(id: 1) { résultat in
    switch résultat {
    case .success(let utilisateur):
        print("Utilisateur : \(utilisateur.nom)")
    case .failure(let erreur):
        print("Erreur : \(erreur)")
    }
}

// Model
struct Utilisateur {
    let id: Int
    let prénom: String
    let nom: String
}

// ViewModel
class UtilisateurViewModel {
    private let utilisateur: Utilisateur
    
    var nomComplet: String {
        "\(utilisateur.prénom) \(utilisateur.nom)"
    }
    
    var texteAffiché: String {
        "Utilisateur #\(utilisateur.id) : \(nomComplet)"
    }
    
    init(utilisateur: Utilisateur) {
        self.utilisateur = utilisateur
    }
}

// View
class UtilisateurViewController: UIViewController {
    private let viewModel: UtilisateurViewModel
    private let étiquette = UILabel()
    
    init(viewModel: UtilisateurViewModel) {
        self.viewModel = viewModel
        super.init(nibName: nil, bundle: nil)
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        étiquette.text = viewModel.texteAffiché
    }
}

protocol Coordinator {
    var navigationController: UINavigationController { get }
    func start()
}

class AppCoordinator: Coordinator {
    let navigationController: UINavigationController
    
    init(navigationController: UINavigationController) {
        self.navigationController = navigationController
    }
    
    func start() {
        afficheConnexion()
    }
    
    func afficheConnexion() {
        let connexionVC = ConnexionViewController()
        connexionVC.coordinator = self
        navigationController.pushViewController(connexionVC, animated: true)
    }
    
    func afficheAccueil() {
        let accueilVC = AccueilViewController()
        accueilVC.coordinator = self
        navigationController.pushViewController(accueilVC, animated: true)
    }
}

// Protocole pour l'abstraction
protocol ServiceReseau {
    func récupèreDonnées(achèvement: @escaping (Result<Data, Error>) -> Void)
}

// Implémentation concrète
class URLSessionServiceReseau: ServiceReseau {
    func récupèreDonnées(achèvement: @escaping (Result<Data, Error>) -> Void) {
        // Vrai appel réseau
    }
}

// Mock pour les tests
class MockServiceReseau: ServiceReseau {
    func récupèreDonnées(achèvement: @escaping (Result<Data, Error>) -> Void) {
        achèvement(.success(Data()))
    }
}

// ViewModel avec injection de dépendances
class UtilisateurViewModel {
    private let serviceReseau: ServiceReseau
    
    // Injection de constructeur
    init(serviceReseau: ServiceReseau) {
        self.serviceReseau = serviceReseau
    }
    
    func chargeUtilisateurs() {
        serviceReseau.récupèreDonnées { résultat in
            // Gérer le résultat
        }
    }
}

// Utilisation
let viewModel = UtilisateurViewModel(serviceReseau: URLSessionServiceReseau())

// Tests
let viewModelTest = UtilisateurViewModel(serviceReseau: MockServiceReseau())

protocol UtilisateurRepository {
    func récupèreUtilisateur(id: Int) async throws -> Utilisateur
    func sauvegardeUtilisateur(_ utilisateur: Utilisateur) async throws
}

class UtilisateurRepositoryImpl: UtilisateurRepository {
    private let serviceAPI: APIService
    private let serviceCache: CacheService
    
    init(serviceAPI: APIService, serviceCache: CacheService) {
        self.serviceAPI = serviceAPI
        self.serviceCache = serviceCache
    }
    
    func récupèreUtilisateur(id: Int) async throws -> Utilisateur {
        // Vérifier le cache en premier
        if let utilisateurMisEnCache = try? await serviceCache.récupèreUtilisateur(id: id) {
            return utilisateurMisEnCache
        }
        
        // Récupérer de l'API
        let utilisateur = try await serviceAPI.récupèreUtilisateur(id: id)
        
        // Mettre à jour le cache
        try? await serviceCache.sauvegardeUtilisateur(utilisateur)
        
        return utilisateur
    }
    
    func sauvegardeUtilisateur(_ utilisateur: Utilisateur) async throws {
        try await serviceAPI.metÀJourUtilisateur(utilisateur)
        try await serviceCache.sauvegardeUtilisateur(utilisateur)
    }
}

class ImageTableViewCell: UITableViewCell {
    static let identifiant = "ImageCell"
    private let customImageView = UIImageView()
    
    override func prepareForReuse() {
        super.prepareForReuse()
        customImageView.image = nil  // Effacer l'ancienne image
    }
}

// Dans le view controller
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cellule = tableView.dequeueReusableCell(withIdentifier: ImageTableViewCell.identifiant, for: indexPath) as! ImageTableViewCell
    
    // Charger l'image de manière asynchrone
    DispatchQueue.global(qos: .userInitiated).async {
        let image = self.chargeEtRedimensionneImage(at: indexPath)
        DispatchQueue.main.async {
            cellule.imageView?.image = image
        }
    }
    
    return cellule
}

class ViewController: UIViewController {
    var fermeture: (() -> Void)?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // MAUVAIS - cycle de rétention
        fermeture = {
            self.view.backgroundColor = .red
        }
        
        // BON - weak self
        fermeture = { [weak self] in
            self?.view.backgroundColor = .red
        }
        
        // BON - unowned self (si self existe toujours)
        fermeture = { [unowned self] in
            self.view.backgroundColor = .red
        }
    }
}

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    
    // Critique : Configurer la fenêtre et le view controller racine
    configureFenêtre()
    
    // Différer le travail non critique
    DispatchQueue.main.async {
        self.configureAnalyse()
        self.configureRapportsDeCrash()
    }
    
    // Travail en arrière-plan
    DispatchQueue.global(qos: .background).async {
        self.préchargeDonnées()
    }
    
    return true
}

class CacheImage {
    static let partagé = CacheImage()
    
    private let cacheMémoire = NSCache<NSString, UIImage>()
    private let gestionnaireFichiers = FileManager.default
    private let répertoireCache: URL
    
    private init() {
        répertoireCache = gestionnaireFichiers.urls(for: .cachesDirectory, in: .userDomainMask)[0]
            .appendingPathComponent("CacheImage")
        try? gestionnaireFichiers.createDirectory(at: répertoireCache, withIntermediateDirectories: true)
    }
    
    func chargeImage(depuis url: URL, achèvement: @escaping (UIImage?) -> Void) {
        let clé = url.absoluteString as NSString
        
        // Vérifier le cache mémoire
        if let imageMiseEnCache = cacheMémoire.object(forKey: clé) {
            achèvement(imageMiseEnCache)
            return
        }
        
        // Vérifier le cache disque
        let URLFichier = répertoireCache.appendingPathComponent(url.lastPathComponent)
        if let imageDisque = UIImage(contentsOfFile: URLFichier.path) {
            cacheMémoire.setObject(imageDisque, forKey: clé)
            achèvement(imageDisque)
            return
        }
        
        // Télécharger
        URLSession.shared.dataTask(with: url) { données, _, _ in
            guard let données = données, let image = UIImage(data: données) else {
                achèvement(nil)
                return
            }
            
            // Sauvegarder dans les caches
            self.cacheMémoire.setObject(image, forKey: clé)
            try? données.write(to: URLFichier)
            
            DispatchQueue.main.async {
                achèvement(image)
            }
        }.resume()
    }
}

// Ancienne méthode avec les gestionnaires d'achèvement
func récupèreUtilisateur(id: Int, achèvement: @escaping (Result<Utilisateur, Error>) -> Void) {
    URLSession.shared.dataTask(with: url) { données, réponse, erreur in
        // Gérer le résultat
    }.resume()
}

// Nouvelle méthode avec async/await
func récupèreUtilisateur(id: Int) async throws -> Utilisateur {
    let (données, _) = try await URLSession.shared.data(from: url)
    let utilisateur = try JSONDecoder().decode(Utilisateur.self, from: données)
    return utilisateur
}

// Utilisation
Task {
    do {
        let utilisateur = try await récupèreUtilisateur(id: 1)
        print(utilisateur.nom)
    } catch {
        print("Erreur : \(erreur)")
    }
}

// Exécution parallèle
async let utilisateur1 = récupèreUtilisateur(id: 1)
async let utilisateur2 = récupèreUtilisateur(id: 2)
let utilisateurs = try await [utilisateur1, utilisateur2]

actor CompteBancaire {
    private var solde: Double = 0
    
    func déposer(montant: Double) {
        solde += montant
    }
    
    func retirer(montant: Double) -> Bool {
        guard solde >= montant else { return false }
        solde -= montant
        return true
    }
    
    func obtenirSolde() -> Double {
        return solde
    }
}

// Utilisation
let compte = CompteBancaire()

Task {
    await compte.déposer(montant: 100)
    let solde = await compte.obtenirSolde()
    print("Solde : \(solde)")
}

// Main Actor pour les mises à jour de l'interface utilisateur
@MainActor
class ViewModel: ObservableObject {
    @Published var données: [String] = []
    
    func chargeDonnées() async {
        let nouvellesDonnées = await récupèreDonnéesDeLAPI()
        // Automatiquement sur le thread principal
        self.données = nouvellesDonnées
    }
}

import Combine

class UtilisateurViewModel: ObservableObject {
    @Published var texteRecherche = ""
    @Published var utilisateurs: [Utilisateur] = []
    
    private var annulations = Set<AnyCancellable>()
    
    init() {
        $texteRecherche
            .debounce(for: .milliseconds(300), scheduler: RunLoop.main)
            .removeDuplicates()
            .filter { !$0.isEmpty }
            .flatMap { requête in
                self.rechercheUtilisateurs(requête: requête)
            }
            .receive(on: DispatchQueue.main)
            .sink { [weak self] utilisateurs in
                self?.utilisateurs = utilisateurs
            }
            .store(in: &annulations)
    }
    
    func rechercheUtilisateurs(requête: String) -> AnyPublisher<[Utilisateur], Never> {
        // Retourner le publisher
        URLSession.shared.dataTaskPublisher(for: url)
            .map(\.data)
            .decode(type: [Utilisateur].self, decoder: JSONDecoder())
            .replaceError(with: [])
            .eraseToAnyPublisher()
    }
}

// File d'attente serial
let fileAttenteSerial = DispatchQueue(label: "com.app.serial")
fileAttenteSerial.async { print("Tâche 1") }
fileAttenteSerial.async { print("Tâche 2") }
// Sortie : Tâche 1, Tâche 2 (toujours dans l'ordre)

// File d'attente concurrent
let fileAttenteConcurrent = DispatchQueue(label: "com.app.concurrent", attributes: .concurrent)
fileAttenteConcurrent.async { print("Tâche A") }
fileAttenteConcurrent.async { print("Tâche B") }
// Sortie : Tâche A, Tâche B OU Tâche B, Tâche A (ordre non garanti)

// Barrière pour les opérations d'écriture
fileAttenteConcurrent.async(flags: .barrier) {
    // Accès exclusif - aucune autre tâche ne s'exécute simultanément
    print("Opération d'écriture")
}

class CoreDataManager {
    let conteneurPersistant: NSPersistentContainer
    
    var contexteVue: NSManagedObjectContext {
        return conteneurPersistant.viewContext
    }
    
    func effectueTâcheEnArrièrePlan(_ block: @escaping (NSManagedObjectContext) -> Void) {
        conteneurPersistant.performBackgroundTask { contexte in
            block(contexte)
            
            if contexte.hasChanges {
                try? contexte.save()
            }
        }
    }
}

// Utilisation
coreDataManager.effectueTâcheEnArrièrePlan { contexte in
    let utilisateur = Utilisateur(context: contexte)
    utilisateur.nom = "Jean"
    // Le contexte sauvegarde automatiquement
}