Aide-mémoire Swift
Dernière mise à jour
Hello World et bases
Swift ne nécessite aucun code standard au niveau supérieur - une seule ligne s'exécute.
| Opération | Syntaxe |
|---|---|
| Afficher une ligne | print("Hello, World!") |
| Afficher sans saut de ligne | print("Hi", terminator: "") |
| Interpolation de chaîne | print("Hi \(name)") |
| Commentaire | // this is a comment |
| Commentaire multiligne | /* ... */ |
| Importer un module | import Foundation |
| Exécuter un fichier | swift run ou swift main.swift |
Variables (let / var) et types
Utilisez let pour les constantes et var pour les valeurs mutables ; les types sont généralement inférés.
| Opération | Syntaxe |
|---|---|
| Constante | let age = 30 |
| Variable | var count = 0 |
| Type explicite | let name: String = "Ada" |
| Types de base | Int, Double, String, Bool, Character |
| Conversion de type | Double(i), String(n), Int("42") |
| Tuple | let pair = (1, "a") |
| Alias de type | typealias ID = Int |
| Vérifier le type | value is String, value as? String |
Optionals
Les optionals modélisent l'absence possible d'une valeur ; déballez-la avant utilisation.
| Opération | Syntaxe |
|---|---|
| Déclarer un optional | var name: String? = nil |
| Liaison optionnelle | if let n = name { ... } |
| Déballage avec guard | guard let n = name else { return } |
| Coalescence des nuls | let n = name ?? "default" |
| Chaînage optionnel | user?.address?.city |
| Déballage forcé (non sûr) | name! |
| Déballé implicitement | var name: String! |
| Mapper sur un optional | name.map { $0.count } |
Chaînes
Les chaînes sont des types valeur avec une prise en charge complète d'Unicode.
| Opération | Syntaxe |
|---|---|
| Longueur | s.count |
| Majuscules / minuscules | s.uppercased(), s.lowercased() |
| Concaténer | "foo" + "bar" |
| Interpolation | "Total: \(price)" |
| Contient | s.contains("ell") |
| A le préfixe / suffixe | s.hasPrefix("he") |
| Découper | s.split(separator: ",") |
| Remplacer | s.replacingOccurrences(of: "a", with: "b") |
| Chaîne multiligne | """ ... """ |
Collections (Array, Dictionary, Set)
Trois types de collection principaux, tous des types valeur.
| Opération | Syntaxe |
|---|---|
| Littéral de tableau | var nums = [1, 2, 3] |
| Ajouter (append) | nums.append(4) |
| Accès / nombre | nums[0], nums.count |
| Map / filter | nums.map { $0 * 2 }, nums.filter { $0 > 1 } |
| Littéral de dictionnaire | var ages = ["Ada": 30] |
| Accès au dictionnaire | ages["Ada"] renvoie un optional |
| Littéral d'ensemble | var ids: Set = [1, 2, 3] |
| Insérer dans un ensemble | ids.insert(4) |
| Itérer un dictionnaire | for (k, v) in ages { ... } |
Contrôle de flux
Les conditions ne nécessitent pas de parenthèses ; switch doit être exhaustif.
| Opération | Syntaxe |
|---|---|
| If / else | if x > 0 { ... } else { ... } |
| Ternaire | let r = x > 0 ? "pos" : "neg" |
| Switch | switch n { case 1: ...; default: ... } |
| Switch avec plage | case 1...5: ... |
| Boucle for-in | for i in 0..<10 { ... } |
| For-in sur un tableau | for item in items { ... } |
| Boucle while | while x < 100 { ... } |
| Repeat-while | repeat { ... } while x < 100 |
| Break / continue | break, continue |
Fonctions et closures
Les fonctions ont des paramètres étiquetés ; les closures sont des blocs de code autonomes.
| Opération | Syntaxe |
|---|---|
| Définir une fonction | func add(a: Int, b: Int) -> Int { a + b } |
| Étiquette externe | func greet(to name: String) { ... } |
| Paramètre par défaut | func greet(name: String = "World") { ... } |
| Paramètre variadique | func sum(_ nums: Int...) -> Int { ... } |
| Retours multiples (tuple) | func bounds() -> (min: Int, max: Int) { ... } |
| Expression de closure | let f = { (x: Int) -> Int in x * x } |
| Closure en suffixe | nums.map { $0 * 2 } |
| Arguments abrégés | { $0 + $1 } |
Structures vs classes
Les structures sont des types valeur (copiées) ; les classes sont des types référence (partagées).
| Opération | Syntaxe |
|---|---|
| Définir une structure | struct Point { var x: Int; var y: Int } |
| Définir une classe | class Person { var name: String } |
| Initialiseur de classe | init(name: String) { self.name = name } |
| Créer une instance | let p = Point(x: 1, y: 2) |
| Méthode mutating de structure | mutating func move() { x += 1 } |
| Méthode de classe | func greet() { ... } |
| Héritage (classes uniquement) | class Student: Person { ... } |
| Propriété calculée | var area: Int { width * height } |
| Membre statique | static let shared = Manager() |
Enums
Les enums regroupent des valeurs liées et peuvent porter des données associées.
| Opération | Syntaxe |
|---|---|
| Définir un enum | enum Direction { case north, south } |
| Utiliser un case | let d = Direction.north |
| Switch sur un enum | switch d { case .north: ... } |
| Valeurs brutes | enum Status: Int { case ok = 200 } |
| Accéder à la valeur brute | Status.ok.rawValue |
| Init depuis une valeur brute | Status(rawValue: 200) |
| Valeurs associées | case result(Int, String) |
| Méthodes sur les enums | func label() -> String { ... } |
La syntaxe Swift que vous utilisez le plus, sur une seule page. Cet aide-mémoire Swift est une référence rapide pour le cœur du langage - constantes et variables, optionals, chaînes, collections, contrôle de flux, fonctions et closures, plus les structures, classes et enums avec lesquels vous construisez des applications iOS et macOS.
Tout ce qui figure ici est du Swift standard et se compile avec la chaîne d'outils officielle. Copiez ce dont vous avez besoin, ou essayez chaque extrait en direct dans le playground Swift - aucun Xcode requis.
FAQ de l'aide-mémoire Swift
Cet aide-mémoire Swift est-il gratuit ?
Oui. Cet aide-mémoire Swift est entièrement gratuit, sans inscription. Mettez-le en favori et revenez dès que vous devez retrouver un motif d'optional, une syntaxe de closure ou une méthode de collection.
Comment déballer un optional en Swift ?
Un optional peut contenir une valeur ou
nil, vous le déballez donc avant utilisation. Les méthodes sûres sont la liaison optionnelle (if let n = name { ... }), un guard let en début de fonction, l'opérateur de coalescence des nuls (name ?? "default") et le chaînage optionnel (user?.name). Le déballage forcé avec name! fonctionne mais plante si la valeur est nil, alors n'y recourez que lorsque vous êtes certain.Quelle est la différence entre une structure et une classe en Swift ?
Une
struct est un type valeur : l'affecter ou la passer en crée une copie, donc les modifications n'affectent pas l'original. Une class est un type référence : les copies partagent la même instance, et seules les classes prennent en charge l'héritage. La recommandation d'Apple est de préférer les structures par défaut et d'utiliser une classe lorsque vous avez besoin d'un état mutable partagé ou de l'héritage.Puis-je m'entraîner à Swift en ligne ?
Oui. Ouvrez le playground Swift pour exécuter n'importe quel extrait de cet aide-mémoire dans votre navigateur - aucun Xcode à installer. Quand vous voulez de la structure, le cours Swift interactif gratuit de Coddy vous emmène des optionals et des collections jusqu'aux structures, classes et enums, étape par étape.
Cet aide-mémoire convient-il aux débutants ?
Oui. Il est organisé des sujets les plus courants (variables, optionals, contrôle de flux) jusqu'aux plus avancés (closures, structures vs classes, enums), pour que vous puissiez utiliser les premières sections dès le premier jour et progresser vers le reste.
Ressources connexes
Plus d'aide-mémoires
