Dans Swift, lors de l'apprentissage de l'interface utilisateur (UI), tĂŽt ou tard, tout le monde en vient Ă la nĂ©cessitĂ© d'utiliser un dĂ©lĂ©guĂ©. Tous les guides Ă©crivent Ă leur sujet, et vous semblez faire ce qui est Ă©crit lĂ -bas, et cela semble fonctionner, mais pourquoi et comment cela fonctionne, tout le monde dans leur tĂȘte ne s'intĂšgre pas Ă la fin. Personnellement, j'ai mĂȘme eu le sentiment pendant un certain temps que le dĂ©lĂ©guĂ© est une sorte de mot magique, et qu'il est directement intĂ©grĂ© au langage de programmation (c'est Ă quel point mes pensĂ©es Ă©taient dĂ©routantes Ă partir de ces guides). Essayons d'expliquer en termes simples ce que c'est. Et une fois que vous aurez compris le dĂ©lĂ©guĂ©, il sera beaucoup plus facile de comprendre ce qu'est un rappel et comment il fonctionne.
Serveur et chef
Alors, avant de passer au code, imaginons un certain serveur et un chef. Le serveur a reçu une commande du client Ă table, mais lui-mĂȘme ne sait pas cuisiner, et il doit en parler au cuisinier. Il peut aller dans la cuisine et dire au cuisinier: «Faites cuire le poulet». Le cuisinier a les outils appropriĂ©s (poĂȘle, huile, feu ...) et les compĂ©tences culinaires. Le cuisinier prĂ©pare et donne le plat au serveur. Le serveur prend ce qui a Ă©tĂ© fait par le chef et l'apporte au client.
Imaginons maintenant une situation dans laquelle un serveur ne peut pas venir en courant Ă la cuisine et dire directement au cuisinier quel plat lui a Ă©tĂ© commandĂ©. Ils ne le laissent pas entrer dans la cuisine (par exemple, de telles rĂšgles) ou la cuisine est Ă un autre Ă©tage (vous en avez assez de courir). Et le seul moyen de communiquer est la fenĂȘtre du mini-ascenseur. Le serveur y met un mot, appuie sur le bouton, l'ascenseur se dirige vers la cuisine. Revient avec un plat prĂ©parĂ©. Te souviens tu? Maintenant, corrigeons la situation dans notre tĂȘte, essayons de la recrĂ©er Ă travers le code et comprenons comment elle se rapporte Ă notre sujet.
Passons au code
Nous créons les cours de serveur et de cuisine. Pour plus de simplicité, faisons cela dans la cour de récréation:
import UIKit
//
class Waiter {
/// "" - . , "private".
private var order: String?
/// " ".
func takeOrder(_ food: String) {
print("What would you like?")
print("Yes, of course!")
order = food
sendOrderToCook()
}
/// " ". . ?
private func sendOrderToCook() {
// ??? ?
}
/// " ". .
private func serveFood() {
print("Your \(order!). Enjoy your meal!")
}
}
//
class Cook {
/// "". .
private let pan: Int = 1
/// "". .
private let stove: Int = 1
/// "". .
private func cookFood(_ food: String) -> Bool {
print("Let's take a pan")
print("Let's put \(food) on the pan")
print("Let's put the pan on the stove")
print("Wait a few minutes")
print("\(food) is ready!")
return true
}
}Maintenant, nous en créons des copies (nous les embauchons pour travailler), et demandons au serveur de recevoir la commande (poulet):
// ( ):
let waiter = Waiter()
let cook = Cook()
// . , :
waiter.takeOrder("Chiken")Comment le serveur peut-il dire au cuisinier quoi cuisiner maintenant?
, , private. private, :
cook.cookFood(waiter.order!)
// 'cookFood' is inaccessible due to 'private' protection level
// 'order' is inaccessible due to 'private' protection level«» , private . "" , ? : " , , ?"
"". . . "" " ":
protocol InterchangeViaElevatorProtocol {
func cookOrder(order: String) -> Bool
}, "", , . . , . : , .
, . ().
. , , " ". Xcode . Bool .
cookFood, .
extension Cook: InterchangeViaElevatorProtocol {
func cookOrder(order: String) -> Bool {
cookFood(order)
}
}" ". , , .
extension Waiter {
var receiverOfOrderViaElevator: InterchangeViaElevatorProtocol? { return cook }
}, . return cook.
-: , . .
, . , .
:
import UIKit
protocol InterchangeViaElevatorProtocol {
func cookOrder(order: String) -> Bool
}
class Waiter {
// " ". , , .
var receiverOfOrderViaElevator: InterchangeViaElevatorProtocol?
var order: String?
func takeOrder(_ food: String) {
print("What would you like?")
print("Yes, of course!")
order = food
sendOrderToCook()
}
private func sendOrderToCook() {
// ??? ?
}
private func serveFood() {
print("Your \(order!). Enjoy your meal!")
}
}
//
class Cook: InterchangeViaElevatorProtocol {
private let pan: Int = 1
private let stove: Int = 1
private func cookFood(_ food: String) -> Bool {
print("Let's take a pan")
print("Let's put \(food) on the pan")
print("Let's put the pan on the stove")
print("Wait a few minutes")
print("\(food) is ready!")
return true
}
// , ():
func cookOrder(order: String) -> Bool {
cookFood(order)
}
}private order ( ).
:
- :
// :
let waiter = Waiter()
let cook = Cook()
// :
waiter.takeOrder("Chiken"), " " â .
// , " " - :
waiter.receiverOfOrderViaElevator = cook, , , .
" " :
// " " :
waiter.receiverOfOrderViaElevator?.cookOrder(order: waiter.order!), !
/*
What would you like?
Yes, of course!
Let's take a pan
Let's put Chiken on the pan
Let's put the pan on the stove
Wait a few minutes
Chiken is ready!
*/« », .
«» , « », , .
private func sendOrderToCook() {
// cookOrder " ":
receiverOfOrderViaElevator?.cookOrder(order: order!)
}! receiverOfOrderViaElevator, . . delegate, . , , .
? «, â . â UI?»
delegate UI?
UI , «» «». , table view collection view. table view collection view : . . () «» («Delegate»).
, Delegable «». , , !
, â . . Waiter. () hireWaiter. (, -):
// -
class Chief: InterchangeViaElevatorProtocol {
private let pan: Int = 1
private let stove: Int = 1
private func cookFood(_ food: String) -> Bool {
print("Let's take a pan")
print("Let's put \(food) on the pan")
print("Let's put the pan on the stove")
print("Wait a few minutes")
print("\(food) is ready!")
return true
}
// , ():
func cookOrder(order: String) -> Bool {
cookFood(order)
}
// - :
func hireWaiter() -> Waiter {
return Waiter()
}
}- ( - hireWaiter):
// - (- ):
let chief = Chief()
// - :
let waiter = chief.hireWaiter()
// :
waiter.takeOrder("Chiken"). , " " â -. .
// , " " - -:
waiter.receiverOfOrderViaElevator = chief
// " " :
waiter.receiverOfOrderViaElevator?.cookOrder(order: waiter.order!), .
. , -, , « » -.
class SmartChief: Chief {
override func hireWaiter() -> Waiter {
let waiter = Waiter()
waiter.receiverOfOrderViaElevator = self //
return waiter
}
}SmartChief Chief .
, - (), . !
let smartChief = SmartChief()
let smartWaiter = smartChief.hireWaiter()
smartWaiter.takeOrder("Fish")
/*
What would you like?
Yes, of course we have Fish!
Let's take a pan
Let's put Fish on the pan
Let's put the pan on the stove
Wait a few minutes
Fish is ready!
*/:
- (), , , , - .
- «» .
- (, ) , ( )
- , self «» .
, «» , , .
. , ! .
(, callback). ? ,
, , «» . , . ? ?
(callback) â , . . .
-,
, - ( , ). , , : «- ! , !» , , . .
.
. . , String Bool. cookFood ! - - .
///
class TalentedWaiter {
var order: String?
// . , String Bool.
var doEverything: ((String) -> Bool)?
func takeOrder(_ food: String) {
print("What would you like?")
print("Yes, of course we have \(food)!")
order = food
// - :
doOwnself()
}
private func doOwnself() -> Bool {
// , :
if let doEverything = doEverything {
let doOwnself = doEverything(order!)
return doOwnself
} else {
return false
}
}
}-. , , . , . , :
// -
class LazyChief {
private let pan: Int = 1
private let stove: Int = 1
private func cookFood(_ food: String) -> Bool {
print("I have \(pan) pan")
print("Let's put \(food) on the pan!")
print("I have \(stove) stove. Let's put the pan on the stove!")
print("Wait a few minutes...")
print("\(food) is ready!")
return true
}
// :
func hireWaiter() -> TalentedWaiter {
let talentedWaiter = TalentedWaiter()
// . , cookFood:
talentedWaiter.doEverything = { order in
self.cookFood(order)
}
return talentedWaiter
}
}-, , , :
let lazyChief = LazyChief()
let talentedWaiter = lazyChief.hireWaiter()
talentedWaiter.takeOrder("Meat")
/*
What would you like?
Yes, of course we have Meat!
I have 1 pan
Let's put Meat on the pan!
I have 1 stove. Let's put the pan on the stove!
Wait a few minutes...
Meat is ready!
*/, , «» .
, , . , , ().
â . , self , - , .
[weak self] in . , !
talentedWaiter.doEverything = { [weak self] order in
self!.cookFood(order)
}. , . !