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

เหตุใดจึงมี satisfies

ทำความเข้าใจช่องว่างระหว่างการระบุชนิดข้อมูลกับการอนุมานที่ satisfies เข้ามาเติมเต็ม

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

เป้าหมายสองประการที่ขัดแย้งกัน

เมื่อประกาศ config โดยทั่วไปแล้ว คุณมักต้องการสองสิ่ง ได้แก่ การตรวจสอบความถูกต้องให้ตรงกับรูปแบบโครงสร้างที่ทราบแน่ชัด และ การอนุมานค่าลิเทอรัลที่แม่นยำ เป้าหมายสองอย่างนี้มักขัดแย้งกัน

type Color = "red" | "green" | "blue";
// We want both: check the values AND remember exactly which ones.

การระบุชนิดทำให้การจำกัดค่าลิเทอรัลหายไป

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

type Config = { color: string; retries: number };
const cfg: Config = { color: "red", retries: 3 };
// cfg.color is string, not "red" anymore.
console.log(cfg.color.toUpperCase());

เหตุใดการขยายชนิดจึงเป็นปัญหา

หาก color ถูกขยายชนิดเป็น string คุณจะไม่สามารถใช้ค่านี้ในตำแหน่งที่ต้องการค่าลิเทอรัลเฉพาะได้ เช่น การใช้เป็นดัชนีในชนิดอื่น

const cfg = { color: "red" } as { color: string };
// const exact: "red" = cfg.color; // Error: string not assignable to "red"
console.log(cfg.color);

ไม่ระบุชนิดทำให้การตรวจสอบความถูกต้องหายไป

การลบคำระบุชนิดออกจะคงการอนุมานที่แม่นยำไว้ แต่เอากลไกความปลอดภัยออกไปด้วย คำสะกดผิดและโครงสร้างที่ไม่ถูกต้องจะไม่ถูกตรวจพบ

const cfg = { color: "rad", retries: 3 };
// No error on the typo "rad" because nothing validates it.
console.log(cfg.color);

ช่องว่างในการตรวจสอบความถูกต้อง

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

const palette = { primary: "blu" }; // typo, no error
console.log(palette.primary); // "blu"

ทำความรู้จักโอเปอเรเตอร์ satisfies

โอเปอเรเตอร์ satisfies ตรวจสอบความถูกต้องของนิพจน์เทียบกับชนิดหนึ่ง พร้อมทั้ง รักษาไว้ซึ่งชนิดที่อนุมานได้อย่างแม่นยำ ได้ประโยชน์จากทั้งสองด้าน

type Config = { color: string; retries: number };
const cfg = { color: "red", retries: 3 } satisfies Config;
console.log(cfg.color); // type is "red", value validated

satisfies รักษาค่าลิเทอรัลไว้

หลังใช้ satisfies แล้ว cfg.color ยังคงเป็นลิเทอรัล "red" ไม่ใช่ string แบบกว้าง การอนุมานจึงยังคงอยู่

type Config = { color: string };
const cfg = { color: "red" } satisfies Config;
const exact: "red" = cfg.color; // OK
console.log(exact);

satisfies ยังคงตรวจสอบความถูกต้อง

หากออบเจกต์ไม่ตรงกับชนิด satisfies จะแจ้งข้อผิดพลาด เช่นเดียวกับการระบุชนิด

type Config = { retries: number };
// const bad = { retries: "three" } satisfies Config; // Error
const good = { retries: 3 } satisfies Config;
console.log(good.retries);

ตัวอย่างที่เป็นแรงจูงใจ

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

type Routes = Record<string, { method: "GET" | "POST" }>;
const routes = {
  home: { method: "GET" },
  submit: { method: "POST" }
} satisfies Routes;
console.log(routes.home.method); // "GET" literal

เปรียบเทียบสามแนวทาง

การระบุชนิด: ตรวจสอบความถูกต้องและขยายชนิด ไม่ระบุชนิด: แม่นยำแต่ไม่ผ่านการตรวจสอบ satisfies: ตรวจสอบความถูกต้องและยังคงความแม่นยำ แนวทางที่สามจึงเหมาะกับ config มากที่สุด

type C = { color: string };
const a: C = { color: "red" };          // widened
const b = { color: "red" };             // unvalidated
const c = { color: "red" } satisfies C; // validated + precise
console.log(a.color, b.color, c.color);

ควรเลือกใช้ satisfies เมื่อใด

ใช้ satisfies เมื่อใดก็ตามที่คุณกำหนดค่าคงที่ซึ่งต้องสอดคล้องกับชนิดหนึ่ง แต่ยังต้องการใช้เนื้อหาที่แน่นอนของค่านั้นในภายหลัง

type Sizes = Record<string, number>;
const sizes = { sm: 8, md: 16, lg: 24 } satisfies Sizes;
// keys "sm" | "md" | "lg" stay known for autocomplete
console.log(sizes.md);

ตรวจสอบความเข้าใจอย่างรวดเร็ว: เหตุใดจึงมี satisfies

ทดสอบความเข้าใจของคุณว่าทำไมจึงมี satisfies

ทบทวน: เหตุใดจึงมี satisfies

คุณได้เรียนรู้ว่าการระบุชนิดจะตรวจสอบความถูกต้องแต่ขยายชนิด การไม่ระบุชนิดจะรักษาความแม่นยำไว้แต่ไม่ตรวจสอบ และ satisfies ให้ทั้งการตรวจสอบความถูกต้องและการอนุมานที่แม่นยำ ซึ่งเหมาะอย่างยิ่งสำหรับออบเจกต์การกำหนดค่า

type C = { color: string };
const c = { color: "blue" } satisfies C;
const exact: "blue" = c.color;
console.log(exact);

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

บทเรียน “เหตุใดจึงมี satisfies” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “เหตุใดจึงมี satisfies”

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

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

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

บทเรียน “เหตุใดจึงมี satisfies” ใช้เวลานานแค่ไหน

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

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

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

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

  1. เหตุใดจึงมี satisfies
  2. satisfies เทียบกับคำอธิบายชนิดข้อมูล
  3. satisfies เทียบกับการยืนยันด้วย as
  4. รูปแบบการใช้ satisfies ในทางปฏิบัติ
← กลับไปที่ TypeScript Academy