Sixième jour des 100 Days of SwiftUI ! Aujourd’hui, on plonge dans le cœur de la logique de programmation avec les boucles et les conditions.

La journée a été beaucoup plus agréable avec des températures plus supportables. J’ai pu mieux récupérer grâce à une nuit plus fraîche, et j’ai même trouvé l’énergie pour faire 36km en vélo d’intérieur !

# Avancement sur les projets portfolio

Cet après-midi, j’ai finalisé les prototypes de ma première application. J’ai affiné plusieurs aspects importants :

• Révision du système de tampons : j’ai modifié la façon dont les tampons s’ajoutent sur les cartes de fidélité pour une meilleure expérience utilisateur
• Définition des user stories : j’ai clarifié les premières actions à développer et établi les priorités
• Planification du développement : identification des fonctionnalités à implémenter en premier

Bonne nouvelle : j’ai terminé toute la préparation de la première semaine pour le premier projet ! La semaine prochaine, je pourrai commencer la préparation de la deuxième application du portfolio. Cette approche me permettra d’éviter les retards et de commencer le développement de l’application de cartes de fidélité dans deux semaines.

# Découverte de l’architecture MVVM

Après avoir finalisé les prototypes, j’ai regardé une vidéo de Développeur Libre sur l’architecture MVVM (Model-View-ViewModel). Cette présentation d'1h30 était très détaillée, montrant toutes les étapes et couches de cette architecture.

Une question se pose maintenant : dois-je suivre strictement cette structure complexe dans ma phase d’apprentissage ?

Réflexion : Je pense pouvoir utiliser les mêmes blocs fondamentaux de cette architecture reconnue, mais en simplifiant l’approche pour l’apprentissage. Sinon, je risque d’avoir des problèmes de compréhension de mon propre code.

L’équilibre entre bonnes pratiques et simplicité d’apprentissage sera crucial pour mes premiers projets.

# Apprentissages du jour

## Les boucles for : parcourir et répéter

La boucle for est l’un des outils les plus puissants en programmation. Elle permet de répéter des actions de manière contrôlée.

### Parcourir des collections

Avec Swift, parcourir un tableau devient très naturel. Au lieu de manipuler des indices, on peut directement itérer sur les éléments :

let platforms = ["iOS","macOS","tvOS","watchOS","visionOS"]

for os in platforms {
    print("Swift works great on \(os)")
}

### Les ranges : définir des plages

Swift propose une syntaxe élégante pour créer des plages de valeurs :

• 1…100 : inclut 100 (plage fermée)
• 1..<100 : exclut 100 (plage semi-ouverte, très pratique pour les tableaux qui commencent à l’indice 0)

### Le caractère générique underscore

Quand la valeur de l’itération n’est pas importante, Swift nous permet d’utiliser _ pour l’ignorer :

for _ in 1...5 {
    // Répéter 5 fois sans utiliser la valeur
}

## Les boucles while : conditions dynamiques

La boucle while est parfaite quand on ne connaît pas à l’avance le nombre d’itérations nécessaires :

var countdown = 10
while countdown > 0 {
    print("\(countdown)...")
    countdown -= 1
}

### Nombres aléatoires en Swift

Swift offre des méthodes simples pour générer des nombres aléatoires :

• Int.random(in: 1…1000) : entier aléatoire
• Double.random(in: 0…1) : nombre décimal aléatoire

## Contrôler le flux avec break et continue

### Continue : passer à l’itération suivante

Le mot-clé continue permet de sauter à l’itération suivante sans exécuter le reste du code :

for file in files {
    if file.hasSuffix(".jpg") == false {
        continue  // Ignore les fichiers non-JPEG
    }
    print("Found picture : \(file)")
}

### Break : sortir complètement de la boucle

Break interrompt totalement l’exécution de la boucle :

if multiplesOf.count == 10 {
    break  // On a trouvé 10 éléments, on s'arrête
}

### Labels : contrôler les boucles imbriquées

Pour les boucles imbriquées, Swift permet d’utiliser des labels pour contrôler précisément quelle boucle on veut interrompre :

ourLoop: for i in 1...100 {
    if i == 5 {
        break ourLoop  // Sort de la boucle étiquetée
    }
}

Conseil : Les labels sont particulièrement utiles quand on a plusieurs niveaux de boucles imbriquées et qu’on veut sortir de toutes en une fois.

# Challenge FizzBuzz : mettre en pratique

Le célèbre exercice FizzBuzz combine parfaitement boucles et conditions :

• Multiple de 3 → “Fizz”
• Multiple de 5 → “Buzz”
• Multiple de 3 ET 5 → “FizzBuzz”
• Sinon → le nombre

La clé est de tester d’abord la condition la plus spécifique (multiple de 3 ET 5) avant les conditions individuelles.

# Exercices pratiques réalisés

## 1. Générateur de nombres pairs

Créer un tableau avec tous les nombres pairs de 1 à 10 en utilisant la méthode isMultiple(of:).

## 2. Vérificateur d’âge

Système simple pour vérifier l’éligibilité au permis de conduire avec calcul du temps d’attente restant.

## 3. Table de multiplication

Fonction qui affiche proprement une table de multiplication pour n’importe quel nombre.

## 4. Analyse de performances

Générer 100 scores aléatoires, filtrer ceux supérieurs à 90, et trouver le score maximum avec gestion des cas où aucun résultat n’est trouvé.

## 5. Détecteur de nombres parfaits

Un nombre parfait est égal à la somme de ses diviseurs propres. L’optimisation consiste à ne tester que jusqu’à n/2 puisque aucun diviseur propre ne peut être supérieur à la moitié du nombre.

## 6. Générateur de mots de passe

Trois versions progressivement optimisées :

• Version basique : utilise des tableaux séparés pour chaque type de caractère
• Version améliorée : concatène tout en une seule chaîne de caractères
• Version experte : utilise la programmation fonctionnelle avec map pour une solution ultra-concise

Après avoir créé la première version, j’ai cherché comment optimiser le code et j’ai demandé conseil à Claude, qui m’a proposé ces deux approches plus élégantes.

Astuce : La méthode randomElement() de Swift permet de sélectionner aléatoirement un élément dans une collection.

# Réflexions sur cette étape

Cette journée était dense entre la théorie Swift du matin et le travail sur les prototypes l’après-midi. L’architecture MVVM semble prometteuse, mais je vais garder une approche progressive pour ne pas me compliquer la tâche dans mes premiers projets.

À demain pour la suite des 100 Days of SwiftUI !