0Pricing
Swift Academy · บทเรียน

โพรโทคอลในฐานะสัญญา

กำหนดสัญญาพฤติกรรมโดยไม่ขึ้นกับชนิด

โพรโทคอลในฐานะสัญญา เป็นบทเรียน 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. โพรโทคอลในฐานะสัญญา
  2. การใช้งานเริ่มต้นในส่วนขยาย
  3. การประกอบโพรโทคอล
  4. การสอดคล้องตามเงื่อนไข
← กลับไปที่ Swift Academy