TypeScript Academy · บทเรียน

การทำชนิดให้แคบลงด้วย typeof และค่าความจริง

ใช้การตรวจสอบ typeof เพื่อจำกัดชนิดพื้นฐานให้แคบลง

บทเรียน 1 จาก 413 ขั้นตอน

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

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

TypeScript จำกัดประเภทยูเนียนภายในบล็อกเงื่อนไข การตรวจสอบ `typeof` และการตรวจสอบค่าจริงเท็จเป็นเทคนิคการจำกัดประเภทที่ใช้บ่อยที่สุด

การจำกัดประเภทด้วย typeof

ใช้ `typeof` เพื่อตรวจสอบประเภทพื้นฐาน TypeScript เข้าใจการตรวจสอบ typeof และจำกัดประเภทภายในบล็อกได้
function process(val: string | number) {
  if (typeof val === 'string') {
    return val.toUpperCase(); // val: string
  }
  return val.toFixed(2); // val: number
}

ค่าที่ typeof ส่งกลับ

typeof ส่งกลับค่า 'string', 'number', 'boolean', 'bigint', 'symbol', 'undefined', 'object' หรือ 'function' หมายเหตุ: typeof null === 'object' ซึ่งเป็นลักษณะเฉพาะของ JavaScript
typeof 'hello'    // 'string'
typeof 42         // 'number'
typeof true       // 'boolean'
typeof null       // 'object' (quirk!)
typeof undefined  // 'undefined'

การจำกัดประเภทด้วยค่าจริงเท็จ

ค่าใน JavaScript เป็นค่าจริงหรือค่าเท็จ TypeScript จะจำกัด `T | null | undefined` ให้เหลือ `T` ภายในการตรวจสอบค่าจริงเท็จ
function greet(name: string | null) {
  if (name) {
    console.log('Hello, ' + name); // name: string
  } else {
    console.log('Hello, stranger');
  }
}

ค่าเท็จ

ค่าเท็จใน JavaScript ได้แก่ false, 0, '', null, undefined, 0n และ NaN การจำกัดประเภทด้วยค่าจริงเท็จจะนำค่าเหล่านี้ออกจากประเภทเมื่อการตรวจสอบผ่าน

การจำกัดประเภทด้วยการแปลงเป็นค่าบูลีน

การใช้ `Boolean(val)` หรือ `!!val` ก็จำกัด null และ undefined ออกจากประเภทได้เช่นกัน
const items: (string | null)[] = ['a', null, 'b', null];
const strings = items.filter((x): x is string => x !== null);

เงื่อนไขปฏิเสธ

TypeScript ยังจำกัดประเภทในสาขา else และหลังการส่งกลับก่อนกำหนดด้วย
function getLength(val: string | null): number {
  if (!val) return 0; // early return narrows
  return val.length;  // val: string here
}

การรวม typeof กับการเปรียบเทียบความเท่ากัน

การเปรียบเทียบความเท่ากันอย่างเคร่งครัด (===) เมื่อใช้ร่วมกับ typeof จะจำกัดประเภทได้อย่างแม่นยำ
function accept(x: string | number | boolean) {
  if (typeof x === 'string' || typeof x === 'number') {
    console.log(x); // x: string | number
  }
}

typeof ไม่สามารถจำกัดประเภทให้เป็น null ได้

หากต้องการจำกัดประเภทให้เป็น null ให้ใช้การเปรียบเทียบอย่างเคร่งครัด `=== null` การตรวจสอบค่าจริงเท็จไม่สามารถแยก null ออกจากค่าเท็จอื่น ๆ ได้
function check(x: string | null | 0) {
  if (x === null) { /* x: null */ }
  else if (x === 0) { /* x: 0 */ }
  else { /* x: string */ }
}

การจำกัดประเภทในลูป

TypeScript ใช้การจำกัดประเภทภายในเนื้อหาของลูปด้วย ไม่ได้จำกัดเฉพาะในคำสั่ง if เท่านั้น

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

TypeScript ติดตามประเภทในแต่ละจุดของโค้ดโดยใช้การวิเคราะห์ลำดับการควบคุม การกำหนดค่าก็อัปเดตประเภทด้วยเช่นกัน
let x: string | number = 'hello';
// x: string
x = 42;
// x: number

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

ภายใน `if (typeof val === 'string')` ประเภทของ `val` คืออะไร หากเดิมมีประเภทเป็น `string | number`

ทบทวน

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

เรียนรู้ TypeScript ด้วย AI tutor — ฟรี

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

คอร์ส
101
บทเรียน
352

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

บทเรียน “การทำชนิดให้แคบลงด้วย typeof และค่าความจริง” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “การทำชนิดให้แคบลงด้วย typeof และค่าความจริง”

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

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

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

บทเรียน “การทำชนิดให้แคบลงด้วย typeof และค่าความจริง” ใช้เวลานานแค่ไหน

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

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

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

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

  1. การทำชนิดให้แคบลงด้วย typeof และค่าความจริง
  2. การทำชนิดให้แคบลงด้วย instanceof และ in
  3. ฟังก์ชันตรวจสอบชนิดที่ผู้ใช้กำหนด
  4. ตรวจสอบความครอบคลุมทุกกรณีด้วย never
← กลับไปที่ TypeScript Academy