0Pricing
Swift Academy · Leçon

Types valeur pour réduire le partage

Privilégiez les types valeur pour éviter les partages accidentels : les structures et les énumérations sont copiées lors de l’affectation, ce qui favorise l’isolation, la prévisibilité et la sécurité des threads.

Types valeur pour réduire le partage est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 3. 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 3 leçons au total.

Pourquoi utiliser des types valeur ?

Les structures/énumérations Swift sont des types valeur : l’affectation et le passage en argument créent des copies. Cela réduit le partage accidentel et facilite le raisonnement sur l’état.

Partage de références (classe)

Les classes sont des types référence : plusieurs variables peuvent pointer vers la même instance, de sorte que les modifications se propagent entre les alias.

final class Bag {
    var items: [String]
    init(_ items: [String]) { self.items = items }
}
let a = Bag(["pen"])
let b = a            // REF COPY: a and b refer to the same object
b.items.append("book")
print(a.items)       // ["pen","book"] — mutated via b
print(b.items)

Copies indépendantes (structure)

Les structures sont copiées lors de l’affectation. Chaque variable possède ses propres données ; les modifications restent locales.

struct Point { var x: Int; var y: Int }
var p1 = Point(x: 1, y: 2)
var p2 = p1          // VALUE COPY: independent
p2.x = 99
print(p1.x, p2.x)    // 1, 99 — p1 unaffected

Collections avec copie à l’écriture

Les tableaux/dictionnaires/ensembles sont des types valeur avec une copie à l’écriture. Lorsque vous modifiez un tableau référencé par plusieurs variables, Swift crée une nouvelle copie.

var a1 = [1,2,3]
var a2 = a1      // copy-on-write handle
a2.append(4)     // triggers copy if a1 is uniquely referenced
print(a1)        // [1,2,3]
print(a2)        // [1,2,3,4]

Mises à jour de style pur

Concevez des API presque pures : acceptez une valeur et renvoyez une nouvelle valeur. Les appelants évitent ainsi les modifications partagées inattendues.

struct Profile {
    var name: String
    var tags: [String]
}
func addTag(_ p: Profile, _ tag: String) -> Profile {
    var copy = p          // work on a value copy
    copy.tags.append(tag) // caller gets a new updated value
    return copy
}
let pA = Profile(name: "Ana", tags: [])
let pB = addTag(pA, "swift")
print(pA.tags)  // []
print(pB.tags)  // ["swift"]

Choisir judicieusement

Recommandations :

  • Préférez une structure pour les données petites, immuables ou modifiées localement.
  • Utilisez une classe lorsqu’une identité, un état mutable partagé ou l’héritage est nécessaire.
  • Les types valeur réduisent le partage et facilitent le raisonnement sur la sécurité de la concurrence.

Partage de valeurs ou de références

Vérification rapide : pourquoi les types valeur aident-ils à éviter le partage involontaire ?

Récapitulatif

Récapitulatif : les structures/énumérations sont des valeurs. Utilisez-les pour réduire l’état mutable partagé. Les collections utilisent la copie à l’écriture, afin que les modifications ne surprennent pas les autres détenteurs.

Questions Fréquemment Posées

La leçon « Types valeur pour réduire le partage » est-elle gratuite ?

Oui — le texte complet de « Types valeur pour réduire le partage » 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 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Types valeur pour réduire le partage » ?

Privilégiez les types valeur pour éviter les partages accidentels : les structures et les énumérations sont copiées lors de l’affectation, ce qui favorise l’isolation, la prévisibilité et la sécurité… 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 3 sur 3.

Combien de temps prend la leçon « Types valeur pour réduire le partage » ?

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. Notions de base d’ARC : strong, weak et unowned
  2. Cycles de rétention et rupture avec weak/unowned
  3. Types valeur pour réduire le partage
← Retour à Swift Academy