Créer des wrappers, projectedValue
Créez un wrapper personnalisé, configurez wrappedValue et exposez des métadonnées ou fonctions auxiliaires avec projectedValue ( $ ).
Créer des wrappers, projectedValue est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 1 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 enveloppes de propriétés ?
Une enveloppe de propriété est un type réutilisable qui gère la manière dont une propriété est stockée et lue :
- wrappedValue : la valeur publique
- projectedValue : une API supplémentaire via
$ - Configuration via des initialiseurs et des paramètres
Clamped et indicateur projeté
@Clamped limite un nombre à un intervalle. La projectedValue ($hp) indique si la dernière affectation a été limitée.
@propertyWrapper
struct Clamped {
private var value: Int
private let range: ClosedRange<Int>
private(set) var wasClampedLastSet = false
var wrappedValue: Int {
get { value }
set {
let clamped = min(max(newValue, range.lowerBound), range.upperBound)
wasClampedLastSet = (clamped != newValue)
value = clamped
}
}
var projectedValue: Bool { wasClampedLastSet } // $prop -> was it clamped?
init(wrappedValue: Int, range: ClosedRange<Int>) {
self.range = range
let clamped = min(max(wrappedValue, range.lowerBound), range.upperBound)
self.value = clamped
self.wasClampedLastSet = (clamped != wrappedValue)
}
}
struct Player {
@Clamped(range: 0...100) var hp: Int = 120 // init clamps to 100
}
var p = Player()
print(p.hp) // 100
p.hp = -5
print(p.hp, p.$hp) // 0 true (was clamped)Normalisation et vue alternative
Les enveloppes peuvent transformer l'entrée (supprimer les espaces ou la mettre en minuscules). $property peut exposer une forme alternative pratique.
@propertyWrapper
struct Normalized {
private var storage: String = ""
var wrappedValue: String {
get { storage }
set { storage = newValue.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() }
}
var projectedValue: String { storage.uppercased() } // alternate view
init(wrappedValue: String) { self.wrappedValue = wrappedValue }
}
struct User {
@Normalized var username: String = " Alice "
}
let u = User()
print(u.username) // "alice"
print(u.$username) // "ALICE" (projected)Enveloppe configurable
Transmettez des paramètres aux enveloppes (par exemple, la longueur). L'enveloppe applique la mise en forme chaque fois que vous définissez la propriété.
@propertyWrapper
struct Padded {
private var value: String
private let length: Int
var wrappedValue: String {
get { value }
set {
let s = newValue
value = s.count >= length ? String(s.prefix(length))
: s + String(repeating: " ", count: length - s.count)
}
}
var projectedValue: Int { value.count } // current width
init(wrappedValue: String, length: Int) {
self.length = length
self.value = ""
self.wrappedValue = wrappedValue
}
}
struct Row {
@Padded(length: 6) var code: String = "AB"
}
var r = Row()
print("|\(r.code)|") // |AB |
print(r.$code) // 6Historique via $value
Utilisez projectedValue pour exposer des métadonnées, comme un historique des modifications, sans encombrer l'API de la valeur principale.
@propertyWrapper
struct History<Value> {
private var value: Value
private(set) var changes: [Value] = []
var wrappedValue: Value {
get { value }
set { changes.append(value); value = newValue }
}
var projectedValue: [Value] { changes } // $prop -> previous values
init(wrappedValue: Value) { self.value = wrappedValue }
}
struct Settings {
@History var level: Int = 1
}
var s = Settings()
s.level = 2
s.level = 3
print(s.level) // 3
print(s.$level) // [1, 2]Conseils de conception
Conseils :
- Gardez les enveloppes petites et ciblées.
- Documentez ce que $projectedValue expose.
- Préférez les transformations pures ; évitez les effets secondaires importants.
- Fournissez des initialiseurs clairs et des valeurs par défaut pertinentes.
Objectif de la valeur projetée
Vérification rapide : à quoi sert $property dans les enveloppes ?
Récapitulatif
Récapitulatif : implémentez @propertyWrapper avec un wrappedValue ; exposez des fonctions auxiliaires, des indicateurs ou un historique via projectedValue ($), et configurez le comportement au moyen d'initialiseurs.
Questions Fréquemment Posées
La leçon « Créer des wrappers, projectedValue » est-elle gratuite ?
Oui — le texte complet de « Créer des wrappers, projectedValue » 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 « Créer des wrappers, projectedValue » ?
Créez un wrapper personnalisé, configurez wrappedValue et exposez des métadonnées ou fonctions auxiliaires avec projectedValue ( $ ). 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 1 sur 3.
Combien de temps prend la leçon « Créer des wrappers, projectedValue » ?
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
- Créer des wrappers, projectedValue
- Réutilisabilité et contraintes
- Modèles courants de wrappers (validation, mise en cache)