Patron Stratégie

Fait partie de la section Programmation orientée objet du Journey Swift de Coddy. Leçon 45 sur 57.

Le modèle strategy place chaque variante d’un algorithme dans son propre type derrière un protocole partagé. Le code qui l’utilise conserve une stratégie et peut la remplacer à l’exécution :

protocol ShippingStrategy {
    func cost(weight: Int) -> Int
}
struct Standard: ShippingStrategy { func cost(weight: Int) -> Int { 5 + weight } }
struct Express: ShippingStrategy { func cost(weight: Int) -> Int { 15 + weight * 2 } }

struct Checkout {
    var shipping: any ShippingStrategy
    func total(price: Int, weight: Int) -> Int { price + shipping.cost(weight: weight) }
}

var c = Checkout(shipping: Standard())
print(c.total(price: 100, weight: 3))
c.shipping = Express()
print(c.total(price: 100, weight: 3))

Sortie :

108
121

En Swift, une fermeture suffit souvent pour une stratégie à une seule méthode. Le type stocke une fonction et l’appelle :

struct Sorter {
    var rule: (String, String) -> Bool
    func sort(_ words: [String]) -> [String] { words.sorted(by: rule) }
}

let words = ["banana", "kiwi", "apple"]
var s = Sorter(rule: <)
print(s.sort(words))
s.rule = { $0.count < $1.count }
print(s.sort(words))

Sortie :

["apple", "banana", "kiwi"]
["kiwi", "apple", "banana"]

La stratégie remplace un switch à l’intérieur de l’algorithme. Les nouvelles variantes sont de nouveaux types (ou fermetures), et le code qui les utilise reste inchangé :

// sans stratégie : chaque nouvelle option modifie cette fonction
func cost(kind: String, weight: Int) -> Int {
    switch kind { case "standard": return 5 + weight; default: return 15 + weight * 2 }
}
// avec une stratégie : Checkout ne change jamais
struct Overnight: ShippingStrategy { func cost(weight: Int) -> Int { 40 } }

Les stratégies peuvent être choisies à partir de données, par exemple d’un paramètre utilisateur, à l’aide d’une petite fabrique :

protocol Discount { func apply(_ price: Int) -> Int }
struct NoDiscount: Discount { func apply(_ p: Int) -> Int { p } }
struct Percent: Discount { let rate: Int; func apply(_ p: Int) -> Int { p - p * rate / 100 } }

func discount(for member: String) -> any Discount {
    member == "gold" ? Percent(rate: 20) : NoDiscount()
}

print(discount(for: "gold").apply(200))
print(discount(for: "basic").apply(200))

Sortie :

160
200

Défi

Facile

L’attaque d’un personnage de jeu est une stratégie. Le protocole Attack possède name et damage(strength:) -> Int. Implémentez Sword (strength * 2), Bow (strength + 5) et Magic (un mana stocké ; les dégâts valent strength * 3 lorsque mana est supérieur ou égal à 10, et 1 sinon ; damage lui-même ne modifie pas mana). Hero stocke sa strength et son attack, et strike() renvoie Ada hits with sword for 20.

Le code fourni lit le nom et la force du héros, puis les commandes equip sword, equip bow, equip magic 15 ou strike. Il affiche le résultat de chaque attaque.

Votre code doit être placé dans Attack.swift, Sword.swift, Bow.swift, Magic.swift et Hero.swift. main.swift contient le code fourni pour les entrées et les sorties et ne peut pas être modifié.

Essayez vous-même

// Code d'entrée/sortie fourni : le garder tel quel
var input: [String] = []
while let line = readLine() { input.append(line) }
let head = input[0].split(separator: ",").map(String.init)
var hero = Hero(name: head[0], strength: Int(head[1])!, attack: Sword())
for cmd in input.dropFirst() {
    let p = cmd.split(separator: " ").map(String.init)
    if p[0] == "strike" { print(hero.strike()); continue }
    switch p[1] {
    case "bow": hero.attack = Bow()
    case "magic": hero.attack = Magic(mana: Int(p[2])!)
    default: hero.attack = Sword()
    }
}