TypeScript Academy · บทเรียน

การเปรียบเทียบระดับชนิดข้อมูล

เปรียบเทียบตัวเลขทั้งหมดในระดับชนิดข้อมูล

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

การเปรียบเทียบตัวเลข

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

type BuildTuple<N extends number, Acc extends unknown[] = []> =
  Acc["length"] extends N ? Acc : BuildTuple<N, [...Acc, unknown]>;

ความเท่ากันของลิเทอรัล

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

type NumEquals<A extends number, B extends number> =
  [A] extends [B] ? ([B] extends [A] ? true : false) : false;

type X = NumEquals<3, 3>; // true
type Y = NumEquals<3, 4>; // false

การตรวจสอบค่ามากกว่าด้วยการลดขนาด

สำหรับ A > B ให้สร้างทูเพิลสำหรับทั้งสองค่า แล้วนำองค์ประกอบออกจากแต่ละทูเพิลทีละหนึ่ง หาก B ว่างก่อนในขณะที่ A ยังมีองค์ประกอบอยู่ แสดงว่า A มีค่ามากกว่า

type GreaterThan<A extends number, B extends number> =
  BuildTuple<A> extends [...BuildTuple<B>, unknown, ...unknown[]]
    ? true : false;

type X = GreaterThan<5, 3>; // true
type Y = GreaterThan<3, 5>; // false

การอ่านรูปแบบนี้

รูปแบบ [...BuildTuple<B>, unknown, ...unknown[]] หมายความว่า: มีคำนำหน้าความยาว B แล้วตามด้วยองค์ประกอบอีกอย่างน้อยหนึ่งตัว หาก A เข้ากับรูปแบบนี้ แสดงว่า A มีองค์ประกอบมากกว่า B ดังนั้น A > B

type A = GreaterThan<4, 4>; // false (no extra element)
type B = GreaterThan<6, 2>; // true

ค่าน้อยกว่า

LessThan เป็นเพียง GreaterThan ที่สลับอาร์กิวเมนต์กัน ควรนำกลับมาใช้ซ้ำแทนการสร้างอนุพันธ์ขึ้นใหม่

type LessThan<A extends number, B extends number> =
  GreaterThan<B, A>;

type X = LessThan<3, 5>; // true
type Y = LessThan<5, 3>; // false

ค่ามากกว่าหรือเท่ากับ

รวมการเปรียบเทียบเข้ากับการตรวจสอบความเท่ากัน A >= B เป็นจริงเมื่อ A > B หรือ A == B

type Gte<A extends number, B extends number> =
  GreaterThan<A, B> extends true
    ? true
    : NumEquals<A, B>;

type X = Gte<5, 5>; // true
type Y = Gte<3, 5>; // false

การเปรียบเทียบแบบเรียกซ้ำ

อีกวิธีหนึ่งคือเปรียบเทียบโดยลดค่าของทั้งสองลงจนกว่าค่าหนึ่งจะถึงศูนย์ วิธีนี้แสดงแนวคิดการลดพร้อมกันทีละขั้นอย่างชัดเจนว่า ค่าที่ถึงศูนย์ก่อนคือค่าที่น้อยกว่า

type Cmp<A extends number, B extends number> =
  A extends 0
    ? (B extends 0 ? "eq" : "lt")
    : B extends 0
      ? "gt"
      : Cmp<Dec<A>, Dec<B>>;

type X = Cmp<3, 5>; // "lt"

การพึ่งพาการลดค่า

รูปแบบแบบเรียกซ้ำต้องใช้ Dec จากบทเรียนก่อนหน้า แต่ละขั้นจะนำขีดนับจำนวนออกจากแต่ละฝั่งหนึ่งขีด เมื่อทั้งสองค่าเป็นศูนย์ แสดงว่าค่าเท่ากัน หากมีเพียงค่าเดียวที่เป็นศูนย์ อีกค่าหนึ่งจะมากกว่า

type Dec<N extends number> =
  BuildTuple<N> extends [unknown, ...infer R] ? R["length"] : 0;

ความเท่ากันกับความสามารถในการกำหนดค่าให้กัน

โปรดระวัง: number extends number เป็นจริง แต่ไม่ได้หมายความว่าเป็นความเท่ากันของลิเทอรัล การเปรียบเทียบในที่นี้สมมติว่าเป็นชนิดลิเทอรัลที่เฉพาะเจาะจง เช่น 3 และ 5 ไม่ใช่ชนิด number แบบกว้าง

type A = NumEquals<3, 3>;          // true
type B = 3 extends number ? 1 : 0; // 1 (assignability, not equality)

การสร้างเกณฑ์การเรียงลำดับ

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

type IsSorted<A extends number, B extends number> =
  GreaterThan<A, B> extends true ? false : true;

type X = IsSorted<2, 5>; // true
type Y = IsSorted<5, 2>; // false

ใช้เท่าที่จำเป็น

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

type A = GreaterThan<9, 4>; // true (cheap, prefix pattern)

ตรวจสอบความเข้าใจ

ทดสอบความเข้าใจของคุณเกี่ยวกับการเปรียบเทียบระดับชนิด

ทบทวน

ตอนนี้คุณสามารถจัดลำดับตัวเลขในระบบชนิดได้แล้ว

ตรวจสอบความเท่ากันด้วยความสามารถในการกำหนดค่าให้กันของลิเทอรัลทั้งสองฝ่าย
GreaterThan ใช้คำนำหน้าความยาว B และองค์ประกอบเพิ่มเติมอีกหนึ่งตัว
LessThan สลับอาร์กิวเมนต์ ส่วน Gte เพิ่มการตรวจสอบความเท่ากัน
ใช้ได้กับตัวเลขลิเทอรัลขนาดเล็ก ไม่ใช่ชนิด number แบบกว้าง

ถัดไป: เปลี่ยนทั้งหมดนี้ให้เป็นตัวช่วยที่ใช้งานจริง

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

บทเรียน “การเปรียบเทียบระดับชนิดข้อมูล” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “การเปรียบเทียบระดับชนิดข้อมูล”

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

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

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

บทเรียน “การเปรียบเทียบระดับชนิดข้อมูล” ใช้เวลานานแค่ไหน

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

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

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

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

← กลับไปที่ TypeScript Academy