Swift Academy · Leçon

Inférence des types et types explicites

Découvrez comment Swift infère les types et quand les déclarer explicitement.

Inférence des types et types explicites est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.

Bienvenue

Swift est un langage *à typage statique* : chaque valeur possède un type connu lors de la compilation. Cependant, vous avez rarement besoin d’écrire vous-même le type, car Swift le déduit pour vous.

Qu’est-ce que l’inférence de type ?

Swift examine la valeur située à droite et en déduit automatiquement le type : ```swift let message = "Hello" // inferred as String let count = 42 // inferred as Int let price = 9.99 // inferred as Double ``` Aucune annotation de type n’est nécessaire : le compilateur s’en charge.

Annotations de type explicites

Vous pouvez toujours indiquer explicitement le type à l’aide de deux-points : ```swift let message: String = "Hello" let count: Int = 42 let price: Double = 9.99 ``` C’est utile lorsque le type déduit ne correspond pas à celui que vous souhaitez.

Quand l’inférence choisit le mauvais type

Les littéraux à virgule flottante sont de type `Double` par défaut. Si vous avez besoin de `Float`, annotez-le explicitement : ```swift let inferred = 3.14 // Double let explicit: Float = 3.14 // Float ``` De même, les littéraux entiers sont de type `Int` par défaut : utilisez une annotation pour `Int32`, `UInt8`, etc.

La sécurité des types en pratique

Une fois qu’un type est défini, il ne peut plus changer : ```swift var score = 0 // Int score = "ten" // ❌ cannot assign String to Int ``` La sécurité des types détecte cette catégorie de bogue lors de la compilation, bien avant l’exécution.

La fonction type(of:)

Utilisez `type(of:)` pour examiner le type lors de l’exécution : ```swift let value = 42 print(type(of: value)) // Int let name = "Alice" print(type(of: name)) // String ``` C’est utile pour déboguer les résultats surprenants de l’inférence de type.

Alias de types

`typealias` attribue un nouveau nom à un type existant afin d’améliorer la lisibilité : ```swift typealias Celsius = Double typealias UserID = Int var temperature: Celsius = 36.6 var userId: UserID = 1001 ``` Les alias de types sont purement esthétiques : le type sous-jacent ne change pas.

Annotations sans initialisation

Lorsque vous déclarez une variable sans valeur initiale, vous *devez* annoter son type : ```swift var name: String // ✓ annotation required name = "Bob" var total: Int total = 0 ``` Swift ne peut pas déduire un type en l’absence de valeur.

Littéraux numériques et lisibilité

Swift autorise les traits de soulignement dans les littéraux numériques pour améliorer leur lisibilité : ```swift let million = 1_000_000 let hex = 0xFF_EC_D3 let binary = 0b1111_0000 ``` Le compilateur ignore les traits de soulignement : ils sont purement esthétiques.

Conversion de type — aucune conversion implicite

Swift ne convertit jamais implicitement les types. Vous devez effectuer la conversion explicitement : ```swift let intVal: Int = 5 let dblVal: Double = Double(intVal) // explicit conversion let sum = Double(intVal) + 2.5 ``` Cela évite les bogues subtils dus à des promotions numériques involontaires.

Vérification rapide

Quel type Swift déduit-il pour `let x = 3.14` ?

Récapitulatif

Points essentiels : • Swift déduit les types à partir des valeurs initiales ; aucune annotation n’est généralement nécessaire • Les annotations explicites (`: Type`) remplacent l’inférence • Les nombres à virgule flottante sont de type `Double` par défaut, et les entiers de type `Int` • Aucune conversion implicite : utilisez `Int()`, `Double()`, etc. • `type(of:)` révèle le type lors de l’exécution Ensuite : les types fondamentaux — nombres, booléens et caractères.

Questions Fréquemment Posées

La leçon « Inférence des types et types explicites » est-elle gratuite ?

Oui — le texte complet de « Inférence des types et types explicites » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Inférence des types et types explicites » ?

Découvrez comment Swift infère les types et quand les déclarer explicitement. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Inférence des types et types explicites » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

let ou var : constantes et variables
Inférence des types et types explicites
Nombres, booléens et caractères
Fondamentaux des chaînes et interpolation

← Retour à Swift Academy