Swift Academy · บทเรียน

รูปแบบ Coordinator

รวมศูนย์ตรรกะลำดับการนำทาง

บทเรียน 3 จาก 413 ขั้นตอน

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

ปัญหาการนำทาง

เมื่อมุมมองผลักหรือแสดงมุมมองอื่นโดยตรง ตรรกะการนำทางจะถูก กระจัดกระจาย ไปทั่วแอป แต่ละหน้าจอต้องรู้จักหน้าจอถัดไป ทำให้เกิดการเชื่อมโยงที่แน่นหนา

รูปแบบตัวประสานงาน แก้ปัญหานี้ด้วยการแยกการนำทางออกมาไว้ในอ็อบเจ็กต์เฉพาะ

ตัวประสานงานคืออะไร

ตัวประสานงาน คืออ็อบเจ็กต์ที่มีหน้าที่เพียงจัดการ ลำดับการนำทาง โดยจะตัดสินใจว่าหน้าจอถัดไปคืออะไร และสร้างตัวควบคุมมุมมองหรือมุมมองที่จะแสดง

มุมมองไม่จำเป็นต้องรู้เรื่องการกำหนดเส้นทางอีกต่อไป — มุมมองเพียงส่งสัญญาณเหตุการณ์ แล้วตัวประสานงานจะตัดสินใจว่าจะทำอะไร

โพรโทคอลของตัวประสานงาน

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

protocol Coordinator: AnyObject {
    var childCoordinators: [Coordinator] { get set }
    func start()
}

ตัวประสานงานรูปธรรม

ตัวประสานงานรูปธรรมจะเป็นเจ้าของตัวควบคุมการนำทาง และสร้างหน้าจอแรกใน start()

final class AppCoordinator: Coordinator {
    var childCoordinators: [Coordinator] = []
    let navigationController: UINavigationController

    init(navigationController: UINavigationController) {
        self.navigationController = navigationController
    }

    func start() {
        let vc = HomeViewController()
        navigationController.setViewControllers([vc], animated: false)
    }
}

แยกมุมมองออกจากการกำหนดเส้นทาง

ประโยชน์สำคัญคือ มุมมองไม่ต้องสร้างหน้าจอถัดไปอีกต่อไป แต่จะแจ้งตัวประสานงานว่าเกิดเหตุการณ์ขึ้น แล้วตัวประสานงานจะกำหนดเส้นทาง

นั่นหมายความว่าสามารถนำหน้าจอเดิมกลับมาใช้ในลำดับการทำงานที่แตกต่างกันได้โดยไม่ต้องแก้ไขโค้ด

ส่งสัญญาณเหตุการณ์ขึ้นไป

มุมมองสื่อสารกับตัวประสานงานผ่าน delegate หรือโคลเชอร์ โดยมุมมองไม่จำเป็นต้องรู้ว่าจะนำไปสู่ที่ใดต่อ

protocol HomeViewControllerDelegate: AnyObject {
    func homeDidSelectProfile()
}

final class HomeViewController: UIViewController {
    weak var delegate: HomeViewControllerDelegate?

    func profileTapped() {
        delegate?.homeDidSelectProfile()
    }
}

จัดการเส้นทาง

ตัวประสานงานนำโพรโทคอลของ delegate ไปใช้ และตัดสินใจว่าจะนำทางอย่างไรเมื่อเหตุการณ์เกิดขึ้น

extension AppCoordinator: HomeViewControllerDelegate {
    func homeDidSelectProfile() {
        let profile = ProfileViewController()
        navigationController.pushViewController(profile, animated: true)
    }
}

ตัวประสานงานย่อย

ลำดับการทำงานขนาดใหญ่ เช่น การเริ่มต้นใช้งานหรือการชำระเงิน จะมี ตัวประสานงานย่อย ของตนเอง ตัวประสานงานหลักจะเริ่มตัวประสานงานย่อยและเก็บไว้ใน childCoordinators เพื่อให้ยังคงทำงานอยู่

func startOnboarding() {
    let child = OnboardingCoordinator(navigationController: navigationController)
    childCoordinators.append(child)
    child.start()
}

หลีกเลี่ยงหน่วยความจำรั่ว

เนื่องจากตัวประสานงานหลักเก็บตัวประสานงานย่อยไว้ คุณจึงต้อง นำตัวประสานงานย่อยออก เมื่อสิ้นสุดลำดับการทำงาน มิฉะนั้นจะเกิดหน่วยความจำรั่ว แนวทางที่ใช้กันทั่วไปคือการเรียกกลับเมื่อทำงานเสร็จ

func childDidFinish(_ child: Coordinator) {
    childCoordinators.removeAll { $0 === child }
}

ตัวประสานงานกับ SwiftUI

ใน SwiftUI ตัวประสานงานมักควบคุมเส้นทางของ NavigationStack โดยตัวประสานงานจะเป็นเจ้าของเส้นทางที่สังเกตการเปลี่ยนแปลงได้ และมุมมองจะเพิ่มเส้นทางลงไป

final class Router: ObservableObject {
    @Published var path: [Route] = []

    func push(_ route: Route) {
        path.append(route)
    }
}

enum Route: Hashable { case profile, settings }

สรุปประโยชน์

รูปแบบตัวประสานงานมอบสิ่งต่อไปนี้ให้คุณ:

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

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

ทดสอบความเข้าใจเกี่ยวกับตัวประสานงานของคุณ

ตอบคำถามในบทเรียนแบบโต้ตอบ

สรุป

คุณได้เรียนรู้ รูปแบบตัวประสานงาน:

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

เมื่อใช้ร่วมกับ MVVM ตัวประสานงานจะช่วยทำให้สถาปัตยกรรมสะอาดและทดสอบได้อย่างสมบูรณ์

เริ่มต้นได้ฟรี

เรียนรู้ Swift ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 122
บทเรียน: 409

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

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

บทเรียน “รูปแบบ Coordinator” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “รูปแบบ Coordinator”

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

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

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

บทเรียน “รูปแบบ Coordinator” ใช้เวลานานแค่ไหน

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

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

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

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

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