TypeScript Academy · Pelajaran

Mentaip Fungsi Variadik

Bina API fleksibel dengan jenis tuple variadik.

Pelajaran 4 daripada 413 langkah

Mentaip Fungsi Variadik ialah pelajaran TypeScript Academy percuma di CoddyKit. Ini ialah pelajaran 4 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran TypeScript Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus TypeScript Academy merangkumi sejumlah 4 pelajaran.

Fungsi Variadik Generik

Jenis tupel variadik membolehkan generik menangkap dan memanipulasi senarai hujah. Ini membuka jalan kepada utiliti yang menggabungkan tupel, meneruskan parameter, dan mengubah bentuk tandatangan panggilan dengan keselamatan jenis sepenuhnya.

Menangkap Hujah sebagai Tupel

Generik yang dihadkan kepada unknown[] boleh menangkap keseluruhan senarai hujah sebagai jenis tupel T, sambil mengekalkan jenis dan kedudukan 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 boleh menyebarkan tupel generik yang ditangkap ke dalam senarai parameter lain. Ini meneruskan hujah sambil mengekalkan jenis tepatnya.

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

Jenis tupel variadik sangat berguna apabila menggabungkan tupel. Menyebarkan dua tupel generik dalam jenis hasil menghasilkan gabungannya.

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 Jenis Hasil Tepat

Oleh sebab [...A, ...B] menyebarkan tupel generik, hasilnya mengekalkan jenis dan susunan setiap elemen — bukan sekadar tatasusunan kesatuan yang diperluas.

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)

Menambah Hujah di Hadapan

Tupel variadik membolehkan anda mengubah bentuk senarai parameter — contohnya, fungsi yang menambahkan hujah awal pada tandatangan 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 Jenis Kepala

Dengan parameter tupel, anda boleh mengasingkan jenis elemen pertama dan bahagian baki menggunakan tupel berlabel, kemudian mengendalikan setiap bahagian.

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

Jenis Utiliti Parameters

Jenis terbina dalam Parameters<F> mengekstrak senarai hujah fungsi sebagai tupel — yang dibina sendiri berasaskan jenis tupel variadik. Anda boleh menggunakan semula parameter sesuatu tandatangan 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 sebaran baki untuk membina pembungkus yang meneruskan hujah kepada fungsi sedia ada dengan penaipan yang sama.

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))

Membina Tandatangan Gaya Curry

Tupel variadik membolehkan pembantu penggunaan separa: tangkap sesetengah hujah sekarang, kemudian jangkakan bahagian baki, semuanya disemak jenisnya.

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

Kelebihan dan Berwaspada

Generik tupel variadik memberikan alat yang tepat dan boleh digunakan semula untuk membentuk fungsi — pembungkus, penerus, dan penggabung. Alat ini bersifat lanjutan, jadi gunakannya apabila ketepatan jenis benar-benar berbaloi.

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

Semakan Pantas

Uji pemahaman anda tentang generik tupel variadik.

Jawab dalam pelajaran interaktif

Imbas Kembali

Jenis tupel variadik membolehkan generik menangkap senarai hujah sebagai tupel dan menyebarkannya pada kedudukan parameter atau hasil. Ini menyokong penggabungan tupel ([...A, ...B]), penerusan hujah, pengasingan kepala dan ekor, serta penggunaan separa — semuanya sambil mengekalkan jenis tepat setiap elemen. Ciri terbina dalam seperti Parameters<F> bergantung pada mekanisme yang sama. Gunakan alat ini apabila penaipan bentuk fungsi yang tepat berbaloi dengan kerumitannya.

Percuma untuk bermula

Pelajari TypeScript dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 101
Pelajaran: 352

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Mentaip Fungsi Variadik” percuma?

Ya — teks penuh “Mentaip Fungsi Variadik” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus TypeScript Academy, tingkat taraf kepada CoddyKit PRO. Kursus TypeScript Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Mentaip Fungsi Variadik”?

Bina API fleksibel dengan jenis tuple variadik. Anda berlatih TypeScript Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan TypeScript Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran TypeScript Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 4 daripada 4.

Berapa lamakah pelajaran “Mentaip Fungsi Variadik” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran TypeScript Academy ini?

Ya. Setiap pelajaran TypeScript Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke TypeScript Academy