0Pricing
TypeScript Academy · Урок

Типизация функций с переменным числом аргументов

Создавайте гибкие API с помощью типов кортежей с переменным числом элементов

«Типизация функций с переменным числом аргументов» — бесплатный урок TypeScript Academy на CoddyKit. Это урок 4 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения TypeScript Academy, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс TypeScript Academy содержит 4 уроков всего.

Обобщённые вариадические функции

Вариадические типы кортежей позволяют обобщённым типам захватывать и обрабатывать списки аргументов. Благодаря этому можно создавать вспомогательные средства, которые объединяют кортежи, передают параметры дальше и изменяют сигнатуры вызовов с полной проверкой типов.

Сохранение аргументов в виде кортежа

Обобщённый тип с ограничением unknown[] может сохранить весь список аргументов как тип кортежа T, сохраняя тип и позицию каждого параметра.

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

Применение расширения к обобщённому кортежу

Вы можете применить оператор расширения к сохранённому обобщённому кортежу в другом списке параметров. Это позволяет передавать аргументы дальше, сохраняя их точные типы.

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

Объединение двух кортежей

Вариадические типы кортежей особенно полезны при объединении кортежей. Расширение двух обобщённых кортежей в возвращаемом типе даёт их объединение.

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)

Почему тип результата точен

Поскольку [...A, ...B] расширяет обобщённые кортежи, результат сохраняет тип и порядок каждого элемента, а не превращается просто в массив с расширенным объединённым типом.

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)

Добавление аргумента в начало

Вариадические кортежи позволяют изменять списки параметров — например, добавлять начальный аргумент в сигнатуру функции обратного вызова.

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

Извлечение типа первого элемента

Для параметра-кортежа можно отделить тип первого элемента от остальных с помощью именованного кортежа, а затем работать с каждой частью отдельно.

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

Вспомогательный тип Parameters

Встроенный тип Parameters<F> извлекает список аргументов функции в виде кортежа — этот тип сам построен на основе вариадических типов кортежей. Вы можете повторно использовать параметры сигнатуры в другом месте.

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

Передача параметров с помощью Parameters

Объедините Parameters с остаточным расширением, чтобы создать оболочку, которая передаёт аргументы существующей функции с идентичной типизацией.

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

Создание сигнатуры, подобной каррированию

Вариадические кортежи позволяют создавать вспомогательные средства для частичного применения: одни аргументы передаются сейчас, а остальные ожидаются позже, и всё проверяется по типам.

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

Возможности и осторожность

Обобщённые вариадические кортежи дают точные и пригодные для повторного использования инструменты изменения формы функций — оболочки, средства передачи параметров и объединители. Это продвинутая возможность, поэтому используйте её, когда точность типов действительно оправдывает сложность.

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

Быстрая проверка

Проверьте, насколько хорошо Вы понимаете обобщённые вариадические кортежи.

Повторение

Вариадические типы кортежей позволяют обобщённым типам сохранять списки аргументов в виде кортежей и расширять их в позициях параметров или возвращаемого значения. Это обеспечивает объединение кортежей ([...A, ...B]), передачу аргументов, разделение на первый и оставшиеся элементы, а также частичное применение — с сохранением точных типов всех элементов. Встроенные типы, такие как Parameters<F>, используют тот же механизм. Применяйте эти инструменты, когда точная типизация формы функции оправдывает дополнительную сложность.

Часто задаваемые вопросы

Урок «Типизация функций с переменным числом аргументов» бесплатный?

Да — полный текст урока «Типизация функций с переменным числом аргументов» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс TypeScript Academy, подпишись на CoddyKit PRO. Курс TypeScript Academy содержит 4 уроков всего.

Чему я научусь в уроке «Типизация функций с переменным числом аргументов»?

Создавайте гибкие API с помощью типов кортежей с переменным числом элементов Ты практикуешь TypeScript Academy с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать TypeScript Academy?

Предыдущий опыт не требуется. TypeScript Academy на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 4 из 4.

Сколько времени занимает урок «Типизация функций с переменным числом аргументов»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке TypeScript Academy?

Да. Каждый урок TypeScript Academy включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

  1. Остаточные параметры функций
  2. Оператор spread в массивах и объектах
  3. Остаточные элементы кортежей
  4. Типизация функций с переменным числом аргументов
← Назад к TypeScript Academy