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

รูปแบบการใช้งานจริงของยูเนียนและอินเตอร์เซกชัน

ประยุกต์ใช้ยูเนียนและอินเตอร์เซกชันในสถานการณ์จริง

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

ยินดีต้อนรับ

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

รูปแบบข้อมูลเสริม

จำลองฟังก์ชันหรือเหตุการณ์ที่อาจมีหรือไม่มีข้อมูลติดมาด้วยโดยใช้ยูเนียน
type Event =
  | { type: 'click'; x: number; y: number }
  | { type: 'keypress'; key: string }
  | { type: 'blur' };

ตัวสร้าง/มิกซ์อินด้วยอินเตอร์เซกชัน

ใช้อินเตอร์เซกชันเพื่อประกอบชุดความสามารถให้เป็นประเภทที่รวมกัน
type Serializable = { serialize(): string };
type Validatable = { validate(): boolean };
type Model = Serializable & Validatable & { id: number };

ยูเนียนสำหรับปรับรูปแบบอินพุตให้เป็นมาตรฐาน

รับประเภทอินพุตที่ยืดหยุ่นในฟังก์ชัน แล้วปรับให้เป็นประเภทมาตรฐาน
function toArray<T>(val: T | T[]): T[] {
  return Array.isArray(val) ? val : [val];
}

ประเภทมีตราประทับด้วยอินเตอร์เซกชัน

สร้างประเภทที่แตกต่างกันจากประเภทพื้นฐานเดียวกัน โดยใช้อินเตอร์เซกชันร่วมกับเครื่องหมายตราประทับเฉพาะ
type UserId = number & { __brand: 'UserId' };
type PostId = number & { __brand: 'PostId' };
// Prevents accidentally mixing IDs

รูปแบบ WithOptional

ใช้อินเตอร์เซกชันกับประเภทบางส่วน เพื่อสร้างประเภทพื้นฐานที่มีบางฟิลด์เป็นฟิลด์ที่ต้องมี และฟิลด์อื่นเป็นฟิลด์เสริม
type RequiredFields = { id: number; email: string };
type OptionalFields = Partial<{ name: string; bio: string }>;
type UserUpdate = RequiredFields & OptionalFields;

พร็อพส์ของคอมโพเนนต์หลายรูปแบบ

ในรีแอ็กต์ ประเภทยูเนียนช่วยให้พร็อพส์ของคอมโพเนนต์เปลี่ยนแปลงได้ตามตัวจำแนก
type ButtonProps =
  | { variant: 'primary'; onClick: () => void }
  | { variant: 'link'; href: string };

การขยายประเภทจากผู้ให้บริการภายนอก

ทำอินเตอร์เซกชันระหว่างประเภทจากผู้ให้บริการภายนอกกับส่วนเพิ่มเติมของคุณเอง
import type { Request } from 'express';
type AuthRequest = Request & { user: User };

การรวมยูเนียนกับอินเตอร์เซกชัน

สามารถรวมยูเนียนกับอินเตอร์เซกชันได้ วงเล็บจะควบคุมลำดับการดำเนินการ
type Admin = { role: 'admin' };
type User = { role: 'user' };
type LoggedIn = { sessionId: string };
type AuthUser = (Admin | User) & LoggedIn;

ตัวป้องกันประเภทสำหรับสมาชิกยูเนียน

เขียนฟังก์ชันตัวป้องกันประเภทที่นำกลับมาใช้ใหม่ได้ เพื่อจำกัดประเภทยูเนียนโดยไม่ต้องเขียนการตรวจสอบซ้ำ
function isAdmin(u: AuthUser): u is Admin & LoggedIn {
  return u.role === 'admin';
}

พฤติกรรมการแจกแจงในอินเตอร์เซกชัน

กฎการแจกแจง: A & (B | C) = (A & B) | (A & C) TypeScript จะใช้กฎนี้โดยอัตโนมัติ
type Base = { id: number };
type AB = Base & (string | number);
// equivalent to: (Base & string) | (Base & number)

ตรวจสอบความเข้าใจอย่างรวดเร็ว

รูปแบบใดสร้างประเภทที่แตกต่างจาก `number` เพื่อป้องกันการนำรหัสประจำตัวมาปะปนกันโดยไม่ตั้งใจ

ทบทวน

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

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

บทเรียน “รูปแบบการใช้งานจริงของยูเนียนและอินเตอร์เซกชัน” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “รูปแบบการใช้งานจริงของยูเนียนและอินเตอร์เซกชัน” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

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

  1. ชนิดยูเนียน: A หรือ B
  2. ชนิดอินเตอร์เซกชัน: A และ B
  3. ยูเนียนแบบมีตัวแยกแยะสำหรับการจับคู่รูปแบบอย่างปลอดภัย
  4. รูปแบบการใช้งานจริงของยูเนียนและอินเตอร์เซกชัน
← กลับไปที่ TypeScript Academy