TypeScript Academy · บทเรียน

โทเคนบริการที่ปลอดภัยด้านชนิดข้อมูล

ใช้โทเคนที่มีชนิดข้อมูลเพื่อหลีกเลี่ยงข้อผิดพลาดขณะทำงานในการค้นหาบริการ

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

ปัญหาของโทเค็นสตริง

โทเค็นสตริงอย่าง "Logger" พิมพ์ผิดได้ง่ายและไม่มีข้อมูลประเภท คอนเทนเนอร์ไม่สามารถบอกได้ว่า get("Loggr") ผิด และประเภทที่ได้กลับมามักเป็น any

ใช้สัญลักษณ์เป็นโทเค็น

การใช้สัญลักษณ์แทนสตริงทำให้โทเค็นแต่ละรายการมีเอกลักษณ์เฉพาะตัว จึงไม่ชนกับรายการอื่นโดยไม่ตั้งใจ รีจิสทรีส่วนกลางช่วยจัดระเบียบโทเค็นเหล่านี้

const TYPES = {
  Logger: Symbol.for("Logger"),
  Mailer: Symbol.for("Mailer"),
} as const;

จับคู่โทเค็นกับประเภท

เป้าหมายที่ลึกกว่านั้นคือการเชื่อมโยงโทเค็นแต่ละรายการกับประเภทที่โทเค็นนั้นแก้ค่าออกมา เพื่อให้คอนเทนเนอร์คืนค่าประเภทที่ถูกต้องแทนที่จะเป็น any เราจะสร้างตัวห่อโทเค็นที่มีการระบุประเภท

interface Token<T> {
  readonly id: symbol;
  readonly _type?: T; // phantom type marker
}

สร้างโทเค็นที่มีการระบุประเภท

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

function token<T>(name: string): Token<T> {
  return { id: Symbol.for(name) };
}
const LoggerToken = token<Logger>("Logger");

ส่วนติดต่อของคอนเทนเนอร์ที่มีการระบุประเภท

เราระบุประเภทให้คอนเทนเนอร์ เพื่อให้ get อนุมานประเภทที่แก้ค่าออกมาได้จากโทเค็น ไม่ต้องแปลงประเภท และไม่ต้องใช้ any

interface TypedContainer {
  get<T>(t: Token<T>): T;
  bind<T>(t: Token<T>, impl: () => T): void;
}

การผูกด้วยประเภทที่อนุมานได้

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

declare const c: TypedContainer;
c.bind(LoggerToken, () => new ConsoleLogger());
// ConsoleLogger must satisfy Logger or this errors.

การแก้ค่าด้วยประเภทครบถ้วน

ตอนนี้ get จะคืนค่าประเภทเดียวกับโทเค็นอย่างแม่นยำ การเติมโค้ดอัตโนมัติและการตรวจสอบประเภทจะทำงานกับผลลัพธ์ได้โดยไม่ต้องใส่คำอธิบายประเภทด้วยตนเอง

const logger = c.get(LoggerToken); // type: Logger
logger.log("typed resolution");

หลีกเลี่ยงข้อผิดพลาดในการค้นคืน

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

// c.get(LogerToken) -> compile error: LogerToken is not defined

สิ่งที่เทียบเท่าใน InversifyJS

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

import { Container } from "inversify";
const TYPES = { Logger: Symbol.for("Logger") };
// container.bind<Logger>(TYPES.Logger).to(ConsoleLogger)

รีจิสทรีโทเค็น

การรวมโทเค็นไว้ในโมดูลเดียวทำให้มีแหล่งข้อมูลจริงเพียงแห่งเดียว จึงค้นหา ปรับโครงสร้าง และรักษาความสอดคล้องทั่วทั้งฐานโค้ดได้ง่าย

export const TOKENS = {
  Logger: token<Logger>("Logger"),
  Mailer: token<Mailer>("Mailer"),
};

สรุปประโยชน์

โทเค็นที่มีการระบุประเภทให้เอกลักษณ์เฉพาะตัว (สัญลักษณ์) ความปลอดภัยในเวลาคอมไพล์ (ปฏิเสธประเภทที่ไม่ตรงกัน) ประเภทผลลัพธ์ที่ถูกต้อง (ไม่ใช้ any) และการป้องกันการพิมพ์ผิด (ข้อผิดพลาดจากตัวแปรที่ไม่ได้กำหนด)

ตรวจสอบอย่างรวดเร็ว

ตรวจสอบความเข้าใจสั้น ๆ เกี่ยวกับบทเรียนนี้

ทบทวน

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

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

บทเรียน “โทเคนบริการที่ปลอดภัยด้านชนิดข้อมูล” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “โทเคนบริการที่ปลอดภัยด้านชนิดข้อมูล”

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

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

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

บทเรียน “โทเคนบริการที่ปลอดภัยด้านชนิดข้อมูล” ใช้เวลานานแค่ไหน

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

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

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

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

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