การตรวจสอบ input เวลาคอมไพล์
ปฏิเสธนิพจน์ DSL ที่มีรูปแบบไม่ถูกต้องก่อนเริ่มทำงาน
การตรวจสอบ input เวลาคอมไพล์ เป็นบทเรียน TypeScript Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน TypeScript Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส TypeScript Academy มีบทเรียนทั้งหมด 4 บทเรียน
การตรวจสอบอินพุตขณะคอมไพล์
DSL ระดับชนิดสามารถ ปฏิเสธนิพจน์ที่มีรูปแบบไม่ถูกต้องก่อนขณะทำงาน ได้ ด้วยการใช้ชนิดลิเทอรัลแม่แบบและชนิดแบบมีเงื่อนไข เราจะตรวจสอบโครงสร้างของสตริงในระดับชนิด และปฏิเสธอินพุตที่ไม่ถูกต้อง
ตัวอย่าง: ภาษาตัวเลือกขนาดเล็ก
ลองนึกภาพว่ารับสตริงอย่าง "user.name" หรือ "order.items.length" เราต้องการปฏิเสธ "user." หรือ ".name" ขณะคอมไพล์
การแยกวิเคราะห์ด้วยลิเทอรัลแม่แบบ
ชนิดลิเทอรัลแม่แบบจะแยกสตริงออกเป็นส่วน ๆ โดยใช้ infer ซึ่งเป็นพื้นฐานของการแยกวิเคราะห์ขณะคอมไพล์ รูปแบบจริงจะคั่นด้วยเครื่องหมายย้อนกลับ (ส่วนหัว จุด และส่วนท้ายพร้อมการอนุมาน) เราเรียกตัวจับคู่การแยกนี้ว่า DotSplit
// Real TS: backtick pattern matching Head, ".", Tail.
type Split<S extends string> =
S extends DotSplit<infer Head, infer Tail>
? [Head, ...Split<Tail>]
: [S];
type P = Split<"a.b.c">; // ["a", "b", "c"]การตรวจสอบแต่ละส่วน
ชนิดแบบมีเงื่อนไขจะตรวจสอบว่าไม่มีส่วนใดว่าง ส่วนที่ว่างจะทำให้อินพุตไม่ถูกต้อง รูปแบบ DotSplit เดียวกัน (ลิเทอรัลแม่แบบที่คั่นด้วยเครื่องหมายย้อนกลับในโค้ดจริง) จะขับเคลื่อนการเรียกซ้ำ
type NonEmpty<S extends string> = S extends "" ? false : true;
type Valid<S extends string> =
S extends DotSplit<infer H, infer T>
? H extends "" ? false : Valid<T>
: NonEmpty<S>;
type V1 = Valid<"a.b">; // true
type V2 = Valid<"a.">; // falseการจำกัด API ด้วยความถูกต้อง
ใช้ชนิดความถูกต้องเพื่อจำกัดพารามิเตอร์ของฟังก์ชัน: สตริงที่ถูกต้องจะคงชนิดของตัวเองไว้ ส่วนสตริงที่ไม่ถูกต้องจะกลายเป็น never ทำให้การเรียกใช้ไม่ผ่านการคอมไพล์
declare function path<S extends string>(
p: Valid<S> extends true ? S : never
): void;
path("user.name"); // ok
path("user."); // Error: argument is neverการปฏิเสธโทเค็นที่ไม่รู้จัก
คุณยังจำกัดอักขระที่อนุญาตได้ด้วย จับคู่เฉพาะรูปแบบเซกเมนต์ที่รู้จักเท่านั้น ส่วนสิ่งอื่นจะถูกยุบเป็นชนิดที่ปฏิเสธ
type Allowed = "user" | "order" | "name" | "items";
type CheckSeg<S extends string> = S extends Allowed ? true : false;การตรวจสอบตัวดำเนินการ
สำหรับ DSL ของนิพจน์ เช่น "age > 18" ให้จับคู่ตัวดำเนินการด้วยลิเทอรัลแม่แบบ และตรวจสอบว่าตัวดำเนินการนั้นอยู่ในชุดที่อนุญาต ตัวจับคู่ (ช่องว่างซ้าย O ช่องว่างขวา) เป็นลิเทอรัลแม่แบบแบบแบ็กทิกในโค้ดจริง เราเรียกแทนด้วย CondMatch
type Op = ">" | "<" | "=" | ">=" | "<=";
// Real TS: backtick pattern -> left, " ", infer O, " ", right.
type IsCond<S extends string> =
S extends CondMatch<infer O>
? O extends Op ? true : false
: false;
type C1 = IsCond<"age > 18">; // true
type C2 = IsCond<"age ! 18">; // falseการรวมการตรวจสอบ
ตัวตรวจสอบที่ใช้จริงจะตัดกันหลายเงื่อนไข ได้แก่ เซกเมนต์ที่ไม่ว่าง โทเค็นที่อนุญาต และโครงสร้างที่สมดุล แต่ละเงื่อนไขเป็นชนิดมีเงื่อนไข จากนั้นรวมเข้าด้วยกันด้วยชนิดช่วยที่ทำงานคล้ายตรรกะ
type And<A, B> = A extends true ? (B extends true ? true : false) : false;ขีดจำกัดการเรียกซ้ำ
การเรียกซ้ำระดับชนิดข้อมูลมีขีดจำกัดด้านความลึก สำหรับสตริงที่ยาวมาก คอมไพเลอร์อาจรายงานข้อผิดพลาดว่า "การสร้างอินสแตนซ์ของชนิดข้อมูลลึกเกินไป" ควรจำกัดความยาวของอินพุตที่นำไปแยกวิเคราะห์ หรือทำให้ไวยากรณ์เรียบง่ายขึ้น
ดีกว่าการแยกวิเคราะห์ขณะทำงาน
ตัวแยกวิเคราะห์ขณะทำงานจะแจ้งปัญหาเมื่อมีการประเมินสตริงที่ไม่ถูกต้องเท่านั้น แต่การตรวจสอบขณะคอมไพล์จะปฏิเสธลิเทอรัลทันทีที่คุณพิมพ์ พร้อมคำแนะนำครบถ้วนในตัวแก้ไขและไม่มีต้นทุนขณะทำงาน
เหตุผลที่เรื่องนี้สำคัญ
DSL จำนวนมากรับอินพุตเป็นสตริง เช่น เส้นทาง คำค้น และรูปแบบ การตรวจสอบโครงสร้างของสตริงเหล่านี้ในระบบชนิดข้อมูลจะตรวจจับการพิมพ์ผิดและนิพจน์ที่มีรูปแบบไม่ถูกต้องได้ ก่อน ที่โปรแกรมจะทำงาน และเปลี่ยนข้อผิดพลาดขณะทำงานกลุ่มหนึ่งให้เป็นข้อผิดพลาดขณะคอมไพล์
ตรวจสอบความเข้าใจอย่างรวดเร็ว
ตรวจสอบความเข้าใจของคุณเกี่ยวกับการตรวจสอบอินพุตขณะคอมไพล์
ทบทวน
คุณตรวจสอบอินพุตของ DSL ได้ ก่อนเริ่มทำงาน โดยแยกวิเคราะห์ลิเทอรัลสตริงด้วยชนิดลิเทอรัลแม่แบบและ infer จากนั้นตรวจสอบเซกเมนต์และตัวดำเนินการด้วยชนิดมีเงื่อนไข การจำกัดพารามิเตอร์ของฟังก์ชันด้วยชนิดความถูกต้องทำให้นิพจน์ที่มีรูปแบบไม่ถูกต้องกลายเป็น never และไม่ผ่านการคอมไพล์ โดยต้องคำนึงถึงขีดจำกัดการเรียกซ้ำด้วย
คำถามที่พบบ่อย
บทเรียน “การตรวจสอบ input เวลาคอมไพล์” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “การตรวจสอบ input เวลาคอมไพล์” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส TypeScript Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส TypeScript Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “การตรวจสอบ input เวลาคอมไพล์”
ปฏิเสธนิพจน์ DSL ที่มีรูปแบบไม่ถูกต้องก่อนเริ่มทำงาน คุณปฏิบัติ TypeScript Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน TypeScript Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน TypeScript Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน
บทเรียน “การตรวจสอบ input เวลาคอมไพล์” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน TypeScript Academy นี้ได้ไหม
ได้ บทเรียน TypeScript Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- DSL ระดับชนิดข้อมูลคืออะไร
- การออกแบบ DSL สำหรับการสืบค้นแบบต่อเนื่อง
- การตรวจสอบ input เวลาคอมไพล์
- ข้อความข้อผิดพลาดใน DSL ระดับชนิดข้อมูล