TypeScript Academy · บทเรียน

ช่องทางข้อผิดพลาดและสิ่งพึ่งพา

ติดตามข้อผิดพลาดที่มีชนิดข้อมูลและสิ่งพึ่งพาที่ถูกฉีดในผลข้างเคียง

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

ช่องข้อผิดพลาดและการพึ่งพา

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

การล้มเหลวที่มีชนิดข้อมูลด้วย Effect.fail

Effect.fail นำค่าไปไว้ในช่องข้อผิดพลาด คลาสที่มีแท็กช่วยให้แยกแยะข้อผิดพลาดได้ง่าย

import { Effect } from "effect";

class NotFound { readonly _tag = "NotFound"; }
class Forbidden { readonly _tag = "Forbidden"; }

const load = Effect.fail(new NotFound());
// Effect<never, NotFound, never>

ข้อผิดพลาดรวมกันเมื่อประกอบเอฟเฟกต์

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

// Effect<A, NotFound, never> then Effect<B, Forbidden, never>
// => Effect<B, NotFound | Forbidden, never>

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

Effect.catchAll หรือ catchTag ใช้จัดการข้อผิดพลาด โดยนำข้อผิดพลาดเหล่านั้นออกจากช่อง หรือแทนที่ด้วยข้อผิดพลาดอื่น การจัดการ NotFound จะทำให้ชนิด E แคบลง

import { Effect, pipe } from "effect";

const safe = pipe(
  Effect.fail(new NotFound()),
  Effect.catchTag("NotFound", () => Effect.succeed("default"))
);
// Effect<string, never, never> -- error handled

การกู้คืนเทียบกับการส่งต่อ

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

การประกาศการพึ่งพา

บริการจะประกาศเป็น Context.Tag เอฟเฟกต์ที่ใช้บริการนั้นจะมีบริการดังกล่าวอยู่ในช่อง R

import { Context, Effect } from "effect";

class Random extends Context.Tag("Random")<
  Random,
  { readonly next: Effect.Effect<number> }
>() {}

const program = Effect.gen(function* () {
  const random = yield* Random;
  return yield* random.next;
});
// Effect<number, never, Random>

ข้อกำหนดปรากฏในชนิดข้อมูล

สังเกตว่าตอนนี้ช่อง R มี Random อยู่ เอฟเฟกต์นี้ ไม่สามารถทำงานได้ จนกว่าจะมีการตอบสนองข้อกำหนดดังกล่าว ซึ่งคอมไพเลอร์จะบังคับใช้

การจัดเตรียมด้วย Layer

Layer อธิบายวิธีสร้างบริการ การจัดเตรียมเลเยอร์จะตอบสนองข้อกำหนดและนำข้อกำหนดนั้นออกจาก R

import { Effect, Layer } from "effect";

const RandomLive = Layer.succeed(Random, {
  next: Effect.sync(() => Math.random()),
});

const runnable = Effect.provide(program, RandomLive);
// Effect<number, never, never> -- R cleared

เลเยอร์ประกอบเข้าด้วยกันได้

เลเยอร์สามารถพึ่งพาเลเยอร์อื่นและรวมเข้าด้วยกันเพื่อสร้างกราฟการพึ่งพาที่สมบูรณ์ ไลบรารีนี้จะเชื่อมต่อเลเยอร์ตามลำดับที่ถูกต้องโดยอิงจากชนิดข้อมูล

import { Layer } from "effect";
// Layer.merge(DatabaseLive, LoggerLive)
// Layer that provides both services

การทดสอบด้วยการสลับเลเยอร์

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

import { Layer, Effect } from "effect";

const RandomTest = Layer.succeed(Random, {
  next: Effect.succeed(0.5),
});
// Effect.provide(program, RandomTest) -> deterministic

เหตุผลที่เรื่องนี้สำคัญ

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

ตรวจสอบอย่างรวดเร็ว

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

สรุป

ช่องข้อผิดพลาดติดตามการล้มเหลวที่มีชนิดข้อมูล (Effect.fail และทำให้แคบลงด้วย catchTag/catchAll) ซึ่งจะรวมเป็นยูเนียนเมื่อประกอบเอฟเฟกต์ ส่วน ช่องข้อกำหนดติดตามบริการที่ประกาศผ่าน Context.Tag และได้รับการตอบสนองโดย Layer หลายรายการผ่าน Effect.provide ทั้งสองช่องทำให้คอมไพเลอร์ตรวจสอบข้อผิดพลาดและการพึ่งพาได้ อีกทั้งทำให้การทดสอบทำได้ง่ายด้วยการสลับเลเยอร์

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

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

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

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

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

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

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

บทเรียน “ช่องทางข้อผิดพลาดและสิ่งพึ่งพา” ใช้เวลานานแค่ไหน

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

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

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

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

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