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

ชนิดยูเนียน: A หรือ B

ใช้ | เพื่อรองรับความเป็นไปได้ของชนิดหลายแบบ

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

เริ่มต้นใช้งาน

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

ไวยากรณ์ยูเนียนพื้นฐาน

รวมประเภทตั้งแต่สองประเภทขึ้นไปด้วย `|` ตัวแปรที่มีประเภทยูเนียนสามารถเก็บค่าใดค่าหนึ่งจากประเภทที่ระบุไว้ได้
let id: string | number;
id = 'abc123'; // OK
id = 42;       // OK
// id = true;  // Error

ยูเนียนในพารามิเตอร์ฟังก์ชัน

รองรับประเภทอินพุตหลายประเภทในฟังก์ชันโดยใช้ประเภทพารามิเตอร์แบบยูเนียน
function format(val: string | number): string {
  return typeof val === 'string' ? val.toUpperCase() : val.toFixed(2);
}

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

คุณสามารถเรียกใช้ได้เฉพาะเมธอดที่มีร่วมกันในสมาชิกยูเนียนทั้งหมดโดยไม่ต้องจำกัดประเภท หากต้องการใช้เมธอดเฉพาะประเภท คุณต้องจำกัดประเภทก่อน
function process(val: string | number) {
  // val.toFixed(2); // Error — not on string
  if (typeof val === 'number') {
    val.toFixed(2); // OK
  }
}

ยูเนียนกับประเภทลิเทอรัล

ประเภทยูเนียนของค่าลิเทอรัลจะสร้างชุดค่าที่อนุญาตซึ่งคล้ายกับรายการแจกแจง โดยใช้ค่าสตริงหรือตัวเลข
type Direction = 'north' | 'south' | 'east' | 'west';
type StatusCode = 200 | 201 | 400 | 404 | 500;

ยูเนียนสำหรับประเภทที่อาจว่างเปล่า

ยูเนียนที่ใช้บ่อยที่สุดคือ `T | null` หรือ `T | undefined` เพื่อแทนค่าที่อาจไม่มี เมื่อเปิดใช้ strictNullChecks
function getUser(id: number): User | null {
  return db.find(u => u.id === id) ?? null;
}

ยูเนียนของประเภทอ็อบเจ็กต์

ประเภทยูเนียนสามารถรวมประเภทอ็อบเจ็กต์เข้าด้วยกันได้ TypeScript อนุญาตให้เข้าถึงเฉพาะคุณสมบัติที่มีร่วมกันในสมาชิกทั้งหมดโดยไม่ต้องจำกัดประเภท
type Cat = { kind: 'cat'; meow(): void };
type Dog = { kind: 'dog'; bark(): void };
type Pet = Cat | Dog;
function speak(pet: Pet) {
  if (pet.kind === 'cat') pet.meow();
  else pet.bark();
}

ยูเนียนที่มีสามประเภทขึ้นไป

ประเภทยูเนียนสามารถมีประเภทได้มากเท่าที่จำเป็น
type Input = string | number | boolean | null;

ยูเนียนในประเภทค่าที่ส่งกลับ

ฟังก์ชันสามารถส่งกลับประเภทที่แตกต่างกันได้ตามตรรกะการทำงาน คุณสามารถแสดงสิ่งนี้ด้วยประเภทยูเนียนของค่าที่ส่งกลับ
function divide(a: number, b: number): number | null {
  if (b === 0) return null;
  return a / b;
}

ยูเนียนแบบมีตัวจำแนก

เพิ่มคุณสมบัติลิเทอรัลร่วมกันหนึ่งรายการ ซึ่งเรียกว่าตัวจำแนก ให้กับสมาชิกยูเนียน TypeScript จะใช้คุณสมบัตินี้เพื่อจำกัดประเภทโดยอัตโนมัติ
type Square = { kind: 'square'; side: number };
type Circle = { kind: 'circle'; radius: number };
type Shape = Square | Circle;

คุณสมบัติร่วมกันโดยไม่ต้องจำกัดประเภท

หากสมาชิกยูเนียนทั้งหมดมีคุณสมบัติเดียวกัน คุณสามารถเข้าถึงคุณสมบัตินั้นได้โดยไม่ต้องจำกัดประเภท
type A = { name: string; x: number };
type B = { name: string; y: number };
type AB = A | B;
function getName(obj: AB): string {
  return obj.name; // OK — name is on both
}

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

ไวยากรณ์ใดสร้างประเภทยูเนียนที่อาจเป็นสตริงหรือตัวเลขได้

ทบทวน

ประเภทยูเนียน (`|`) อนุญาตให้มีค่าจากหลายประเภทได้ ควรจำกัดประเภทยูเนียนก่อนใช้การดำเนินการเฉพาะประเภท ประเภทยูเนียนของค่าลิเทอรัลจะจำกัดค่าให้อยู่ในชุดที่มีจำนวนจำกัด ยูเนียนแบบมีตัวจำแนกจะเพิ่มแท็กร่วมเพื่อให้จำกัดประเภทได้ง่ายขึ้น

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

บทเรียน “ชนิดยูเนียน: A หรือ B” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “ชนิดยูเนียน: A หรือ B”

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

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

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

บทเรียน “ชนิดยูเนียน: A หรือ B” ใช้เวลานานแค่ไหน

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

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

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

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

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