0Pricing
TypeScript Academy · Pelajaran

Menghitung dengan Panjang Tuple

Representasikan angka sebagai panjang tuple dalam jenis.

Menghitung dengan Panjang Tuple adalah pelajaran TypeScript Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar TypeScript Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus TypeScript Academy mencakup 4 pelajaran total.

Angka Memerlukan Representasi

Sistem tipe tidak dapat langsung menjumlahkan literal numerik. Solusi klasiknya adalah merepresentasikan angka N sebagai tupel dengan N elemen. Isinya tidak penting; yang penting hanyalah panjangnya.

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

Membaca Panjang

Setiap tipe tupel memiliki properti length yang merupakan tipe literal numerik. Pengindeksan dengan ["length"] membacanya kembali sebagai bilangan yang dapat Anda gunakan.

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

Mengapa Pengisi unknown

Kami menggunakan unknown sebagai tipe elemen karena nilainya tidak relevan; yang penting hanyalah jumlahnya. Tipe apa pun dapat digunakan, tetapi unknown menandakan "penanda tempat" dengan jelas.

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

Membangun Tupel dengan Panjang N

Untuk melakukan hal sebaliknya, bangun tupel dengan panjang target menggunakan rekursi. Tambahkan elemen hingga panjangnya sama dengan N, lalu kembalikan tupel tersebut. Inilah pembantu BuildTuple yang terkenal.

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

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

Cara BuildTuple Mengulang

Telusuri BuildTuple<3>:

  • Panjang akumulator 0, bukan 3, tambahkan satu
  • Panjang akumulator 1, bukan 3, tambahkan satu
  • Panjang akumulator 2, bukan 3, tambahkan satu
  • Panjang akumulator 3, sama dengan 3, kembalikan

Panjang akumulator adalah penghitung perulangan.

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

Panjang Adalah Jembatannya

Dua operasi memungkinkan Anda berpindah antara bilangan dan tupel:

  • Bilangan ke tupel: BuildTuple<N>
  • Tupel ke bilangan: T["length"]

Semua aritmetika tipe dibangun dengan melintasi jembatan ini.

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

Membandingkan berdasarkan Panjang

Karena panjang tupel adalah literal, Anda dapat memeriksa kesamaan jumlah. Bangun tupel, lalu bandingkan panjangnya melalui kompatibilitas penetapan.

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

Penghitung Panjang Generik

Anda dapat mengimplementasikan kembali length melalui rekursi untuk memahaminya, meskipun membaca ["length"] lebih cepat. Ini menunjukkan bahwa menghitung hanyalah menelusuri sebuah tupel.

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

Tupel sebagai Penghitung

Anggap tupel sebagai catatan hitungan: setiap elemen adalah satu tanda. Menambahkan elemen menambah hitungan; menghapusnya mengurangi hitungan. Model mental ini membuat aritmetika lebih mudah dipahami.

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

type A = Inc<3>; // 4

Pratinjau Pengurangan Satu

Pengurangan satu membangun tupel untuk N, lalu menyimpulkan semua hal kecuali elemen terakhir dan membaca panjang yang lebih pendek. Anda akan meresmikan cara ini dalam pelajaran berikutnya.

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

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

Batas yang Perlu Diingat

Teknik ini bekerja untuk bilangan bulat kecil yang tidak negatif. N yang sangat besar mencapai batas rekursi, dan tidak ada fitur bawaan untuk bilangan negatif atau desimal. Dalam batas tersebut, teknik ini andal dan sepenuhnya statis.

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

Pemeriksaan Singkat

Ujilah pemahaman Anda tentang penghitungan berdasarkan panjang tupel.

Ringkasan

Penghitungan adalah dasar matematika tingkat tipe.

  • Representasikan N sebagai tupel dengan panjang N.
  • Baca bilangannya dengan T["length"].
  • BuildTuple<N> mengubah bilangan menjadi tupel.
  • Hanya bekerja untuk bilangan bulat kecil yang tidak negatif.

Berikutnya: penjumlahan dan pengurangan sungguhan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menghitung dengan Panjang Tuple” gratis?

Ya — teks lengkap “Menghitung dengan Panjang Tuple” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus TypeScript Academy, upgrade ke CoddyKit PRO. Kursus TypeScript Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Menghitung dengan Panjang Tuple”?

Representasikan angka sebagai panjang tuple dalam jenis. Kamu berlatih TypeScript Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai TypeScript Academy?

Tidak diperlukan pengalaman sebelumnya. TypeScript Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Menghitung dengan Panjang Tuple” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran TypeScript Academy ini?

Ya. Setiap pelajaran TypeScript Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Menghitung dengan Panjang Tuple
  2. Penjumlahan dan Pengurangan Tingkat Jenis
  3. Perbandingan Tingkat Jenis
  4. Utilitas Jenis Numerik Praktis
← Kembali ke TypeScript Academy