Réutilisabilité et contraintes
Concevez des wrappers génériques avec des contraintes de type (par exemple Value: Comparable ), ajoutez des API ciblées avec where et composez plusieurs wrappers.
Réutilisabilité et contraintes est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 2 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 les contraintes ?
Écrivez une seule enveloppe et réutilisez-la avec de nombreux types en la rendant générique grâce aux contraintes. Ajoutez des API ciblées avec des clauses where et composez de petites enveloppes.
Générique + Comparable
Utilisez Comparable pour qu’une seule enveloppe Bounded fonctionne avec Int, String, etc. Les types invalides sont rejetés à la compilation.
@propertyWrapper
struct Bounded<Value: Comparable> {
private var value: Value
private let range: ClosedRange<Value>
var wrappedValue: Value {
get { value }
set {
// clamp using Comparable
if newValue < range.lowerBound { value = range.lowerBound }
else if newValue > range.upperBound { value = range.upperBound }
else { value = newValue }
}
}
init(wrappedValue: Value, _ range: ClosedRange<Value>) {
self.range = range
self.value = min(max(wrappedValue, range.lowerBound), range.upperBound)
}
}
struct Stats {
@Bounded(0...100) var score: Int = 120
@Bounded("a"..."z") var letter: String = "Swift"
}
var st = Stats()
print(st.score) // 100
st.letter = "m"
print(st.letter)Extensions avec contraintes
Utilisez where pour proposer des fonctionnalités supplémentaires uniquement lorsque le type les prend en charge (par exemple, des indicateurs entiers ou des mises à jour en virgule flottante).
extension Bounded where Value: BinaryInteger {
var isMaxed: Bool { wrappedValue == range.upperBound }
}
extension Bounded where Value: FloatingPoint {
mutating func bump(by delta: Value) { wrappedValue = wrappedValue + delta }
}
struct Meter {
@Bounded(0...10) var steps: Int = 9
@Bounded(0.0...1.0) var progress: Double = 0.25
}
var m = Meter()
print(m.$steps) // projectedValue not defined; accessing wrapper is not allowed directly here
print(m._steps) // compiler creates backing storage name; shown for illustration only
print(m.steps) // 9
print(m._progress) // backing storage (illustrative)
m._progress.bump(by: 0.6)
print(m.progress) // 0.85 (clamped if exceeded)Enveloppe réservée aux collections
Limitez les API aux collections en ajoutant une contrainte sur RangeReplaceableCollection. Cela fonctionne avec String et Array.
@propertyWrapper
struct MaxLength<Value: RangeReplaceableCollection> where Value.Element: Sendable {
private var storage: Value
private let limit: Int
var wrappedValue: Value {
get { storage }
set {
var v = newValue
if v.count > limit { v.removeLast(v.count - limit) }
storage = v
}
}
init(wrappedValue: Value, _ limit: Int) {
self.limit = limit
self.storage = wrappedValue
if storage.count > limit { storage.removeLast(storage.count - limit) }
}
}
struct Post {
@MaxLength(10) var title: String = "hello swift learners"
@MaxLength(5) var tags: [String] = ["swift","ios","spm"]
}
var p = Post()
print(p.title) // "hello swif"
print(p.tags) // ["swift","ios","spm"]Composition d’enveloppes
Vous pouvez empiler de petites enveloppes. Ici, Trimmed s’exécute d’abord, puis NonEmpty garantit une valeur de repli.
@propertyWrapper
struct Trimmed {
private var s: String = ""
var wrappedValue: String {
get { s }
set { s = newValue.trimmingCharacters(in: .whitespacesAndNewlines) }
}
init(wrappedValue: String) { self.wrappedValue = wrappedValue }
}
@propertyWrapper
struct NonEmpty {
private var s: String = ""
var wrappedValue: String {
get { s }
set { s = newValue.isEmpty ? "N/A" : newValue }
}
init(wrappedValue: String) { self.wrappedValue = wrappedValue }
}
struct Profile {
@NonEmpty @Trimmed var displayName: String = " "
}
var prof = Profile()
print(prof.displayName) // "N/A"Variables locales + réutilisation
Les enveloppes fonctionnent également avec les variables locales. Gardez-les génériques pour pouvoir les réutiliser entre les modules.
@propertyWrapper
struct Default<Value> {
private var value: Value
private let make: () -> Value
var wrappedValue: Value {
get { value }
set { value = newValue }
}
init(wrappedValue: Value, _ factory: @escaping () -> Value) {
self.value = wrappedValue
self.make = factory
}
mutating func reset() { value = make() }
}
// Local variable usage
do {
@Default({ 0 }) var counter: Int = 5
print(counter) // 5
_counter.reset()
print(counter) // 0
}Contrainte de compilation sur l’enveloppe
Vérification rapide : comment restreindre une enveloppe aux types Comparable ?
Récapitulatif
Récapitulatif : rendez les enveloppes génériques, ajoutez des contraintes pour garantir une utilisation sûre, exposez des API ciblées avec des clauses where et composez de petites enveloppes pour améliorer la clarté.
Questions Fréquemment Posées
La leçon « Réutilisabilité et contraintes » est-elle gratuite ?
Oui — le texte complet de « Réutilisabilité et contraintes » 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 « Réutilisabilité et contraintes » ?
Concevez des wrappers génériques avec des contraintes de type (par exemple Value: Comparable ), ajoutez des API ciblées avec where et composez plusieurs wrappers. 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 2 sur 3.
Combien de temps prend la leçon « Réutilisabilité et contraintes » ?
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)