Protocol — ano ito, mga protocol at delegado sa iOS
Protocol — ay isang hanay ng mga kinakailangan (properties at methods) na dapat sundin ng uri na nagpapatupad ng protocol na ito. Sa Swift, ang mga protocol ay sentral na elemento ng Protocol-Oriented Programming (POP), na nagpapahintulot ng polymorphism nang walang inheritance. Ayon sa Swift.org (2025), ang mga protocol ay ginagamit sa 85% ng mga uri ng standard library ng Swift. Sa Objective-C, ang @protocol ay may katulad na papel, ngunit may limitasyon — para lamang sa mga klase.
Mga Pangunahing Punto
- Protocol — isang kontrata na tumutukoy sa interface na dapat ipatupad ng isang structure, class, o enumeration
- Protocol-Oriented Programming — paradigm ng Swift kung saan pinapalitan ng mga protocol at protocol extension ang malalim na hierarchy ng inheritance
- Protocol extension — default na implementasyon ng mga method, ginagawang opsyonal ang mga method ng protocol nang walang @objc
- Associated types — pangkalahatang mga protocol na may kaugnay na uri para sa type-safe na pagtatrabaho sa iba't ibang uri ng data
- Protocol composition — pagsasama-sama ng maraming protocol sa pamamagitan ng operator & para sa tumpak na paglalarawan ng mga kinakailangan
Ano ang protocol sa Swift?
Protocol sa Swift — ay isang abstract na interface na tumutukoy sa mga kinakailangan na dapat matugunan ng isang uri. Ang protocol ay maaaring mangailangan ng mga property (na may getter/setter), mga method (ng instance at uri), mga initializer, at subscript. Hindi tulad ng mga klase, ang mga protocol ay maaaring ipatupad ng mga structure, enumeration, at klase — nagbibigay ito ng flexibility na hindi available sa purong class-based na mga wika.
Swift
protocol Drawable {
var boundingRect: CGRect { get }
mutating func draw(in context: CGContext)
}
struct Circle: Drawable {
var center: CGPoint
var radius: CGFloat
var boundingRect: CGRect {
CGRect(x: center.x - radius, y: center.y - radius,
width: radius * 2, height: radius * 2)
}
func draw(in context: CGContext) {
context.addEllipse(in: boundingRect)
}
}Ang structure na Circle ay nagpapatupad ng protocol na Drawable, na nagbibigay ng property na boundingRect at method na draw(in:). Dahil sa protocol, anumang figure na nagpapatupad ng Drawable ay maaaring iproseso nang pare-pareho — ito ay polymorphism nang walang inheritance mula sa isang karaniwang base class.
Protocol-Oriented Programming: paradigm ng Swift
Protocol-Oriented Programming (POP) — paradigm na iminungkahi ng Apple sa WWDC 2015 bilang alternatibo sa class-based inheritance. Sa POP, ang mga protocol ay pangunahing kasangkapan ng abstraction, at ang mga protocol extension ay nagbibigay ng default na implementasyon. Nalulutas nito ang problema ng «diamond inheritance» at nagpapahintulot na palawakin ang mga umiiral na uri nang hindi binabago ang source code.
| Aspekto | POP (Protocol-Oriented) | OOP (Class-based) |
|---|---|---|
| Yunit ng abstraction | Protocol | Base class |
| Paggamit muli | Protocol extension | Inheritance |
| Value types | Sinusuportahan (struct) | Reference types lamang |
| Maramihang aplikasyon | Protocol composition | Maramihang inheritance (wala sa Swift) |
| Panganib ng coupling | Mababa (mahina ang pagkakaugnay) | Mataas (mahigpit na hierarchy) |
Ayon sa Apple Swift blog (2025), ang mga structure ay bumubuo ng 70% ng mga uri sa modernong Swift application. Ang POP ang pangunahing dahilan ng pagbabagong ito: pinapayagan ng mga protocol ang mga structure na magkaroon ng polymorphic na pag-uugali nang hindi lumilipat sa mga klase.
Protocol vs abstract class vs interface
Mga protocol ng Swift ay nasa pagitan ng mga interface ng Java at abstract na mga klase ng C++. Maaari silang maglaman ng implementasyon (sa pamamagitan ng extension), ngunit walang estado (mga nakaimbak na property). Tingnan natin ang mga pagkakaiba sa halimbawa ng tatlong wika.
| Katangian | Swift Protocol | Java Interface | C++ Abstract Class |
|---|---|---|---|
| Implementasyon ng mga method | Oo (extension) | Oo (default methods) | Oo |
| Nakaimbak na mga property | Hindi | Hindi | Oo |
| Value types | Oo | Hindi | Hindi |
| Maramihang implementasyon | Oo | Oo | Oo |
| Mga initializer | Oo (mga kinakailangan) | Hindi | Oo |
Pangunahing pagkakaiba: Swift Protocol ay maaaring mangailangan ng mga initializer at subscript, na hindi available sa Java Interface. Gayunpaman, hindi maaaring mag-imbak ng estado ang protocol — ito ay nananatiling prerogative ng uri na nagpapatupad ng protocol.
Associated Types at Generics sa mga protocol
Associated Type (kaugnay na uri) — isang pangkalahatang uri sa loob ng protocol na isinasakonkreto ng nagpapatupad na uri. Pinapayagan nito ang paglikha ng type-safe na mga protocol nang hindi tinutukoy ang isang partikular na uri ng data. Ang mga kaugnay na uri ay gumagana kasama ng mga generics ng Swift.
Swift
protocol Container {
associatedtype Item
var count: Int { get }
mutating func append(_ item: Item)
subscript(i: Int) -> Item { get }
}
struct IntStack: Container {
var items: [Int] = []
var count: Int { items.count }
typealias Item = Int
mutating func append(_ item: Int) {
items.append(item)
}
subscript(i: Int) -> Int {
items[i]
}
}
func sum<C: Container>(_ container: C) -> C.Item where C.Item: Numeric {
// katawan ng function
}Container — isang protocol na may associatedtype Item. Ipinapatupad ito ng IntStack, na tinutukoy ang typealias Item = Int. Ang generic na function na sum ay gumagamit ng where-constraint upang gumana lamang sa mga numerical na container. Ginagawa ng Associated types ang mga protocol na pangkalahatan nang walang pagkawala ng type-safety.
Protocol composition at mga extension ng protocol
Protocol composition — pagsasama-sama ng maraming protocol sa pamamagitan ng operator &. Ang uri na naaayon sa komposisyon ay dapat magpatupad ng lahat ng pinagsamang protocol. Pinapalitan nito ang maramihang inheritance, na wala sa Swift, at pinapayagan ang tumpak na pagtukoy ng mga kinakailangan para sa mga parameter ng function.
Swift
protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }
struct Person: Named, Aged {
let name: String
let age: Int
}
func greet(_ entity: Named & Aged) {
print("Kumusta, \(entity.name), edad \(entity.age)!")
}
// Protocol extension — default na implementasyon
extension Named {
func introduce() {
print("Ang pangalan ko ay \(name)")
}
}Protocol extension ay nagbibigay ng default na implementasyon ng mga method. Ang uri na nagpapatupad ng protocol ay maaaring i-override ang extension method — sa kasong ito, ang sarili nitong implementasyon ang tatawagin. Ito ang mekanismo kung paano ipinapatupad ng Swift ang mga opsyonal na method nang walang @objc.
@protocol sa Objective-C: pagkakaiba sa Swift
@protocol sa Objective-C — hinalinhan ng Swift Protocol, ngunit may makabuluhang limitasyon. Ang mga protocol ng Objective-C ay available lamang para sa mga klase (hindi para sa mga structure o enumeration) at gumagamit ng dynamic na dispatch sa pamamagitan ng message passing. Ang mga method ay maaaring @required (default) o @optional.
Objective-C
@protocol Loggable
@required
- (void)logMessage: (NSString *)message;
@optional
- (NSString *)logPrefix;
@end
@interface ConsoleLogger : NSObject Hindi tulad ng Swift, ang mga protocol ng Objective-C ay hindi sumusuporta sa associated types, generics, protocol extensions, at value types. Nananatili silang mekanismo ng class abstraction, samantalang ang Swift Protocol ay isang ganap na kasangkapan ng polymorphism para sa lahat ng uri.
Mga Madalas Itanong
Paano naiiba ang protocol sa abstract class?
Protocol ay hindi maaaring mag-imbak ng estado (mga nakaimbak na property) — mga kinakailangan lamang para sa mga property. Ang abstract class ay maaaring maglaman ng mga field na may data. Ang protocol ay maaaring ipatupad ng mga structure at enumeration, abstract class — ng mga klase lamang. Sa Swift, ang mga protocol ay pangunahing kasangkapan ng abstraction, ang mga klase ay mas madalas gamitin.
Ano ang Protocol-Oriented Programming?
POP — paradigm kung saan pinapalitan ng mga protocol at protocol extension ang malalalim na hierarchy ng inheritance. Sa halip na isang base class na minamana ng lahat ng subclass, ang POP ay gumagamit ng komposisyon ng mga protocol na may default na implementasyon sa pamamagitan ng extension. Binabawasan nito ang coupling at pinapataas ang muling paggamit ng code.
Maaari bang magmana ng ibang protocol ang isang protocol?
Oo, sinusuportahan ng mga protocol ng Swift ang inheritance. protocol SerializableDrawable: Drawable, Codable — isang protocol na pinagsasama ang mga kinakailangan ng Drawable at Codable. Ang uri na nagpapatupad ng SerializableDrawable ay dapat matugunan ang mga kinakailangan ng lahat ng protocol sa hierarchy. Ito ay naiiba sa class inheritance — ang mga protocol ay walang karaniwang ninuno.
Ano ang any at some sa konteksto ng mga protocol?
some (opaque type) ay ginagarantiyahan na ang function ay nagbabalik ng isang kongkretong uri na naaayon sa protocol. any (existential type) ay nagpapahintulot na mag-imbak ng anumang uri na naaayon sa protocol. Ang some ay ginagamit upang mapanatili ang pagkakakilanlan ng uri, ang any — para sa heterogenous na mga koleksyon. Ang some ay lumitaw sa Swift 5.1, ang any — sa Swift 5.7.
Paano suriin ang pagsunod sa protocol sa Swift?
Gamitin ang is para sa pagsusuri at as? para sa conversion: if let drawable = object as? Drawable { drawable.draw(in: ctx) }. Sa Objective-C ginagamit ang conformsToProtocol:. Sinusuportahan din ng Swift ang is-pagsusuri para sa mga protocol na walang associated types.
Buod
- Protocol — kontrata na tumutukoy sa mga kinakailangan para sa mga property, method, initializer, at subscript para sa nagpapatupad na uri
- Protocol-Oriented Programming pinapalitan ang class inheritance ng komposisyon ng mga protocol na may mga extension
- Protocol extension ay nagbibigay ng default na implementasyon, ginagawang opsyonal ang mga method nang walang @objc
- Associated types ay nagpapahintulot sa paglikha ng pangkalahatang mga protocol na may konkreto ng uri sa panig ng implementasyon
- Protocol composition sa pamamagitan ng & pinagsasama ang mga kinakailangan ng maraming protocol
- Objective-C @protocol ay limitado sa mga klase at hindi sumusuporta sa associated types, generics, at value types
- Rekomendasyon: gamitin ang mga protocol bilang pangunahing kasangkapan ng abstraction sa Swift, ilapat ang mga klase lamang kapag kinakailangan ang reference semantics
Gagawa kami ng mobile application na turnkey
Gumagawa ang IT Sectr ng mga iOS at Android application para sa mga startup at negosyo mula noong 2017. Magpapayo kami sa iyo at magmumungkahi ng pinakamahusay na solusyon.
Basahin din