Comment débuter avec Swift en 2026 (Guide débutant)

Introduction

Swift est le langage de programmation moderne et puissant développé par Apple pour iOS, macOS, watchOS et tvOS. Lancé en 2014, il combine la sécurité et la performance du C avec la simplicité des scripts modernes. En 2026, Swift 6 est la version stable, avec des améliorations en concurrence (actors) et interopérabilité.

Pourquoi apprendre Swift ? Il est type-sûr, gère les erreurs sans exceptions, et intègre parfaitement Xcode pour un développement rapide. Ce tutoriel beginner vous guide pas à pas : de l'installation à des structures avancées comme les optionals et les classes. Chaque exemple est complet et fonctionnel, copiable dans un Playground Xcode.

À la fin, vous saurez créer des programmes consoles robustes, prêts pour des apps réelles. Comptez 2-3 heures pour tout assimiler. Swift est accessible : pas de pointeurs manuels, garbage collector invisible. Comme un vélo électrique : fluide et sûr dès le départ. (148 mots)

Prérequis

Un Mac avec macOS Ventura (13+) ou supérieur.
Xcode 16+ installé depuis l'App Store (gratuit, ~15 Go).
Pas d'expérience préalable requise, mais notions de base en programmation aident.
Créez un nouveau Playground dans Xcode : File > New > Playground.

Premier programme : Hello World

HelloWorld.playground

import Foundation

print("Bonjour, Swift en 2026 !")

let message = "Votre premier programme fonctionne."
print(message)

Ce code importe Foundation pour les bases, affiche 'Bonjour, Swift en 2026 !' et une constante. Exécutez-le dans un Playground Xcode (Cmd+R). Piège : Oubliez pas le Playground pour tester vite sans build complet.

Variables et constantes

Swift distingue variables (var, modifiables) et constantes (let, immuables). Le typage est inféré : let x = 42 est un Int. Utilisez let par défaut pour la sécurité.

Variables, constantes et types

Variables.playground

import Foundation

// Constantes (immuables)
let nom: String = "Alice"
let age: Int = 30
let salaire: Double = 45000.50
let actif: Bool = true

// Variables (modifiables)
var score = 100
score += 50

print("Nom: \(nom), Âge: \(age), Nouveau score: \(score)")

// Interpolation de chaînes
print("Salaire: \(salaire)€, Actif: \(actif ? "Oui" : "Non")")

Déclare constantes avec types explicites ou inférés, modifie une var. L'interpolation \() est magique pour les chaînes. Évitez var sauf besoin : let prévient les bugs de mutation accidentelle.

Contrôle de flux : if, switch, boucles

If-else pour conditions, switch exhaustif (pas de fallthrough), for-in pour itérations, while pour boucles. Switch gère multiples types sans break.

Boucles et conditions

ControlFlow.playground

import Foundation

// If-else
let note = 16
if note >= 10 {
    print("Validé !")
} else if note >= 5 {
    print("Rattrapage.")
} else {
    print("Échec.")
}

// Switch exhaustif
let fruit = "pomme"
switch fruit {
case "pomme":
    print("Fruit rouge")
case "banane":
    print("Fruit jaune")
default:
    print("Autre")
}

// For-in
for i in 1...5 {
    print("Itération \(i)")
}

// While
var compteur = 0
while compteur < 3 {
    print("Compteur: \(compteur)")
    compteur += 1
}

Gère conditions, switch sur String, boucles sur range (1...5) et while. Switch doit couvrir tous cas (default). Piège : Oubliez default → erreur compile-time, sécurité top !

Fonctions et paramètres

Fonctions.playground

import Foundation

// Fonction simple
func saluer(_ nom: String) -> String {
    return "Bonjour, \(nom) !"
}

print(saluer("Bob"))

// Fonction avec paramètres par défaut et inout
var experience = 5
func gagnerExperience(annees: Int = 1, experience: inout Int) {
    experience += annees
}
gagnerExperience(annees: 2, experience: &experience)
print("Expérience: \(experience)")

// Closure (fonction anonyme)
let calcul = { (a: Int, b: Int) -> Int in
    return a + b
}
print("Somme: \(calcul(3, 4))")

Définit fonctions avec retour, params par défaut, inout (& pour mutation). Closures comme lambdas. Évitez inout sauf nécessaire : favorise l'immutabilité.

Optionals : Gérer l'absence de valeur

Optionals (? ) représentent nil. Force unwrap (!) dangereux ; utilisez if let, guard let ou ? (nil-coalescing).

Optionals en action

Optionals.playground

import Foundation

var emailOptionnel: String? = "user@example.com"

// If let (unwrapping sûr)
if let email = emailOptionnel {
    print("Email: \(email)")
} else {
    print("Pas d'email")
}

// Guard let (early exit)
func traiterEmail(_ email: String?) {
    guard let e = email else {
        print("Erreur: email manquant")
        return
    }
    print("Traité: \(e)")
}
traiterEmail(emailOptionnel)

// Nil-coalescing
let emailFinal = emailOptionnel ?? "default@example.com"
print("Final: \(emailFinal)")

emailOptionnel = nil

Gère optionals sans crash. Guard let simplifie les fonctions. ?? fournit fallback. Piège majeur : ! force → runtime crash si nil ; toujours optional binding.

Structures et classes

StructClass.playground

import Foundation

// Structure (value type, copié)
struct Personne {
    var nom: String
    let age: Int
    
    mutating func anniversaire() {
        // Nécessite mutating pour var
    }
}

var alice = Personne(nom: "Alice", age: 30)

// Classe (reference type, partagé)
class Voiture {
    var marque: String
    
    init(marque: String) {
        self.marque = marque
    }
    
    func accelerer() {
        print("\(marque) accélère")
    }
}

let maVoiture = Voiture(marque: "Tesla")
maVoiture.accelerer()

let copie = maVoiture  // Référence partagée
copie.marque = "BMW"
print(maVoiture.marque)  // BMW aussi !

Struct pour données simples (copie valeur), class pour objets complexes (référence). Init pour class. Struct mutating pour méthodes modifiant self. Choisissez struct par défaut (thread-safe).

Bonnes pratiques

Préférez let à var : Immutabilité réduit bugs.
Toujours gérer optionals avec if/guard, jamais !.
Utilisez structs pour 90% des cas (performant, sûr).
Adoptez guard pour early returns dans fonctions.
Testez dans Playgrounds avant apps complètes.

Erreurs courantes à éviter

Force unwrap (!) sur optional nil → crash fatal.
Oublier default dans switch → erreur compilation (bien, mais surprend).
Confondre struct/class : structs se copient, classes partagées → mutations inattendues.
Ignorer mutating dans structs → compile error.

Pour aller plus loin

Maîtrisez les actors pour concurrence Swift 6, ou créez votre première app iOS avec SwiftUI. Consultez la documentation officielle Swift.

Découvrez nos formations Learni sur iOS/Swift pour un parcours certifiant. Passez à SwiftUI ensuite !

Comment débuter avec Swift en 2026