บทนำเกี่ยวกับการจำกัดประเภทข้อมูลขั้นสูงให้แคบลง

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

เครื่องมือเหล่านี้ช่วยให้โค้ด TypeScript ของคุณปลอดภัยและคาดการณ์ได้มากขึ้น

การจำกัดประเภทข้อมูลให้แคบลงคืออะไร

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

การใช้ typeof เพื่อจำกัดประเภทข้อมูลให้แคบลง

สามารถใช้ตัวดำเนินการ typeof เพื่อจำกัดประเภทพื้นฐานให้แคบลงได้:

function printValue(value: string | number): void {
  if (typeof value === 'string') {
    console.log(`String: ${value}`);
  } else {
    console.log(`Number: ${value}`);
  }
}

printValue('Hello'); // String: Hello
printValue(42); // Number: 42

การใช้ instanceof เพื่อจำกัดประเภทข้อมูลให้แคบลง

สามารถใช้ตัวดำเนินการ instanceof เพื่อจำกัดอินสแตนซ์ของคลาสให้แคบลงได้:

class Dog {
  bark() {
    console.log('Woof!');
  }
}

class Cat {
  meow() {
    console.log('Meow!');
  }
}

function makeSound(animal: Dog | Cat): void {
  if (animal instanceof Dog) {
    animal.bark();
  } else {
    animal.meow();
  }
}

makeSound(new Dog()); // Woof!
makeSound(new Cat()); // Meow!

การใช้ตัวตรวจสอบประเภทแบบกำหนดเอง

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

type Fish = { swim: () => void };
type Bird = { fly: () => void };

declare const animal: Fish | Bird;

function isFish(animal: Fish | Bird): animal is Fish {
  return (animal as Fish).swim !== undefined;
}

if (isFish(animal)) {
  animal.swim();
} else {
  animal.fly();

การวิเคราะห์ลำดับการควบคุม

การวิเคราะห์ลำดับการควบคุมของ TypeScript จะจำกัดประเภทให้แคบลงโดยอัตโนมัติตามลำดับตรรกะของโค้ด:

function getLength(value: string | string[]): number {
  if (Array.isArray(value)) {
    return value.length;
  } else {
    return value.length;
  }
}

console.log(getLength('Hello')); // 5
console.log(getLength(['a', 'b', 'c'])); // 3

ประโยชน์ของการจำกัดประเภทข้อมูลขั้นสูงให้แคบลง

การจำกัดประเภทข้อมูลขั้นสูงให้แคบลงช่วยปรับปรุงโค้ดของคุณโดย:

• ลดข้อผิดพลาดขณะทำงาน
• ทำให้โค้ดปลอดภัยและเข้าใจได้ง่ายขึ้น
• ช่วยให้ควบคุมการจัดการประเภทข้อมูลได้อย่างแม่นยำ

ภารกิจฝึกปฏิบัติ

สร้างฟังก์ชันที่รับพารามิเตอร์ประเภท string | number และบันทึกข้อความที่แตกต่างกันสำหรับแต่ละประเภท ใช้ typeof เพื่อดำเนินตรรกะดังกล่าว

ขอแสดงความยินดี!

คุณได้เรียนรู้วิธีใช้เทคนิคการจำกัดประเภทข้อมูลขั้นสูงให้แคบลงใน TypeScript เพื่อปรับและจัดการประเภทที่ซับซ้อนได้อย่างปลอดภัยและมีประสิทธิภาพแล้ว โปรดฝึกใช้เทคนิคเหล่านี้เพื่อทำให้โค้ดของคุณแข็งแกร่งและปลอดภัยด้านประเภทข้อมูลยิ่งขึ้น!