Необязательные параметры, значения по умолчанию и rest

В части I пропуск аргумента был обычным делом: функция получала undefined и как-то с этим жила. Компилятор смотрит иначе — он считает аргументы и не разрешает вызвать функцию не так, как она объявлена.

function greet(name: string, title: string): string {
  return title + " " + name;
}
console.log(greet("Рико"));

«Ожидалось аргументов: 2, получено: 1» — это TS2554. Обратите внимание, что исполнение всё равно состоялось и напечатало undefined Рико: диагностика ничего не останавливает. Из чистого JavaScript ровно такая строка и уехала бы в прод.

Если пропуск задуман, о нём нужно предупредить — знаком вопроса после имени параметра.

function greet(name: string, title?: string): string {
  return title.toUpperCase() + " " + name;
}
console.log(greet("Рико", "инженер"));
console.log(greet("Рико"));

Счёт аргументов сошёлся, зато появилась диагностика внутри функции: TS18048, «Возможно, title имеет значение undefined». Дальше классический сюжет: предупреждение проигнорировали, первый вызов отработал, второй упал с TypeError — у undefined нет метода toUpperCase. Компилятор показал ровно ту строку, на которой программа и сломалась.

Знак вопроса не делает параметр волшебным, он добавляет к типу undefined. Внутри функции title — это string | undefined, то есть обычное объединение, которое сначала сужают.

function greet(name: string, title?: string): string {
  if (title === undefined) {
    return "Привет, " + name;
  }
  return "Привет, " + title + " " + name;
}
console.log(greet("Рико", "инженер"));
console.log(greet("Рико"));
// врём с типом намеренно: диагностика покажет сигнатуру целиком
const probe: null = greet;

Приём с заведомо неподходящим типом знаком по статье про сужение, но здесь он показывает не одну переменную, а всю сигнатуру: (name: string, title?: string | undefined) => string. Знак вопроса и | undefined стоят рядом не случайно — это две стороны одной записи. Снаружи аргумент можно не передавать, внутри его придётся проверить.

Знак вопроса ставится только в объявлении. На месте вызова не меняется ничего — вы просто не пишете аргумент.

function greet(name: string, title?: string): string {
  return title === undefined ? name : title + " " + name;
}
console.log(greet("Рико", "инженер", "срочно"));

Проверять undefined в начале каждой функции надоедает. Обычно нужно другое: не передали — подставь разумное. Синтаксис тот же, что в части I, но в типах у него появляется приятный побочный эффект.

function greet(name: string, title = "гость"): string {
  return title.toUpperCase() + " " + name;
}
console.log(greet("Рико", "инженер"));
console.log(greet("Рико"));
console.log(greet("Рико", undefined));
// врём с типом намеренно: диагностика покажет сигнатуру целиком
const probe: null = greet;

Внутри функции — ни одной диагностики: toUpperCase вызван без всякой проверки, и это законно. Единственная претензия компилятора — намеренная ложь про тип в последней строке, и она же называет сигнатуру целиком: (name: string, title?: string) => string. Знак вопроса на месте, а | undefined исчез: снаружи параметр по-прежнему можно пропустить, но внутрь undefined не доберётся, его перехватит умолчание. Третий вызов показывает, что явный undefined считается за «не передали» — это одно из немногих мест, где undefined и null ведут себя по-разному не на словах.

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

function repeat(text: string, times = 2): string {
  return text.repeat(times);
}
console.log(repeat("ха"));
console.log(repeat("ха", "три"));

Второй вызов — тот случай, ради которого стоит читать диагностику до запуска. «Аргумент типа string нельзя назначить параметру типа number» — а на исполнении ни ошибки, ни падения: пустая строка. repeat честно превратил "три" в NaN, округлил до нуля и повторил текст ноль раз. Такую пропажу в интерфейсе ищут долго.

У вывода типа из умолчания есть обратная сторона: выводит он широко.

function slot(mode = "быстрый"): string {
  return "режим: " + mode;
}
console.log(slot());
console.log(slot("медленный"));
console.log(slot("бытсрый"));

Диагностик нет. Из "быстрый" компилятор вывел не литеральный тип, а string — как и для обычной let-переменной в статье про литеральные типы. Умолчание задаёт значение, а не список допустимых значений. Если вариантов должно быть ровно два, тип нужно назвать.

type Level = "info" | "warn";
function report(text: string, level: Level = "info"): string {
  return level + ": " + text;
}
console.log(report("привет"));
console.log(report("привет", "error"));

Аннотация и умолчание уживаются: level: Level = "info" читается как «тип вот такой, а если не передали — вот это». В тексте диагностики параметр назван Level | undefined: вариант «не передали» компилятор держит в уме и здесь, просто внутрь функции он не проходит.

И ещё одно свойство, общее с JavaScript: умолчание — это выражение. Оно вычисляется при каждом вызове и видит параметры, объявленные левее.

function tag(name: string, id = name.toLowerCase()): string {
  return name + "#" + id;
}
console.log(tag("Рико"));
console.log(tag("Рико", "42"));

Вопросительный знак и умолчание вместе не ставят: это TS1015, «Параметр не может содержать вопросительный знак и инициализатор». Умолчание и так делает параметр необязательным.

function pad(text: string, filler = null): string {
  return filler + text;
}
console.log(pad("Рико"));
console.log(pad("Рико", "*"));

Аргументы позиционные: второй аргумент попадает во второй параметр, и пропустить дырку посередине нельзя. Отсюда правило, которое компилятор проверяет отдельно от типов.

function order(title?: string, name: string): string {
  return title + " " + name;
}
console.log(order("инженер", "Рико"));

TS1016, «Обязательный параметр не должен следовать за необязательным», и заметьте — диагностика на первой строке, а не на вызове. Запрещено само объявление. Причина видна, если попробовать таким объявлением воспользоваться: раз title можно пропустить, вызов order("Рико") должен что-то значить. Но единственный аргумент по позиции попадёт в title, а обязательный name останется пустым. Правило снимает неоднозначность до того, как она появится.

Пропустить необязательный параметр в середине всё-таки можно — передав undefined явно. Это не обход правила, а его прямое следствие: позиция занята, значения нет.

function tag(text: string, cls?: string, id?: string): string {
  return [text, cls, id].join("|");
}
console.log(tag("привет", undefined, "main"));

А теперь то, что ломает интуицию: точно такое же по смыслу объявление, но со значением по умолчанию, компилятор принимает без единого слова.

function order(title = "гость", name: string): string {
  return title + " " + name;
}
console.log(order("инженер", "Рико"));
console.log(order(undefined, "Рико"));
console.log(order("Рико"));
const probe: null = order;

TS1016 не сработал — и это не поблажка. Сигнатура из последней строки объясняет всё: (title: string | undefined, name: string) => string, без всякого знака вопроса. Параметр с умолчанием, стоящий перед обязательным, перестаёт быть пропускаемым: аргумент передавать обязательно, просто разрешено передать undefined. Правило про порядок не нарушено, потому что необязательных параметров здесь попросту нет.

Третий вызов подтверждает это дважды. Компилятор требует два аргумента — «Ожидалось аргументов: 2, получено: 1». Исполнение печатает Рико undefined: строка «Рико» ушла в title, а name не досталось ничего. Вывод практический — значение по умолчанию ставьте в конец списка, иначе оно приносит не удобство, а обязанность писать undefined при каждом вызове.

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

Когда необязательных параметров становится больше двух, позиции перестают работать вовсе: вызов вида find("привет", undefined, undefined, true) прочитать невозможно. Тогда их собирают в один объект с необязательными полями — теми самыми, из статьи про типы объектов.

function search(text: string, options?: { limit?: number; deep?: boolean }): string {
  const limit = options?.limit ?? 10;
  return text + ":" + limit;
}
console.log(search("а"));
console.log(search("а", { limit: 3 }));
console.log(search("а", { limit: 3, exact: true }));

Порядок полей теперь не важен, на месте вызова видно имя каждого значения, а опечатку ловит проверка лишних свойств из статьи про структурную типизацию: «exact не существует в типе...». Цена — знак вопроса у самого options и ?. при чтении полей.

Обратная задача: аргументов может быть сколько угодно. Три точки перед именем параметра собирают весь хвост в массив — приём из части I, а типизируется он ровно как массив.

function sum(...nums: number[]): number {
  return nums.reduce((acc, n) => acc + n, 0);
}
console.log(sum(1, 2, 3));
console.log(sum());
console.log(sum(1, "2"));

Тип number[] описывает не один аргумент, а весь хвост: каждый аргумент должен быть числом, а сколько их — неважно, ноль тоже подходит. Третий вызов напечатал 12, и это не опечатка: reduce сложил ноль с единицей, получил 1, встретил строку — и сложение стало склейкой. То самое преобразование типов из части I, от которого диагностика и защищает.

Тип rest-параметра обязан быть массивом. Забытые квадратные скобки компилятор ловит отдельным кодом.

function sum(...nums: number) {
  return nums;
}
console.log(sum(1, 2));

«Параметр rest должен иметь тип массива» — TS2370. Вторая диагностика, на вызове, — эхо первой, и в ней виден любопытный след: список аргументов компилятор описал кортежем [number, number]. Именно так он его и представляет.

Rest-параметр всегда последний, и это правило не TypeScript, а самого языка.

function log(...parts: string[], level: string): string {
  return level + " " + parts.join(" ");
}
console.log(log("сервер", "упал", "инфо"));

Диагностик две: TS1014, «Параметр rest должен стоять на последнем месте в списке параметров», и следом обычная путаница со счётом аргументов. А исполнения не будет вообще — движок отказывается разбирать такой код целиком и бросает SyntaxError: Rest parameter must be last formal parameter. Редкий случай, когда компилятор и среда исполнения ругаются на одно и то же: три точки не в конце запрещены самим синтаксисом языка.

На стороне вызова три точки работают в обратную сторону — раскладывают массив в отдельные аргументы. В rest-параметр это проходит всегда, в обычные — не всегда.

function box(width: number, height: number): number {
  return width * height;
}
const sizes = [3, 4];
console.log(box(...sizes));
const fixed = [3, 4] as const;
console.log(box(...fixed));

«Аргумент расширения должен иметь тип кортежа либо передаваться в параметр rest» — TS2556. У sizes тип number[], массив неизвестной длины, и компилятор не может обещать, что там ровно два числа. У fixed благодаря as const тип readonly [3, 4]: длина известна, вызов разрешён. На исполнении оба варианта дали 12 — но только один из них будет давать его всегда.

function point(...coords: [x: number, y: number, label?: string]): string {
  return coords.join(":");
}
console.log(point(1, 2));
console.log(point(1, 2, "дом"));
console.log(point(1));

Раз ? добавляет к типу undefined, кажется, что title?: string и title: string | undefined — одно и то же. Внутри функции да. Снаружи нет.

function a(title?: string): string {
  return "a: " + title;
}
function b(title: string | undefined): string {
  return "b: " + title;
}
console.log(a());
console.log(b());
console.log(b(undefined));

«Ожидалось аргументов: 1, получено: 0» — и это единственная диагностика примера. Функция b обязана получить аргумент, просто этим аргументом разрешено быть undefined. Разница не в типе значения, а в праве промолчать: вызывающий код должен явно сказать «здесь ничего нет», и забыть об этом параметре у него не выйдет.

Правая колонка объясняет, почему значение по умолчанию так часто оказывается лучшим выбором: это единственная запись, после которой внутри функции не нужна ни одна проверка. Знак вопроса берут, когда «не передали» и правда означает особый случай, а не просто «подставь обычное».

function opt(a: string, b?: string): string {
  return a + b;
}
function def(a: string, b = "x"): string {
  return a + b;
}
function rest(a: string, ...r: string[]): string {
  return a + r.join("");
}
console.log(opt.length, def.length, rest.length);