TypeScript Academy · บทเรียน

เหตุใดระบบผลข้างเคียงจึงสำคัญ

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

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

เหตุผลที่ระบบเอฟเฟกต์สำคัญ

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

ปัญหาของ async/throw แบบดิบ

async/await ร่วมกับ throw แบบธรรมดาจะซ่อนข้อมูลสำคัญไว้: ลายเซ็นฟังก์ชันไม่ได้บอกว่าฟังก์ชันอาจโยนข้อผิดพลาดใด หรือจำเป็นต้องใช้ทรัพยากรอะไร

async function getUser(id: number): Promise<User> {
  // may throw NotFoundError, may throw NetworkError
  // needs a database connection from... somewhere
  // none of this is in the type
  return await db.users.find(id);
}

ข้อผิดพลาดที่มองไม่เห็น

Promise<User> ไม่ได้บอกอะไรเกี่ยวกับรูปแบบความล้มเหลว ผู้เรียกใช้จึงไม่ทราบว่าต้องจัดการข้อผิดพลาดใด ทำให้บางครั้งดักจับกว้างเกินไป หรือไม่จัดการบางกรณีเลย

สิ่งที่ต้องพึ่งพาโดยนัย

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

ค่าเอฟเฟกต์คืออะไร

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

import { Effect } from "effect";

// A description: produces number, no errors, no requirements
const program = Effect.succeed(42);
// Nothing has run yet.

ความล้มเหลวที่ชัดเจน

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

import { Effect } from "effect";

const risky = Effect.fail(new Error("boom"));
// type encodes that this can fail with Error

สิ่งที่ต้องพึ่งพาที่ชัดเจน

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

การนำมาประกอบกันได้

เนื่องจากเอฟเฟกต์เป็นค่า คุณจึงรวมเอฟเฟกต์ด้วยตัวดำเนินการ (map, flatMap, zip) ได้เช่นเดียวกับอาร์เรย์หรือพรอมิส แต่ช่องทางข้อผิดพลาดและสิ่งที่ต้องพึ่งพาจะถูกส่งต่อไปโดยอัตโนมัติ

การทำงานที่เลื่อนออกไป

จะไม่มีสิ่งใดเกิดขึ้นจนกว่าคุณจะเรียกใช้เอฟเฟกต์อย่างชัดเจน เช่น Effect.runPromise การแยก คำอธิบาย ออกจาก การทำงานจริง ทำให้ลองใหม่ หยุดกลางคัน และทดสอบได้โดยไม่กระตุ้นผลข้างเคียงซ้ำ

import { Effect } from "effect";

const program = Effect.succeed(1);
// Run at the edge of your app:
// const result = await Effect.runPromise(program);

เปรียบเทียบกับพรอมิส

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

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

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

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

ทดสอบความเข้าใจของคุณว่าเหตุใดระบบเอฟเฟกต์จึงสำคัญ

ทบทวน

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

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

บทเรียน “เหตุใดระบบผลข้างเคียงจึงสำคัญ” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “เหตุใดระบบผลข้างเคียงจึงสำคัญ”

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

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

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

บทเรียน “เหตุใดระบบผลข้างเคียงจึงสำคัญ” ใช้เวลานานแค่ไหน

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

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

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

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

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