Swift Academy · Leçon

Concevoir des interfaces pour la sémantique des valeurs

Choisir entre struct et class lors de la conception d’interfaces publiques et de frameworks.

Concevoir des interfaces pour la sémantique des valeurs 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

La conception d’API fondées sur la sémantique de valeur produit un code prévisible, sûr pour les fils d’exécution et facile à tester. Examinons les principes et les schémas qui permettent de faire ce choix.

Le contrat de sémantique de valeur

Un type possède une sémantique de valeur si : • Deux copies indépendantes restent indépendantes pour toujours • Modifier une copie ne modifie jamais l’autre • Le type se comporte comme `Int` — `a = b; a += 1` laisse `b` inchangé

API publique : privilégier les types de retour valeur

```swift // Reference semantics — caller shares state: func getUser() -> UserClass { ... } // Value semantics — caller gets independent copy: func getUser() -> UserStruct { ... } ``` Les types de retour valeur protègent l’état interne contre les modifications externes.

Types référence immuables

Lorsqu’une classe est toujours immuable, son comportement ressemble à celui d’une valeur : ```swift final class Token { let value: String init(_ v: String) { value = v } // No mutable state — safe to share freely } ```

Liste de contrôle : choisir une structure plutôt qu’une classe

Privilégiez une structure lorsque : ✓ Le type représente des données, et non une identité ✓ L’héritage n’est pas nécessaire ✓ Les instances ne doivent pas être partagées ni faire l’objet d’un partage de références ✓ Le type est équatable par comparaison des valeurs de ses champs ✓ Il fonctionne bien avec Swift Concurrency (`Sendable`)

Sendable et sémantique de valeur

La concurrence de Swift 6 exige que les types franchissant les limites des acteurs soient `Sendable` : ```swift struct Message: Sendable { var text: String; var timestamp: Date } // Safe to pass between actors ``` Les types valeur dont toutes les propriétés sont `Sendable` sont automatiquement `Sendable`.

Rendre les API de classes sûres avec les valeurs

```swift struct Config { // Expose value snapshot instead of the class: func snapshot() -> Config { self } // copy by value semantics } // Or use a value-type DTO: struct UserDTO: Sendable { var id: UUID; var name: String } ```

Schéma de construction avec des types valeur

```swift struct Request { var url: URL var method: String = "GET" var headers: [String:String] = [:] func adding(header: String, value: String) -> Request { var copy = self copy.headers[header] = value return copy } } let r = Request(url: url).adding(header: "Auth", value: "Bearer x") ```

Indication dans la documentation de l’API

Choisir une structure plutôt qu’une classe envoie un signal clair aux utilisateurs de l’API : • « Il s’agit de données — copiez-les librement » • « Modifier votre copie ne modifiera pas la mienne » • « Ce type peut être transmis entre les fils d’exécution en toute sécurité » Cela réduit le besoin de copies défensives dans le code des utilisateurs.

Quand accepter la sémantique de référence

Acceptez la sémantique des classes et des références lorsque : • L’identité compte (`===`) : deux objets utilisateur peuvent représenter la même personne • L’état mutable partagé est la fonctionnalité recherchée : `Database`, `Cache`, `AudioEngine` • L’interopérabilité avec Objective-C l’exige : les types UIKit et AppKit sont des classes • Des rappels de cycle de vie sont nécessaires : `deinit` pour nettoyer les ressources

Vérification rapide

Quel mot-clé de Swift indique qu’un type peut être transmis en toute sécurité au-delà des limites des acteurs dans Swift Concurrency ?

Récapitulatif

Points essentiels : • Sémantique de valeur : les modifications sont locales, sans partage de références • Privilégiez les structures pour les modèles de données ; les classes pour l’identité et le cycle de vie • Les classes immuables se comportent comme des types valeur • `Sendable` + types valeur = concurrence sûre • Le schéma de construction utilisant des copies de structures crée des API immuables claires Cours terminé ! Ensuite : ARC et les schémas de gestion de la mémoire.

Questions Fréquemment Posées

La leçon « Concevoir des interfaces pour la sémantique des valeurs » est-elle gratuite ?

Oui — le texte complet de « Concevoir des interfaces pour la sémantique des valeurs » 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 « Concevoir des interfaces pour la sémantique des valeurs » ?

Choisir entre struct et class lors de la conception d’interfaces publiques et de frameworks. 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 « Concevoir des interfaces pour la sémantique des valeurs » ?

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

Pile ou tas : où résident les valeurs
Mutation, partage et aliasing inattendu
Graphes mixtes de valeurs et de références
Concevoir des interfaces pour la sémantique des valeurs

← Retour à Swift Academy