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

การจำลองชนิดข้อมูล Result

แสดงผลสำเร็จและความล้มเหลวเป็นข้อมูลด้วย Result

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

ชนิดข้อมูล Result

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

การกำหนด Result

รูปแบบคลาสสิกใช้ตัวจำแนก ok เมื่อ ok เป็นจริง จะมี value อยู่ เมื่อเป็นเท็จ จะมี error อยู่

type Result<T, E> =
  | { ok: true; value: T }
  | { ok: false; error: E };

ตัวช่วยสร้าง

ตัวช่วยขนาดเล็กอย่าง ok และ err ทำให้การสร้างผลลัพธ์กระชับและอ่านง่าย แทนการเขียนลิเทอรัลของอ็อบเจ็กต์ด้วยตนเองทุกครั้ง

const ok = <T>(value: T): Result<T, never> => ({ ok: true, value });
const err = <E>(error: E): Result<never, E> => ({ ok: false, error });

การคืนค่า Result

ฟังก์ชันที่อาจล้มเหลวจะคืนค่า ok(value) หรือ err(error) ชนิดข้อมูลที่คืนค่าจะประกาศความเป็นไปได้ทั้งสองแบบให้ผู้เรียกทุกคนทราบ

function divide(a: number, b: number): Result<number, string> {
  return b === 0 ? err("divide by zero") : ok(a / b);
}

การจำกัดชนิดข้อมูลด้วย ok

การตรวจสอบ result.ok จะจำกัดยูเนียนให้แคบลง ภายในแขนงที่เป็นจริง TypeScript จะทราบว่ามี value อยู่ ส่วนภายในแขนงที่เป็นเท็จจะทราบว่ามี error อยู่

const r = divide(10, 2);
if (r.ok) console.log(r.value); // 5
else console.log(r.error);

ตัวจำแนกขับเคลื่อนความปลอดภัย

ฟิลด์ ok เป็น ตัวจำแนก ที่ช่วยให้คอมไพเลอร์เลือกแขนงที่ถูกต้อง คุณไม่สามารถเข้าถึง value ได้หากยังพิสูจน์ไม่ได้ว่า ok เป็นจริง

const r = divide(1, 0);
// r.value here is a type error until we check r.ok
if (!r.ok) console.log("err:", r.error);

ข้อผิดพลาดแบบมีชนิดข้อมูล

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

type DivErr = { kind: "zero" } | { kind: "overflow" };
function div(a: number, b: number): Result<number, DivErr> {
  if (b === 0) return err({ kind: "zero" });
  return ok(a / b);
}

การจัดการข้อผิดพลาดอย่างครบถ้วน

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

const r = div(1, 0);
if (!r.ok) {
  switch (r.error.kind) {
    case "zero": console.log("no zero"); break;
    case "overflow": console.log("too big"); break;
  }
}

ตัวช่วยใช้ค่าตั้งต้น

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

function unwrapOr<T, E>(r: Result<T, E>, fallback: T): T {
  return r.ok ? r.value : fallback;
}
console.log(unwrapOr(divide(1, 0), -1)); // -1

Result เทียบกับการส่งข้อยกเว้น

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

ตัวอย่างสมบูรณ์

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

function safeParse(s: string): Result<number, string> {
  const n = Number(s);
  return Number.isNaN(n) ? err("NaN") : ok(n);
}
const p = safeParse("42");
console.log(p.ok ? p.value : p.error); // 42

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

ตรวจสอบความเข้าใจบทเรียนนี้อย่างรวดเร็ว

ทบทวน

ผลลัพธ์<T, E> คือยูเนียนแบบจำแนกที่มีรูปแบบ { ok: true; value } หรือ { ok: false; error } สร้างด้วยตัวช่วย ok/err และจำกัดชนิดข้อมูลด้วย ok เพื่อเข้าถึง value หรือ error ได้อย่างปลอดภัย โดยข้อผิดพลาดที่มีชนิดข้อมูลช่วยให้จัดการได้ครบทุกกรณี

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

บทเรียน “การจำลองชนิดข้อมูล Result” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “การจำลองชนิดข้อมูล Result”

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

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

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

บทเรียน “การจำลองชนิดข้อมูล Result” ใช้เวลานานแค่ไหน

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

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

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

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

  1. ปัญหาของการโยนข้อผิดพลาด
  2. การจำลองชนิดข้อมูล Result
  3. ชนิดข้อมูล Option และ Maybe
  4. การเขียนโปรแกรมแบบ Railway-Oriented
← กลับไปที่ TypeScript Academy