Swift starter pack

Dans ce module, tu vas apprendre à stocker et manipuler des données qui peuvent changer au cours du temps. Les variables sont la base de toute logique dynamique en programmation, elles te permettent de mémoriser un score, le nom d’un utilisateur, ou encore l’état d’un bouton.

Ici, tu vas découvrir les constantes, ces variables… qui ne changent jamais ! Elles sont essentielles pour stocker des données fixes et fiables.

Dans ce module, tu vas apprendre à bien définir la nature des données que tu manipules. En Swift, chaque donnée a un type : texte (String), nombre entier (Int), nombre à virgule (Double), booléen (Bool), etc.

Dans ce module, tu vas découvrir comment faire des opérations avec tes données. Additionner des nombres, comparer des valeurs, inverser une condition… tout ça, c’est grâce aux opérateurs.

Tu vas manipuler les opérateurs arithmétiques (+, -, *, /), les opérateurs de comparaison (==, !=, >, <), et même des opérateurs un peu plus malins comme += ou %.

Dans ce module, tu vas apprendre à faire des choix logiques dans ton code grâce à if, switch et l’opérateur ternaire. Tu verras comment exécuter des actions différentes selon des situations précises, comme vérifier une connexion, afficher un message, ou adapter l’affichage d’une vue.

Dans ce module, tu vas apprendre à regrouper plusieurs valeurs grâce aux collections Swift : les Array pour stocker des listes ordonnées, les Dictionnaire pour associer des clés à des valeurs, et les Set pour gérer des ensembles uniques sans doublons. Des outils essentiels pour manipuler des données à grande échelle, comme une liste de produits, un inventaire ou un classement de joueurs.

Dans ce module, tu vas apprendre à répéter des actions automatiquement grâce aux boucles for-in et while. Elles te permettent de parcourir des listes, d’exécuter une tâche plusieurs fois, ou de répéter une action jusqu’à ce qu’une condition soit remplie. Un outil indispensable pour automatiser ton code et éviter les copier-coller inutiles.

Dans ce module, tu vas apprendre à regrouper des instructions sous un même nom pour les réutiliser facilement. Les fonctions te permettent d’organiser ton code, de le rendre plus lisible et d’éviter de répéter la même logique plusieurs fois. Tu verras comment leur donner des paramètres, leur faire retourner des résultats, et les appeler quand tu en as besoin.

Dans ce module, tu vas découvrir comment créer tes propres types de données grâce aux structures. Les struct te permettent de regrouper plusieurs propriétés et comportements dans un seul bloc logique. C’est l’outil idéal pour représenter un objet concret dans ton code, comme un joueur, un produit ou une carte de jeu, et travailler avec lui de façon claire et organisée.

Dans ce module, tu vas apprendre à gérer les situations où une donnée peut être présente… ou absente. Les optionnels (?) sont une particularité de Swift qui t’obligent à écrire du code plus sûr, en évitant les plantages liés à des valeurs manquantes. Tu verras comment les déclarer, les vérifier, et les utiliser avec des techniques comme l’unwrapping ou l’opérateur ??.

Dans ce module, tu vas apprendre à définir des ensembles de valeurs possibles avec les énumérations (enum). C’est une façon élégante de représenter des choix clairs et limités dans ton code, comme des directions, des états ou des catégories. Tu verras comment les déclarer, les utiliser dans des conditions, et même leur associer des valeurs supplémentaires.

Dans ce module, tu vas découvrir les classes, un autre moyen de créer tes propres types de données, mais avec une particularité : elles permettent l’héritage. Une classe peut transmettre ses propriétés et méthodes à une autre, ce qui en fait un outil puissant pour modéliser des objets plus complexes et réutiliser ton code. Tu apprendras aussi la différence clé entre struct et class, afin de choisir la bonne approche selon tes besoins.

Dans ce module, tu vas apprendre à utiliser les closures, des fonctions sans nom que tu peux stocker dans des variables ou passer en paramètre. Elles sont très pratiques pour écrire du code concis et flexible, notamment quand tu veux exécuter une action plus tard ou personnaliser le comportement d’une fonction. Tu verras que derrière leur syntaxe un peu intimidante au début, elles sont un outil incontournable en Swift.

Dans ce module, tu vas découvrir les tuples, un moyen simple de regrouper plusieurs valeurs dans une seule variable, sans créer de structure ou de classe. Les tuples sont parfaits pour retourner plusieurs résultats d’une fonction ou pour manipuler rapidement des ensembles de données légers. Tu verras comment les déclarer, les décomposer et les utiliser efficacement.

Dans ce module, tu vas apprendre à utiliser les protocoles, un outil qui permet de définir un contrat que tes types (struct, class, enum) doivent respecter. Grâce aux protocoles, tu rends ton code plus clair, plus flexible et surtout plus réutilisable. Tu verras comment déclarer un protocole, l’adopter dans un type, et tirer parti du polymorphisme pour écrire du code générique.

Dans ce module, tu vas découvrir comment ajouter de nouvelles fonctionnalités à un type existant sans avoir à le modifier. Les extensions te permettent d’enrichir les String, Int, Array (et bien d’autres) avec tes propres méthodes ou propriétés calculées. C’est une façon élégante et puissante de rendre ton code plus lisible et de réutiliser tes outils partout dans ton projet.

Dans ce module, tu vas apprendre à anticiper et gérer les situations imprévues qui pourraient faire planter ton app. Grâce au système de gestion des erreurs de Swift (do, try, catch), tu pourras intercepter les problèmes et réagir proprement au lieu de laisser ton programme crasher. Tu verras aussi comment créer tes propres erreurs pour rendre ton code encore plus robuste.

Dans ce module, tu vas apprendre à faire parler ton app avec le monde extérieur grâce à Codable. Tu verras comment convertir facilement tes structs en JSON (encodage) et lire du JSON pour créer des objets Swift (décodage), sans te battre avec la sérialisation. On couvrira les clés personnalisées (CodingKeys), les dates, les valeurs optionnelles et les erreurs courantes pour rendre tes échanges réseau propres et fiables.

Dans ce module, tu vas apprendre à exécuter des tâches en arrière-plan sans bloquer ton interface grâce à async/await, Task et URLSession. Tu verras comment lancer des requêtes réseau, attendre proprement un résultat, gérer l’annulation et propager les erreurs, le tout avec un code lisible et moderne.