โพรโทคอลในฐานะสัญญา
กำหนดสัญญาพฤติกรรมโดยไม่ขึ้นกับชนิด
โพรโทคอลในฐานะสัญญา เป็นบทเรียน Swift Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Swift Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Swift Academy มีบทเรียนทั้งหมด 4 บทเรียน
โปรโตคอลคืออะไร
โปรโตคอลกำหนดแบบร่างของเมธอด คุณสมบัติ และข้อกำหนดอื่น ๆ ที่ชนิดซึ่งทำตามโปรโตคอลต้องนำไปใช้ โปรโตคอลเป็นสัญญา กล่าวคือชนิดใดก็ตามที่รับโปรโตคอลนั้นจะรับรองว่าจะจัดเตรียมทุกสิ่งที่โปรโตคอลประกาศไว้
protocol Greetable {
var name: String { get }
func greet() -> String
}การทำตามโปรโตคอล
ชนิดหนึ่งจะทำตามโปรโตคอลด้วยการรับโปรโตคอลนั้นและจัดเตรียมข้อกำหนดทุกข้อ ในที่นี้โครงสร้างหนึ่งทำให้ทั้งคุณสมบัติ name และเมธอด greet() ครบถ้วน
protocol Greetable {
var name: String { get }
func greet() -> String
}
struct Person: Greetable {
let name: String
func greet() -> String { "Hello, I am " + name }
}
let p = Person(name: "Ada")
print(p.greet())ข้อกำหนดของคุณสมบัติ
โปรโตคอลระบุว่าคุณสมบัติต้องอ่านได้ ({ get }) หรืออ่านและกำหนดค่าได้ทั้งคู่ ({ get set }) คุณสมบัติที่จัดเก็บค่าหรือคำนวณค่าก็สามารถทำตามข้อกำหนดที่อ่านได้อย่างเดียวได้
protocol Identifiable {
var id: String { get }
}
struct User: Identifiable {
let id: String
}
print(User(id: "u-1").id)ข้อกำหนดของเมธอด
ข้อกำหนดของเมธอดจะแสดงชื่อ พารามิเตอร์ และชนิดค่าที่คืนกลับ แต่ไม่มีส่วนเนื้อหาการทำงาน ชนิดที่ทำตามโปรโตคอลจะจัดเตรียมการนำไปใช้
protocol Shape {
func area() -> Double
}
struct Square: Shape {
let side: Double
func area() -> Double { side * side }
}
print(Square(side: 3).area())ข้อกำหนดแบบ mutating
สำหรับชนิดค่า เมธอดที่เปลี่ยนแปลง self ต้องระบุ mutating ให้ประกาศข้อกำหนดด้วย mutating เพื่อให้โครงสร้างสามารถทำตามข้อกำหนดได้
protocol Toggleable {
mutating func toggle()
}
struct Switch: Toggleable {
var isOn = false
mutating func toggle() { isOn.toggle() }
}
var s = Switch()
s.toggle()
print(s.isOn)โปรโตคอลในฐานะชนิด
โปรโตคอลเป็นชนิดระดับแรก คุณสามารถใช้โปรโตคอลกับตัวแปร พารามิเตอร์ และค่าที่คืนกลับ เพื่อยอมรับค่าใด ๆ ที่ทำตามโปรโตคอล
protocol Animal { func sound() -> String }
struct Dog: Animal { func sound() -> String { "Woof" } }
struct Cat: Animal { func sound() -> String { "Meow" } }
let animals: [Animal] = [Dog(), Cat()]
for a in animals { print(a.sound()) }พหุรูปผ่านโปรโตคอล
การเรียกเมธอดของโปรโตคอลจะส่งต่อไปยังชนิดจริงที่อยู่เบื้องหลังค่า วิธีนี้ทำให้คุณเขียนโค้ดที่ทำงานกับหลายชนิดได้ผ่านสัญญาเดียว
protocol Describable { func describe() -> String }
struct Book: Describable { let t: String; func describe() -> String { "Book: " + t } }
struct Film: Describable { let t: String; func describe() -> String { "Film: " + t } }
func show(_ d: Describable) { print(d.describe()) }
show(Book(t: "Swift"))
show(Film(t: "Inception"))ข้อกำหนดของตัวเริ่มต้น
โปรโตคอลสามารถกำหนดให้ต้องมีตัวเริ่มต้นได้ คลาสต้องระบุ required ให้กับการนำไปใช้ เพื่อให้คลาสย่อยจัดเตรียมตัวเริ่มต้นนี้ด้วย
protocol FromInt {
init(value: Int)
}
struct Wrapper: FromInt {
let value: Int
init(value: Int) { self.value = value }
}
print(Wrapper(value: 42).value)การสืบทอดโปรโตคอล
โปรโตคอลสามารถสืบทอดจากโปรโตคอลอื่นได้ตั้งแต่หนึ่งโปรโตคอลขึ้นไป และเพิ่มข้อกำหนดจากข้อกำหนดที่สืบทอดมา
protocol Named { var name: String { get } }
protocol Aged: Named { var age: Int { get } }
struct Member: Aged {
let name: String
let age: Int
}
let m = Member(name: "Lin", age: 30)
print(m.name, m.age)โปรโตคอลสำหรับคลาสเท่านั้น
ทำเครื่องหมายโปรโตคอลด้วย AnyObject เพื่อจำกัดการทำตามโปรโตคอลให้เหลือเฉพาะคลาส ซึ่งมีประโยชน์สำหรับข้อกำหนดที่ใช้ความหมายแบบอ้างอิง เช่น การมอบหมายงาน
protocol Counter: AnyObject {
var count: Int { get set }
}
class Box: Counter {
var count = 0
}
let b = Box()
b.count = 5
print(b.count)การตรวจสอบการทำตามโปรโตคอล
ใช้ is และ as? เพื่อตรวจสอบขณะทำงานว่าค่าหนึ่งทำตามโปรโตคอลหรือไม่
protocol Flyer { func fly() }
struct Bird: Flyer { func fly() { print("flap") } }
struct Rock {}
let things: [Any] = [Bird(), Rock()]
for t in things {
if let f = t as? Flyer { f.fly() } else { print("grounded") }
}ตรวจสอบอย่างรวดเร็ว
ทดสอบความเข้าใจเกี่ยวกับข้อกำหนดของโปรโตคอล
สรุปทบทวน
คุณได้เรียนรู้ว่าโปรโตคอลคือสัญญา ซึ่งประกาศข้อกำหนดด้านคุณสมบัติ เมธอด การเปลี่ยนแปลงค่า และตัวเริ่มต้นโดยไม่มีการนำไปใช้ ชนิดต่าง ๆ ทำตามโปรโตคอลด้วยการทำให้ข้อกำหนดทุกข้อครบถ้วน โปรโตคอลสามารถใช้เป็นชนิดเพื่อรองรับพหุรูป สืบทอดจากโปรโตคอลอื่น และจำกัดให้ใช้ได้เฉพาะคลาสด้วย AnyObject
คำถามที่พบบ่อย
บทเรียน “โพรโทคอลในฐานะสัญญา” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “โพรโทคอลในฐานะสัญญา” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Swift Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Swift Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “โพรโทคอลในฐานะสัญญา”
กำหนดสัญญาพฤติกรรมโดยไม่ขึ้นกับชนิด คุณปฏิบัติ Swift Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Swift Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Swift Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน
บทเรียน “โพรโทคอลในฐานะสัญญา” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Swift Academy นี้ได้ไหม
ได้ บทเรียน Swift Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- โพรโทคอลในฐานะสัญญา
- การใช้งานเริ่มต้นในส่วนขยาย
- การประกอบโพรโทคอล
- การสอดคล้องตามเงื่อนไข