Swift Academy · บทเรียน

ทางเลือกแทนรูปแบบตัวสังเกต

เปรียบเทียบกับเดเลเกตและผู้เผยแพร่ของ Combine

ทางเลือกแทนรูปแบบตัวสังเกต เป็นบทเรียน Swift Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Swift Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Swift Academy มีบทเรียนทั้งหมด 4 บทเรียน

ทางเลือกอื่นของรูปแบบตัวเฝ้าดู

NotificationCenter เป็นวิธีหนึ่งในการโต้ตอบกับเหตุการณ์ ภาษา Swift ยังมีทางเลือกอื่น ได้แก่ การมอบหมายหน้าที่ คอมไบน์ และลำดับแบบอะซิงก์ แต่ละแบบเหมาะกับรูปแบบการสื่อสารที่แตกต่างกัน

รูปแบบตัวเฝ้าดู

รูปแบบตัวเฝ้าดูทำให้อ็อบเจกต์ต่าง ๆ สมัครรับเหตุการณ์จากหัวข้อได้ NotificationCenter เป็นการนำรูปแบบนี้มาใช้ในลักษณะระดับทั่วทั้งระบบและเชื่อมโยงกันอย่างหลวม ๆ

import Foundation

// Subject posts, observers react, neither holds the other.
NotificationCenter.default.post(name: Notification.Name("tick"), object: nil)
print("Broadcast an event")

การมอบหมายหน้าที่

delegate คือการเชื่อมโยงแบบหนึ่งต่อหนึ่ง อ็อบเจกต์จะส่งต่อเหตุการณ์เฉพาะไปยัง delegate เพียงตัวเดียวผ่านโปรโตคอล วิธีนี้ชัดเจนและปลอดภัยด้านชนิดข้อมูล

protocol DownloadDelegate: AnyObject {
    func didFinish(_ bytes: Int)
}
class Downloader {
    weak var delegate: DownloadDelegate?
    func finish() { delegate?.didFinish(1024) }
}
print("Delegate is one-to-one and typed")

delegate เทียบกับการแจ้งเตือน

ใช้ delegate เมื่อมีอ็อบเจกต์เพียงหนึ่งตัวที่สนใจและความสัมพันธ์นั้นชัดเจน ใช้ NotificationCenter เมื่ออาจมีตัวเฝ้าดูจำนวนมากที่ไม่ทราบล่วงหน้าเข้ามาโต้ตอบ

import Foundation

// One listener -> delegate. Many/unknown listeners -> NotificationCenter.
print("Cardinality guides the choice")

ตัวเผยแพร่ของคอมไบน์

คอมไบน์ จำลองเหตุการณ์เป็นตัวเผยแพร่ที่คุณสมัครรับด้วย sink และรองรับตัวดำเนินการแปลง เช่น map และ filter

import Combine

let subject = PassthroughSubject<Int, Never>()
let c = subject.sink { print("Got \($0)") }
subject.send(5)
_ = c

ตัวเผยแพร่ของ NotificationCenter

คอมไบน์เชื่อมต่อกับ NotificationCenter ได้ด้วย publisher(for:) ซึ่งเปลี่ยนการแจ้งเตือนให้เป็นสายข้อมูลที่คุณสามารถแปลงได้

import Foundation
import Combine

let name = Notification.Name("ping")
let c = NotificationCenter.default.publisher(for: name)
    .sink { _ in print("Combine got notification") }
NotificationCenter.default.post(name: name, object: nil)
_ = c

ตัวดำเนินการของคอมไบน์

จุดแข็งของคอมไบน์คือการประกอบสายงานเหตุการณ์ ได้แก่ การกรอง การหน่วงเวลา การรวม และการแปลงค่าในรูปแบบประกาศ

import Combine

let subject = PassthroughSubject<Int, Never>()
let c = subject
    .filter { $0 > 0 }
    .map { $0 * 2 }
    .sink { print($0) }
subject.send(-1)
subject.send(3)
_ = c

ลำดับแบบอะซิงก์

Swift รุ่นใหม่มี AsyncStream และลำดับการแจ้งเตือนแบบอะซิงก์ ทำให้คุณใช้ for await เพื่อรับเหตุการณ์ภายในการทำงานพร้อมกันแบบมีโครงสร้าง

import Foundation

func listen() async {
    let name = Notification.Name("ping")
    for await _ in NotificationCenter.default.notifications(named: name) {
        print("Async observed")
        break
    }
}
print("Can await notifications")

โคลเชอร์และการเรียกกลับ

สำหรับการเรียกกลับครั้งเดียวในขอบเขตเฉพาะ โคลเชอร์ที่จัดเก็บไว้เป็นวิธีที่ง่ายที่สุด โดยไม่ต้องมีกลไกตัวเฝ้าดูเลย

struct Button {
    var onTap: () -> Void
    func tap() { onTap() }
}
Button(onTap: { print("tapped") }).tap()

การเลือกแนวทาง

delegate: หนึ่งต่อหนึ่งและชัดเจน NotificationCenter: หลายต่อหลายและแยกออกจากกัน คอมไบน์/อะซิงก์: สายข้อมูลที่ต้องแปลง Closure: การเรียกกลับเฉพาะจุดที่เรียบง่าย

import Foundation

// Match the tool to the communication shape.
print("Delegate, Notification, Combine, async, closure")

ข้อแลกเปลี่ยน

NotificationCenter ยืดหยุ่น แต่ไม่มีชนิดข้อมูลกำกับและทำให้เกิดการรั่วไหลได้ง่าย การมอบหมายหน้าที่และคอมไบน์ปลอดภัยด้านชนิดข้อมูล ส่วนคอมไบน์และอะซิงก์เพิ่มความสามารถ แต่ต้องทำความเข้าใจกับแนวคิดมากขึ้น

import Foundation

// Prefer typed approaches when the relationship is known.
print("Type safety vs flexibility tradeoff")

ตรวจสอบความเข้าใจ

กลไกใดเหมาะที่สุดสำหรับความสัมพันธ์แบบหนึ่งต่อหนึ่งที่ชัดเจนและปลอดภัยด้านชนิดข้อมูล

ทบทวน

รูปแบบตัวเฝ้าดูมีหลายรูปแบบใน Swift ได้แก่ NotificationCenter สำหรับเหตุการณ์แบบหลายต่อหลายที่แยกผู้ส่งและผู้รับออกจากกัน การมอบหมายหน้าที่ สำหรับการเชื่อมโยงแบบหนึ่งต่อหนึ่งที่มีชนิดข้อมูลกำกับ คอมไบน์ และ ลำดับแบบอะซิงก์ สำหรับสายข้อมูลที่นำมาประกอบกันได้ และโคลเชอร์สำหรับการเรียกกลับอย่างง่าย เลือกใช้ตามรูปแบบการสื่อสารและความต้องการด้านความปลอดภัยของชนิดข้อมูล บทเรียนนี้จบลงเพียงเท่านี้

คำถามที่พบบ่อย

บทเรียน “ทางเลือกแทนรูปแบบตัวสังเกต” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “ทางเลือกแทนรูปแบบตัวสังเกต” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Swift Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Swift Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “ทางเลือกแทนรูปแบบตัวสังเกต”

เปรียบเทียบกับเดเลเกตและผู้เผยแพร่ของ Combine คุณปฏิบัติ Swift Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Swift Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Swift Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “ทางเลือกแทนรูปแบบตัวสังเกต” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Swift Academy นี้ได้ไหม

ได้ บทเรียน Swift Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

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

การโพสต์และสังเกตการแจ้งเตือน
ข้อมูลส่วนเพิ่มเติม userInfo ของการแจ้งเตือน
การนำตัวสังเกตออกอย่างปลอดภัย
ทางเลือกแทนรูปแบบตัวสังเกต

← กลับไปที่ Swift Academy