TypeScript Academy · บทเรียน

การนับด้วยความยาวทูเพิล

แทนตัวเลขด้วยความยาวของทูเพิลในชนิดข้อมูล

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

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

ตัวเลขต้องมีรูปแบบแทนค่า

ระบบชนิดข้อมูลไม่สามารถบวกค่าลิเทอรัลตัวเลขโดยตรงได้ วิธีแก้แบบดั้งเดิมคือแทนตัวเลข N ด้วย ทูเพิลที่มีสมาชิก N ตัว เนื้อหาของสมาชิกไม่สำคัญ สิ่งที่สำคัญมีเพียงความยาวเท่านั้น

type Three = [unknown, unknown, unknown];
type N = Three["length"]; // 3

การอ่านความยาว

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

type A = [1, 2, 3, 4]["length"]; // 4
type B = []["length"];           // 0
type C = ["x"]["length"];        // 1

เหตุใดจึงใช้ตัวเติมชนิดไม่ทราบ

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

type Two = [unknown, unknown];
type N = Two["length"]; // 2

การสร้างทูเพิลที่มีความยาว N

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

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

type A = BuildTuple<3>; // [unknown, unknown, unknown]

การวนซ้ำของ BuildTuple ทำงานอย่างไร

ติดตามการทำงานของ BuildTuple<3>:

ความยาวของตัวสะสมเป็น 0 ยังไม่เท่ากับ 3 จึงเพิ่มหนึ่ง
ความยาวของตัวสะสมเป็น 1 ยังไม่เท่ากับ 3 จึงเพิ่มหนึ่ง
ความยาวของตัวสะสมเป็น 2 ยังไม่เท่ากับ 3 จึงเพิ่มหนึ่ง
ความยาวของตัวสะสมเป็น 3 เท่ากับ 3 แล้วจึงคืนค่า

ความยาวของตัวสะสมคือ ตัวนับการวนซ้ำ

type A = BuildTuple<2>; // [unknown, unknown]

ความยาวคือสะพานเชื่อม

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

ตัวเลขเป็นทูเพิล: BuildTuple<N>
ทูเพิลเป็นตัวเลข: T["length"]

การคำนวณระดับชนิดทั้งหมดสร้างขึ้นจากการข้ามสะพานนี้

type FromN = BuildTuple<4>;        // tuple of length 4
type BackToN = FromN["length"];    // 4

การเปรียบเทียบด้วยความยาว

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

type SameLength<A extends unknown[], B extends unknown[]> =
  A["length"] extends B["length"] ? true : false;

type X = SameLength<[1, 2], ["a", "b"]>;   // true
type Y = SameLength<[1], ["a", "b"]>;      // false

ตัวนับความยาวแบบทั่วไป

คุณสามารถสร้าง length ขึ้นมาใหม่ด้วยการเรียกซ้ำเพื่อทำความเข้าใจการทำงาน แม้ว่าการอ่าน ["length"] จะเร็วกว่า วิธีนี้แสดงให้เห็นว่าการนับเป็นเพียงการไล่ดูองค์ประกอบของทูเพิล

type Len<T extends unknown[], Acc extends unknown[] = []> =
  T extends [unknown, ...infer R]
    ? Len<R, [...Acc, unknown]>
    : Acc["length"];

type A = Len<["a", "b", "c"]>; // 3

ทูเพิลในฐานะตัวนับ

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

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

type A = Inc<3>; // 4

ตัวอย่างการลดค่าล่วงหน้า

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

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

type A = Dec<3>; // 2
type B = Dec<0>; // 0

ข้อจำกัดที่ควรจำ

เทคนิคนี้ใช้ได้กับจำนวนเต็มไม่ติดลบขนาดเล็ก ค่า N ที่ใหญ่มากจะชนขีดจำกัดการเรียกซ้ำ และไม่มีสิ่งที่มีมาให้ในตัวสำหรับค่าติดลบหรือทศนิยม ภายในขอบเขตนี้ เทคนิคนี้เชื่อถือได้และเป็นแบบคงที่ทั้งหมด

type A = BuildTuple<5>["length"]; // 5 (fine)
// BuildTuple<10000> would error: too deep

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

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

ตอบคำถามในบทเรียนแบบโต้ตอบ

ทบทวน

การนับคือพื้นฐานของคณิตศาสตร์ระดับชนิด

แทนค่า N ด้วยทูเพิลที่มีความยาว N
อ่านตัวเลขด้วย T["length"]
BuildTuple<N> เปลี่ยนจากตัวเลขเป็นทูเพิล
ใช้ได้เฉพาะกับจำนวนเต็มไม่ติดลบขนาดเล็ก

ถัดไป: การบวกและการลบจริง

เริ่มต้นได้ฟรี

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

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

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

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

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

บทเรียน “การนับด้วยความยาวทูเพิล” ฟรีหรือไม่

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

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

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

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

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

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

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

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

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

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

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