ชนิด Template Literal
ผสานชนิดสตริงลิเทอรัลกับไวยากรณ์ template literal เพื่อสร้างชนิดต่าง ๆ เช่น ชื่อเหตุการณ์ สตริงคุณสมบัติ CSS และเส้นทาง API
ชนิด Template Literal เป็นบทเรียน Frontend Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Frontend Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Frontend Academy มีบทเรียนทั้งหมด 4 บทเรียน
ประเภทเทมเพลตลิเทอรัลคืออะไร
TypeScript สามารถสร้างประเภทสตริงจากเทมเพลตลิเทอรัลในระดับประเภทได้ เมื่อใช้ร่วมกับประเภทยูเนียน คุณสามารถแสดงสตริงที่ถูกต้องได้หลายพันแบบโดยไม่ต้องระบุทีละแบบ
ประเภทเทมเพลตลิเทอรัลพื้นฐาน
ใช้สตริงที่ครอบด้วยเครื่องหมาย backtick ในตำแหน่งประเภท โดยสตริงเหล่านี้รับประเภทอื่นมาแทรกได้
type Greeting = `Hello, ${string}!`;
const a: Greeting = 'Hello, Alice!'; // OK
const b: Greeting = 'Hi, Alice!'; // Errorการรวมประเภทยูเนียน
เมื่อแทรกประเภทยูเนียน TypeScript จะสร้างผลคูณของชุดค่าผสมทั้งหมด
type Direction = 'top' | 'right' | 'bottom' | 'left';
type Property = 'margin' | 'padding';
type Side = `${Property}-${Direction}`;
// 'margin-top' | 'margin-right' | ... | 'padding-left' (8 strings)การอนุมานชื่อเหตุการณ์
สร้างชื่อเครื่องจัดการเหตุการณ์จากชื่อเหตุการณ์ ซึ่งเป็นกรณีใช้งานจริงที่พบได้บ่อย
type EventName = 'click' | 'focus' | 'blur' | 'change';
type HandlerName = `on${Capitalize<EventName>}`;
// 'onClick' | 'onFocus' | 'onBlur' | 'onChange'
type Handlers = { [K in HandlerName]?: (e: Event) => void };
// { onClick?: ...; onFocus?: ...; onBlur?: ...; onChange?: ... }ประเภทเครื่องมือสำหรับจัดการสตริง
TypeScript มีตัวช่วยในตัว ได้แก่ Uppercase<T>, Lowercase<T>, Capitalize<T>, Uncapitalize<T>
type Hi = Capitalize<'hello'>; // 'Hello'
type Yell = Uppercase<'hello'>; // 'HELLO'
type Quiet = Lowercase<'HELLO'>; // 'hello'
type Lower = Uncapitalize<'Hi'>; // 'hi'ประเภทพร็อพเพอร์ตี CSS
แสดงประเภทสตริงที่คล้าย CSS เช่น ค่าพิกเซล สีแบบเลขฐานสิบหก และเปอร์เซ็นต์
type Px = `${number}px`;
type Hex = `#${string}`;
type Pct = `${number}%`;
type Style = { padding: Px; color: Hex; width: Pct };
const s: Style = { padding: '8px', color: '#fff', width: '50%' }; // OK
const bad: Style = { padding: '8', color: 'white', width: '50' }; // Errorการอนุมานด้วยเทมเพลตลิเทอรัล
คีย์เวิร์ด infer สามารถแยกส่วนต่าง ๆ ของประเภทสตริงได้ ซึ่งมีประโยชน์สำหรับตัวแยกวิเคราะห์และประเภทเส้นทาง
type ExtractName<T> = T extends `Hello, ${infer Name}!` ? Name : never;
type Result = ExtractName<'Hello, Alice!'>; // 'Alice'ประเภทเส้นทาง API
เส้นทาง API ที่ปลอดภัยด้านประเภท: แยกพารามิเตอร์เส้นทางจากรูปแบบสตริง
type PathParams<T extends string> =
T extends `${string}/:${infer Param}/${infer Rest}`
? { [K in Param | keyof PathParams<`/${Rest}`>]: string }
: T extends `${string}/:${infer Param}`
? { [K in Param]: string }
: {};
type P = PathParams<'/users/:userId/posts/:postId'>;
// { userId: string; postId: string }ประเภทสำหรับแนะนำคลาส Tailwind
จำกัดพร็อพสตริงให้ใช้ได้เฉพาะค่าที่กำหนดไว้ในระบบการออกแบบ
type Spacing = 0 | 1 | 2 | 4 | 8 | 16;
type Side = 't' | 'r' | 'b' | 'l';
type TwSpacing = `m${Side}-${Spacing}` | `p${Side}-${Spacing}`;
// 'mt-0' | 'mt-1' | ... | 'pl-16'
function Box(props: { className: TwSpacing }) { /* ... */ }ข้อจำกัดและประสิทธิภาพของคอมไพเลอร์
ผลคูณของเทมเพลตลิเทอรัลอาจเพิ่มขึ้นอย่างรวดเร็ว (ยูเนียนขนาด 50 × 50 จะสร้างสตริง 2500 แบบ) TypeScript จะคอมไพล์ได้ แต่การอนุมานจะช้าลง ควรจำกัดชุดค่าที่ใช้ให้มีขนาดเล็ก
การแยกแยะประเภทสตริงลิเทอรัล
ใช้เทมเพลตลิเทอรัลเป็นรูปแบบการทำแบรนดิ้งที่สื่อความหมายได้มากขึ้น ซึ่งยังคงเป็นสตริงแต่มีข้อจำกัด
ตรวจสอบความเข้าใจอย่างรวดเร็ว
type X = `on${Capitalize<'click' | 'focus'>}` จะประเมินค่าเป็นอะไร
สรุป: ประเภทเทมเพลตลิเทอรัล
สร้างประเภทสตริงจากเทมเพลตลิเทอรัลที่แทรกประเภทยูเนียน ผลคูณของชุดค่าเพิ่มขึ้นอย่างรวดเร็ว จึงควรจำกัดชุดค่าที่ใช้ให้มีขนาดเล็ก ใช้ Capitalize/Uppercase/Lowercase/Uncapitalize และใช้ร่วมกับ infer เพื่อแยกส่วนต่าง ๆ ของสตริง เหมาะอย่างยิ่งสำหรับชื่อเหตุการณ์ ค่า CSS พารามิเตอร์เส้นทาง และชื่อคลาสในระบบการออกแบบ
คำถามที่พบบ่อย
บทเรียน “ชนิด Template Literal” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “ชนิด Template Literal” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Frontend Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Frontend Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “ชนิด Template Literal”
ผสานชนิดสตริงลิเทอรัลกับไวยากรณ์ template literal เพื่อสร้างชนิดต่าง ๆ เช่น ชื่อเหตุการณ์ สตริงคุณสมบัติ CSS และเส้นทาง API คุณปฏิบัติ Frontend Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Frontend Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Frontend Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน
บทเรียน “ชนิด Template Literal” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Frontend Academy นี้ได้ไหม
ได้ บทเรียน Frontend Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- ชนิด Template Literal
- เดคอเรเตอร์และข้อมูลเมตา
- TypeScript กับ React: เจเนริกของ FC และฮุก
- โหมดเข้มงวดและการกำจัด any