0Pricing
Frontend Academy · บทเรียน

ชนิด 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

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

  1. ชนิด Template Literal
  2. เดคอเรเตอร์และข้อมูลเมตา
  3. TypeScript กับ React: เจเนริกของ FC และฮุก
  4. โหมดเข้มงวดและการกำจัด any
← กลับไปที่ Frontend Academy