0Pricing
Swift Academy · Leçon

Fondamentaux des chaînes et interpolation

Créez des chaînes, utilisez l’interpolation avec \(variable) et réalisez des opérations de base.

Fondamentaux des chaînes et interpolation est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 4 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

Les chaînes sont au cœur de presque toutes les applications. Le type `String` de Swift respecte Unicode, est un type valeur et est extrêmement puissant. Découvrons les notions essentielles.

Littéraux de chaîne

Les littéraux de chaîne utilisent des guillemets doubles : ```swift let greeting = "Hello, World!" var city = "Istanbul" ``` Pour les chaînes multilignes, utilisez trois guillemets : ```swift let poem = """ Roses are red, Swift is great. """ ```

Concaténation de chaînes

Combinez des chaînes avec l'opérateur `+` ou `+=` : ```swift let first = "Hello" let second = " World" let full = first + second // "Hello World" var msg = "Hi" msg += " there" // "Hi there" ```

Interpolation de chaînes

Insérez n'importe quelle expression dans une chaîne avec `\(expression)` : ```swift let name = "Alice" let score = 95 print("Player \(name) scored \(score) points") // Player Alice scored 95 points ``` L'interpolation est plus sûre et plus lisible que la concaténation manuelle.

isEmpty et longueur

Vérifiez si une chaîne est vide ou obtenez le nombre de ses caractères : ```swift var text = "" print(text.isEmpty) // true text = "Swift" print(text.count) // 5 ``` Utilisez `.isEmpty` plutôt que `text == ""` : c'est plus idiomatique en Swift.

Méthodes courantes des chaînes

```swift let str = "Hello, Swift!" str.uppercased() // "HELLO, SWIFT!" str.lowercased() // "hello, swift!" str.contains("Swift") // true str.hasPrefix("Hello") // true str.hasSuffix("!") // true str.replacingOccurrences(of: "Swift", with: "World") ```

Mutabilité des chaînes

Les chaînes de Swift sont des *types valeur*. Une chaîne déclarée avec `var` est mutable ; une chaîne déclarée avec `let` est immuable : ```swift var mutable = "Hello" mutable.append(" World") // ✓ let immutable = "Hello" immutable.append(" World") // ❌ compile error ```

Comparaison de chaînes

Comparez les chaînes avec les opérateurs `==`, `<` et `>` (en tenant compte d'Unicode) : ```swift let a = "apple" let b = "banana" print(a == b) // false print(a < b) // true (lexicographic order) ``` Par défaut, les comparaisons sont indépendantes des paramètres régionaux.

Chaînes brutes

Utilisez `#"..."#` pour désactiver les séquences d'échappement — c'est utile pour les motifs d'expressions régulières ou les chemins : ```swift let pattern = #"\d{3}-\d{4}"# // The backslashes are literal, not escape sequences let path = #"C:\Users\Alice"# ``` L'interpolation fonctionne toujours avec `\#(value)` dans les chaînes brutes.

Conversion entre String et d'autres types

```swift let num = 42 let str = String(num) // "42" let back = Int(str) // Optional(42) let invalid = Int("abc") // nil ``` La conversion d'une chaîne vers un type numérique renvoie une valeur facultative, car la chaîne peut ne pas représenter un nombre valide.

Vérification rapide

Quelle syntaxe permet d'intégrer la valeur d'une variable dans un littéral de chaîne Swift ?

Récapitulatif

Points essentiels : • Les littéraux de chaîne utilisent `"..."` ; les chaînes multilignes utilisent `"""` • Interpolez avec `\(expression)` : c'est la manière la plus claire de construire des chaînes • Les chaînes `var` sont mutables ; les chaînes `let` sont immuables • Utilisez `.isEmpty`, `.count`, `.contains()`, `.hasPrefix()` et `.hasSuffix()` • La conversion de String vers un type numérique renvoie une valeur facultative Prochaine leçon : les boucles for-in avec des plages.

Questions Fréquemment Posées

La leçon « Fondamentaux des chaînes et interpolation » est-elle gratuite ?

Oui — le texte complet de « Fondamentaux des chaînes et interpolation » 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 « Fondamentaux des chaînes et interpolation » ?

Créez des chaînes, utilisez l’interpolation avec \(variable) et réalisez des opérations de base. 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 4 sur 4.

Combien de temps prend la leçon « Fondamentaux des chaînes et interpolation » ?

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

  1. let ou var : constantes et variables
  2. Inférence des types et types explicites
  3. Nombres, booléens et caractères
  4. Fondamentaux des chaînes et interpolation
← Retour à Swift Academy