ชนิดข้อมูล Option และ Maybe
จำลองการมีอยู่หรือไม่มีอยู่ของค่าอย่างชัดเจน
ชนิดข้อมูล Option และ Maybe เป็นบทเรียน TypeScript Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน TypeScript Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส TypeScript Academy มีบทเรียนทั้งหมด 4 บทเรียน
การจำลองการไม่มีค่า
บางครั้งค่าอาจไม่มีอยู่ โดยไม่มีข้อผิดพลาดให้รายงาน ตัวเลือก (หรือเรียกอีกอย่างว่าแบบมีค่าหรือไม่มีค่า) ใช้จำลองการมีค่าหรือไม่มีค่าอย่างชัดเจน เป็นทางเลือกแทน null และ undefined
การกำหนด Option
ตัวเลือกคือยูเนียนแบบจำแนกที่มีแท็ก some เมื่อ some เป็นจริง จะมีค่าอยู่ เมื่อเป็นเท็จ จะไม่มีสิ่งใดอยู่
type Option<T> =
| { some: true; value: T }
| { some: false };ตัวสร้าง
ตัวช่วย some และ none ทำให้สร้างค่าของตัวเลือกได้ง่าย เช่นเดียวกับ ok/err จาก Result
const some = <T>(value: T): Option<T> => ({ some: true, value });
const none: Option<never> = { some: false };การคืนค่า Option
การค้นหาที่อาจไม่พบสิ่งใดจะคืนค่าตัวเลือกแทน T | undefined เจตนาว่าค่าอาจไม่มีจึงปรากฏอย่างชัดเจนในชนิดข้อมูล
function find<T>(arr: T[], pred: (x: T) => boolean): Option<T> {
const hit = arr.find(pred);
return hit === undefined ? none : some(hit);
}การจำกัดชนิดข้อมูลด้วย some
ตรวจสอบ opt.some เพื่อเข้าถึงค่าอย่างปลอดภัย คอมไพเลอร์จะอนุญาตให้อ่าน value ได้เฉพาะภายในแขนงที่มีค่าอยู่เท่านั้น
const r = find([1, 2, 3], n => n > 1);
if (r.some) console.log(r.value); // 2
else console.log("not found");ทำไมไม่ใช้ null อย่างเดียว
null และ undefined เป็นค่าที่ลืมตรวจสอบได้ง่ายและปะปนกับชนิดข้อมูลอื่น ตัวเลือกที่ระบุอย่างชัดเจนจะบังคับให้จัดการกรณีไม่มีค่า และสื่อเจตนาได้อย่างชัดเจน
Option เทียบกับ T | undefined
ทั้งสองแบบใช้จำลองการไม่มีค่าได้ แต่ตัวเลือกเป็นโครงสร้างที่มีชื่อและตั้งใจออกแบบมาโดยเฉพาะ ซึ่งสามารถเพิ่มตัวช่วยอย่าง map และ getOrElse ได้ จึงส่งเสริมการจัดการที่สอดคล้องกันทั่วทั้งฐานโค้ด
// undefined is implicit and easy to ignore;
// Option is explicit and self-documenting.ตัวช่วย getOrElse
หากต้องการเปลี่ยนตัวเลือกให้เป็นค่าที่ใช้งานได้จริง ให้ระบุค่าทดแทนสำหรับกรณีที่ไม่มีค่า วิธีนี้ทำให้การจัดการกรณีไม่มีค่าอยู่ในจุดเดียวที่เห็นได้ชัด
function getOrElse<T>(o: Option<T>, fallback: T): T {
return o.some ? o.value : fallback;
}
console.log(getOrElse(none, 0)); // 0การแมปบนตัวเลือก
map จะแปลงค่าภายในเฉพาะเมื่อมีค่าอยู่ และปล่อยให้กรณีไม่มีค่าคงเดิม วิธีนี้ช่วยให้เชื่อมการแปลงหลายขั้นตอนได้โดยไม่ต้องตรวจสอบซ้ำ
function mapOpt<T, U>(o: Option<T>, f: (t: T) => U): Option<U> {
return o.some ? some(f(o.value)) : none;
}
console.log(mapOpt(some(5), n => n * 2)); // { some: true, value: 10 }Option เทียบกับ Result
ใช้ ตัวเลือก เมื่อการไม่มีค่าไม่มีเหตุผลประกอบ (เช่น ค้นหาแล้วไม่พบ) ใช้ ผลลัพธ์ เมื่อความล้มเหลวมีข้อผิดพลาดที่อธิบายสาเหตุได้ เลือกตามว่าคุณจำเป็นต้องสื่อ เหตุผล หรือไม่
การประกอบตัวเลือก
เนื่องจากตัวเลือกมี map และ getOrElse การเชื่อมขั้นตอนที่อาจไม่มีค่าจึงยังอ่านง่าย โดยกรณีไม่มีค่าจะหยุดการทำงานต่อโดยอัตโนมัติตลอดสาย
const out = getOrElse(mapOpt(find([1,2], n => n > 1), n => n + 100), -1);
console.log(out); // 102ตรวจสอบความเข้าใจ
ตรวจสอบความเข้าใจบทเรียนนี้อย่างรวดเร็ว
ทบทวน
ตัวเลือก<T> มีรูปแบบ { some: true; value } หรือ { some: false } ใช้จำลองการไม่มีค่าอย่างชัดเจนแทน null สร้างด้วย some/none จำกัดชนิดข้อมูลด้วย some และใช้ตัวช่วยอย่าง getOrElse กับ map ควรใช้ตัวเลือกเมื่อการไม่มีค่าไม่จำเป็นต้องมีเหตุผล และใช้ Result เมื่อความล้มเหลวมีเหตุผลประกอบ
คำถามที่พบบ่อย
บทเรียน “ชนิดข้อมูล Option และ Maybe” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “ชนิดข้อมูล Option และ Maybe” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส TypeScript Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส TypeScript Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “ชนิดข้อมูล Option และ Maybe”
จำลองการมีอยู่หรือไม่มีอยู่ของค่าอย่างชัดเจน คุณปฏิบัติ TypeScript Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน TypeScript Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน TypeScript Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน
บทเรียน “ชนิดข้อมูล Option และ Maybe” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน TypeScript Academy นี้ได้ไหม
ได้ บทเรียน TypeScript Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- ปัญหาของการโยนข้อผิดพลาด
- การจำลองชนิดข้อมูล Result
- ชนิดข้อมูล Option และ Maybe
- การเขียนโปรแกรมแบบ Railway-Oriented