Swift Academy · บทเรียน

ตัวดำเนินการจัดการข้อผิดพลาด

กู้คืนการทำงานด้วย catch, retry และ replaceError

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

ข้อผิดพลาดในการรวมค่า

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

ชนิดความล้มเหลว

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

let publisher: AnyPublisher<Data, URLError> = apiClient.request()
// Output = Data, Failure = URLError

ดักจับข้อผิดพลาด

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

apiClient.fetchUser()
    .catch { error in
        Just(User.guest)
    }
    .sink { user in
        print("Got", user.name)
    }
    .store(in: &cancellables)

replaceError

replaceError(with:) เป็นรูปแบบที่ง่ายกว่าของ catch โดยแทนที่ความล้มเหลวใด ๆ ด้วยค่าทดแทนเพียงค่าเดียว แล้วจบการทำงานโดยสำเร็จ

apiClient.fetchCount()
    .replaceError(with: 0)
    .sink { count in
        self.badge.text = "\(count)"
    }
    .store(in: &cancellables)

retry

retry(n) จะสมัครรับข้อมูลจากต้นทางอีกครั้งได้สูงสุด n ครั้งเมื่อเกิดความล้มเหลว เหมาะอย่างยิ่งสำหรับข้อผิดพลาดเครือข่ายที่เกิดขึ้นชั่วคราว

apiClient.fetchData()
    .retry(3)
    .sink(receiveCompletion: { print($0) },
          receiveValue: { print($0) })
    .store(in: &cancellables)

การผสาน retry และการดักจับข้อผิดพลาด

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

apiClient.fetchData()
    .retry(2)
    .catch { _ in
        Just(Data())
    }
    .sink { data in
        self.process(data)
    }
    .store(in: &cancellables)

mapError

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

enum AppError: Error { case network }

apiClient.request()
    .mapError { _ in AppError.network }
    .sink(receiveCompletion: { _ in }, receiveValue: { _ in })
    .store(in: &cancellables)

เหตุใด mapError จึงสำคัญ

เมื่อรวมผู้เผยแพร่เข้าด้วยกัน ชนิด Failure ของผู้เผยแพร่เหล่านั้นต้องตรงกัน mapError จะปรับข้อผิดพลาดที่มีชนิดไม่ตรงกันให้เป็นมาตรฐาน เพื่อให้ตัวดำเนินการอย่าง merge และ zip คอมไพล์ได้ และทำให้ sink ของคุณจัดการข้อผิดพลาดเพียงชนิดเดียว

setFailureType

ผู้เผยแพร่บางประเภท เช่น Just มีชนิด failure เป็น Never ส่วน setFailureType(to:) จะช่วยเชื่อมผู้เผยแพร่เหล่านี้ให้รวมกับผู้เผยแพร่ที่อาจเกิด failure ได้

Just(42)
    .setFailureType(to: AppError.self)
    .merge(with: failablePublisher)
    .sink(receiveCompletion: { _ in }, receiveValue: { _ in })
    .store(in: &cancellables)

การจัดการการเสร็จสิ้น

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

publisher.sink(
    receiveCompletion: { completion in
        if case .failure(let error) = completion {
            self.showAlert(error)
        }
    },
    receiveValue: { value in
        self.update(value)
    }
).store(in: &cancellables)

การออกแบบกระบวนการส่งข้อมูลที่ทนทาน

แนวปฏิบัติที่ดีสำหรับการจัดการข้อผิดพลาด:

ใช้ retry สำหรับความล้มเหลวชั่วคราว
ใช้ ดักจับ หรือ replaceError สำหรับทางเลือกสำรอง
ใช้ mapError เพื่อรวมชนิดข้อผิดพลาดให้เป็นแบบเดียวกัน
จัดการกรณี failure ใน sink เสมอ

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

ทดสอบความรู้เกี่ยวกับการจัดการข้อผิดพลาดของคุณ

สรุปทบทวน

คุณได้เรียนรู้ตัวดำเนินการจัดการข้อผิดพลาดของคอมไบน์:

ดักจับ / replaceError — จัดเตรียมทางเลือกสำรอง
retry — ลองใหม่เมื่อเกิด failure
mapError / setFailureType — รวมชนิดข้อผิดพลาดให้เป็นแบบเดียวกัน

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

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

บทเรียน “ตัวดำเนินการจัดการข้อผิดพลาด” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “ตัวดำเนินการจัดการข้อผิดพลาด”

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

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

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

บทเรียน “ตัวดำเนินการจัดการข้อผิดพลาด” ใช้เวลานานแค่ไหน

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

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

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

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

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