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

ชนิดข้อมูล Suspense และขอบเขตข้อผิดพลาด

ใช้ React.Suspense ร่วมกับคอมโพเนนต์แบบโหลดช้า และกำหนดชนิดข้อมูลให้ขอบเขตข้อผิดพลาดที่ทนทาน (อิงคลาส) จัดการข้อผิดพลาดที่ไม่ทราบชนิดอย่างปลอดภัยและใช้รูปแบบการรีเซ็ต

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

บทนำ

เป้าหมาย: โหลดคอมโพเนนต์แบบขี้เกียจด้วย React.lazy + Suspense และเพิ่มขอบเขตข้อผิดพลาดที่มีชนิด ซึ่งแสดงส่วนสำรองที่เป็นมิตรและบันทึกรายละเอียด

  • Suspense = ส่วนติดต่อผู้ใช้ขณะโหลด
  • ขอบเขตข้อผิดพลาด = ส่วนติดต่อผู้ใช้เมื่อเกิดข้อผิดพลาดขณะรันไทม์
  • ระบุชนิดข้อผิดพลาดที่ไม่ทราบชนิดอย่างปลอดภัย

โหลดเมื่อจำเป็นและ Suspense

React.lazy คืนค่าชนิดคอมโพเนนต์ ให้ห่อด้วย Suspense เพื่อเรนเดอร์ส่วนสำรองระหว่างที่โมดูลกำลังโหลด

import React, { Suspense } from "react"

const LazyWidget = React.lazy(async () => import("./Widget"))

export default function App() {
  return (
    <div style={{ display: "grid", gap: 8 }}>
      <Suspense fallback={<span>Loading…</span>}>
        <LazyWidget />
      </Suspense>
    </div>
  )
}

การระบุชนิดพร็อพส์แบบโหลดเมื่อจำเป็น

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

import React, { Suspense } from "react"

// Ensure props are preserved through lazy
interface ChartProps { title: string; values: number[] }
const Chart = React.lazy(async () => import("./Chart"))

export default function App() {
  return (
    <Suspense fallback={<span>Loading chart…</span>}>
      <Chart title="Sales" values={[10, 20, 15]} />
    </Suspense>
  )
}

การระบุชนิดของขอบเขตข้อผิดพลาด

ระบุชนิดตัวจัดการข้อผิดพลาดด้วย unknown และจำกัดให้แคบลงเป็น Error หากจำเป็น ใช้ React.ErrorInfo เพื่อเข้าถึงสแตกของคอมโพเนนต์

import React from "react"

interface Props { fallback: React.ReactNode }
interface State { hasError: boolean; message?: string }

export class ErrorBoundary extends React.Component<Props, State> {
  state: State = { hasError: false }

  static getDerivedStateFromError(err: unknown): State {
    const msg = err instanceof Error ? err.message : String(err)
    return { hasError: true, message: msg }
  }

  componentDidCatch(error: unknown, info: React.ErrorInfo) {
    // log error & component stack safely
    console.error("ErrorBoundary", error, info.componentStack)
  }

  render() {
    if (this.state.hasError) {
      return this.props.fallback || <span>Something went wrong</span>
    }
    return this.props.children
  }
}

การประกอบขอบเขต

ผสานSuspense (การโหลด) และขอบเขตข้อผิดพลาด (ข้อผิดพลาด) เข้าด้วยกัน ทั้งสองจัดการคนละประเด็นและสามารถซ้อนกันแยกตามแต่ละส่วนได้

import React, { Suspense } from "react"
import { ErrorBoundary } from "./ErrorBoundary"

const Page = React.lazy(async () => import("./Page"))

export default function App() {
  return (
    <div style={{ display: "grid", gap: 8 }}>
      <ErrorBoundary fallback={<span>Failed to load page</span>}>
        <Suspense fallback={<span>Loading page…</span>}>
          <Page />
        </Suspense>
      </ErrorBoundary>
    </div>
  )
}

รูปแบบการรีเซ็ต

แนวทางการรีเซ็ต:

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

ตรวจสอบการระบุชนิดของขอบเขต

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

สรุปทบทวน

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

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

บทเรียน “ชนิดข้อมูล Suspense และขอบเขตข้อผิดพลาด” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “ชนิดข้อมูล Suspense และขอบเขตข้อผิดพลาด”

ใช้ React.Suspense ร่วมกับคอมโพเนนต์แบบโหลดช้า และกำหนดชนิดข้อมูลให้ขอบเขตข้อผิดพลาดที่ทนทาน (อิงคลาส) จัดการข้อผิดพลาดที่ไม่ทราบชนิดอย่างปลอดภัยและใช้รูปแบบการรีเซ็ต คุณปฏิบัติ TypeScript Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

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

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

บทเรียน “ชนิดข้อมูล Suspense และขอบเขตข้อผิดพลาด” ใช้เวลานานแค่ไหน

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

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

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

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

  1. ฮุกแบบกำหนดเองด้วยเจเนอริกและการอนุมาน
  2. ชนิดข้อมูล Suspense และขอบเขตข้อผิดพลาด
← กลับไปที่ TypeScript Academy