TypeScript Academy · Pelajaran

Menentukan Jenis Fungsi Variadik

Bangun API fleksibel dengan jenis tuple variadik.

Menentukan Jenis Fungsi Variadik adalah pelajaran TypeScript Academy gratis di CoddyKit. Ini adalah pelajaran 4 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.

Fungsi Variadik Generik

Tipe tupel variadik memungkinkan generik menangkap dan memanipulasi daftar argumen. Hal ini membuka jalan bagi utilitas yang menggabungkan tupel, meneruskan parameter, dan mengubah bentuk signatur pemanggilan dengan keamanan tipe penuh.

Menangkap Argumen sebagai Tupel

Generik yang dibatasi oleh unknown[] dapat menangkap seluruh daftar argumen sebagai tipe tupel T, dengan mempertahankan tipe dan posisi setiap parameter.

function tuple<T extends unknown[]>(...args: T): T {
  return args
}
const t = tuple("a", 1, true) // type [string, number, boolean]
console.log(t)

Menyebarkan Tupel Generik

Anda dapat menyebarkan tupel generik yang telah ditangkap ke dalam daftar parameter lain. Dengan demikian, argumen dapat diteruskan sambil mempertahankan tipe persisnya.

function wrap<T extends unknown[]>(fn: (...args: T) => void) {
  return (...args: T) => fn(...args)
}
const log = wrap((n: number, s: string) => console.log(n, s))
log(1, "hi")

Menggabungkan Dua Tupel

Tipe tupel variadik sangat berguna saat menggabungkan tupel. Menyebarkan dua tupel generik dalam tipe hasil menghasilkan gabungan keduanya.

function concat<A extends unknown[], B extends unknown[]>(a: A, b: B): [...A, ...B] {
  return [...a, ...b]
}
const r = concat([1, 2], ["a"]) // [number, number, string]
console.log(r)

Mengapa Tipe Hasilnya Tepat

Karena [...A, ...B] menyebarkan tupel generik, hasilnya mempertahankan tipe dan urutan setiap elemen — bukan sekadar larik gabungan yang diperlebar.

function concat<A extends unknown[], B extends unknown[]>(a: A, b: B): [...A, ...B] {
  return [...a, ...b]
}
const r = concat([true], [42])
const flag: boolean = r[0]
const num: number = r[1]
console.log(flag, num)

Menambahkan Argumen di Awal

Tupel variadik memungkinkan Anda mengubah bentuk daftar parameter — misalnya, fungsi yang menambahkan argumen awal ke signatur fungsi panggilan balik.

function withId<T extends unknown[]>(fn: (...args: T) => void) {
  return (id: number, ...rest: T) => {
    console.log("id", id)
    fn(...rest)
  }
}
const f = withId((msg: string) => console.log(msg))
f(7, "hello")

Mengekstrak Tipe Kepala

Dengan parameter tupel, Anda dapat memisahkan tipe elemen pertama dan sisanya menggunakan tupel berlabel, lalu mengolah setiap bagian.

function head<H, T extends unknown[]>(...args: [H, ...T]): H {
  return args[0]
}
const h = head("first", 2, 3) // type string
console.log(h)

Tipe Utilitas Parameters

Parameters<F> bawaan mengekstrak daftar argumen fungsi sebagai tupel — yang juga dibangun berdasarkan tipe tupel variadik. Anda dapat menggunakan kembali parameter suatu signatur di tempat lain.

function greet(name: string, age: number) {}
type GreetArgs = Parameters<typeof greet> // [string, number]
const args: GreetArgs = ["Ada", 36]
console.log(args)

Meneruskan dengan Parameters

Gabungkan Parameters dengan penyebaran sisa untuk membuat pembungkus yang meneruskan argumen ke fungsi yang sudah ada dengan pengetikan identik.

function add(a: number, b: number) { return a + b }
function traced(...args: Parameters<typeof add>): number {
  console.log("calling add", args)
  return add(...args)
}
console.log(traced(2, 3))

Membangun Signatur Mirip Curry

Tupel variadik memungkinkan pembantu penerapan parsial: tangkap beberapa argumen sekarang, lalu harapkan sisanya nanti, semuanya diperiksa tipenya.

function partial<A extends unknown[], B extends unknown[], R>(
  fn: (...args: [...A, ...B]) => R,
  ...a: A
) {
  return (...b: B) => fn(...a, ...b)
}
const addThree = (x: number, y: number, z: number) => x + y + z
const add5 = partial(addThree, 5)
console.log(add5(2, 3)) // 10

Kekuatan dan Kehati-hatian

Generik tupel variadik memberi Anda alat pembentuk fungsi yang tepat dan dapat digunakan kembali — pembungkus, penerus, dan penggabung. Fitur ini bersifat lanjut, jadi gunakan ketika ketepatan tipe benar-benar sepadan dengan kerumitannya.

function pipe2<A extends unknown[], B, C>(
  f: (...a: A) => B,
  g: (b: B) => C
) {
  return (...a: A) => g(f(...a))
}
const fn = pipe2((n: number) => n * 2, (n) => n + 1)
console.log(fn(5)) // 11

Pemeriksaan Singkat

Uji pemahaman Anda tentang generik tupel variadik.

Rangkuman

Tipe tupel variadik memungkinkan generik menangkap daftar argumen sebagai tupel dan menyebarkannya pada posisi parameter atau hasil. Fitur ini mendukung penggabungan tupel ([...A, ...B]), penerusan argumen, pemisahan kepala dan ekor, serta penerapan parsial — semuanya dengan tipe elemen yang tetap persis. Fitur bawaan seperti Parameters<F> mengandalkan mekanisme yang sama. Gunakan alat ini ketika pengetikan bentuk fungsi yang tepat sepadan dengan kerumitannya.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menentukan Jenis Fungsi Variadik” gratis?

Ya — teks lengkap “Menentukan Jenis Fungsi Variadik” 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 “Menentukan Jenis Fungsi Variadik”?

Bangun API fleksibel dengan jenis tuple variadik. 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 4 dari 4.

Berapa lama pelajaran “Menentukan Jenis Fungsi Variadik” 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

← Kembali ke TypeScript Academy