PricingLoginStart free
TypeScript Academy · Pelajaran

Penjumlahan dan Pengurangan Tingkat Jenis

Bangun operasi aritmetika dari manipulasi tuple.

Pelajaran 2 dari 413 langkah

Penjumlahan dan Pengurangan Tingkat Jenis adalah pelajaran TypeScript Academy gratis di CoddyKit. Ini adalah pelajaran 2 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.

Aritmetika berdasarkan Panjang

Dengan representasi berdasarkan panjang tupel, penjumlahan menjadi penggabungan dan pengurangan menjadi penghapusan awalan. Anda menghitung pada tupel, lalu membaca panjang hasilnya.

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

Penjumlahan

Untuk menjumlahkan A + B: bangun tupel dengan panjang A, bangun tupel lain dengan panjang B, bentangkan keduanya ke dalam tupel baru, lalu baca panjangnya.

type Add<A extends number, B extends number> =
  [...BuildTuple<A>, ...BuildTuple<B>]["length"];

type S = Add<3, 4>; // 7

Mengapa Penggabungan Menghasilkan Penjumlahan

Tupel dengan panjang 3 yang diikuti tupel dengan panjang 4 menghasilkan tupel dengan panjang 7. Menggabungkan tanda dari dua catatan hitungan menghasilkan catatan gabungan, sehingga panjangnya dijumlahkan.

type A = Add<2, 2>; // 4
type B = Add<0, 5>; // 5
type C = Add<1, 6>; // 7

Pengurangan berdasarkan Awalan

Untuk menghitung A - B: bangun tupel dengan panjang A, lalu simpulkan tupel tersebut sebagai awalan dengan panjang B yang diikuti bagian sisa. rest memiliki panjang A - B.

type Sub<A extends number, B extends number> =
  BuildTuple<A> extends [...BuildTuple<B>, ...infer Rest]
    ? Rest["length"]
    : never;

type D = Sub<7, 4>; // 3

Menelusuri Pengurangan

Untuk Sub<7, 4>: bangun tupel dengan panjang 7, cocokkan awalan dengan panjang 4, tangkap Rest (panjang 3), lalu baca panjangnya. Awalan yang dihapus tepat sejumlah B tanda.

type A = Sub<5, 2>; // 3
type B = Sub<4, 4>; // 0

Kekurangan Menghasilkan Tipe Mustahil

Bilangan tingkat tipe di sini tidak negatif. Jika B > A, tidak ada awalan yang valid, pola gagal dicocokkan, dan hasilnya adalah never. Anda dapat mengubah nilai bawaannya menjadi 0 jika menginginkannya.

type A = Sub<2, 5>; // never

type SubSafe<A extends number, B extends number> =
  [Sub<A, B>] extends [never] ? 0 : Sub<A, B>;
type B = SubSafe<2, 5>; // 0

Penambahan dan Pengurangan Satu

Kasus khusus penambahan dan pengurangan satu cukup umum untuk diberi nama. Inc menambahkan satu elemen; Dec menghapus satu elemen.

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

type A = Inc<4>; // 5
type B = Dec<4>; // 3

Perkalian dengan Pengulangan

Perkalian adalah penjumlahan berulang. Tambahkan B ke akumulator sebanyak A kali dengan menghitung mundur menggunakan Dec dan mengakumulasikan hasilnya menggunakan Add.

type Mul<A extends number, B extends number, Acc extends number = 0> =
  A extends 0 ? Acc : Mul<Dec<A>, B, Add<Acc, B>>;

type A = Mul<3, 4>; // 12

Pembantu BuildTuple

Setiap operasi di sini bergantung pada BuildTuple. Ini adalah primitif yang dapat digunakan kembali: berikan sebuah bilangan, dan dapatkan tupel dengan panjang tersebut. Simpan di satu tempat, lalu bangun bagian lainnya di atasnya.

type Five = BuildTuple<5>; // [unknown, unknown, unknown, unknown, unknown]
type N = Five["length"];   // 5

Menggabungkan Operasi

Karena setiap operasi menerima dan mengembalikan bilangan, operasi-operasi tersebut dapat digabungkan dengan bebas. Anda dapat menulis ekspresi seperti Add<Mul<2, 3>, 4>, dan kompilator akan mengevaluasinya.

type Result = Add<Mul<2, 3>, 4>; // 10

Kehati-hatian Praktis

Trik ini sangat baik untuk jumlah kecil: indeks larik, ukuran tetap, dan rentang terbatas. Untuk bilangan besar atau matematika umum, batas rekursi dan ketiadaan bilangan negatif membuatnya tidak praktis. Gunakan trik ini ketika nilainya tetap kecil dan statis.

type A = Add<8, 7>;  // 15 (fine)
// Add<5000, 5000> would exceed recursion limits

Pemeriksaan Singkat

Ujilah pemahaman Anda tentang aritmetika tingkat tipe.

Jawab di pelajaran interaktif

Ringkasan

Anda telah mengimplementasikan aritmetika dalam sistem tipe.

  • Add: gabungkan tupel, lalu baca panjangnya.
  • Sub: simpulkan sebuah awalan, lalu baca panjang sisanya.
  • Inc/Dec adalah versi satu langkah.
  • BuildTuple adalah primitif yang digunakan bersama.

Berikutnya: membandingkan bilangan pada tingkat tipe.

Gratis untuk memulai

Belajar TypeScript dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus
101
Pelajaran
352
Mulai belajar gratisLihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Penjumlahan dan Pengurangan Tingkat Jenis” gratis?

Ya — teks lengkap “Penjumlahan dan Pengurangan Tingkat Jenis” 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 “Penjumlahan dan Pengurangan Tingkat Jenis”?

Bangun operasi aritmetika dari manipulasi tuple. 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 2 dari 4.

Berapa lama pelajaran “Penjumlahan dan Pengurangan Tingkat Jenis” 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