Параметры, аргументы и значения по умолчанию

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

function greet(name, greeting) {
  return `${greeting}, ${name}!`;
}

console.log(greet("Аня", "Привет"));

Связь между ними — позиционная. Первый аргумент попадает в первый параметр, второй — во второй, и никакие имена переменных снаружи на это не влияют. Поэтому перепутанный порядок — не ошибка синтаксиса, а тихо неверный ответ.

function divide(a, b) {
  return a / b;
}

console.log(divide(10, 2));
console.log(divide(2, 10));

Параметр — имя в объявлении, аргумент — то, что реально приехало при вызове. В разговоре их путают все, но на собеседовании спрашивают.

Если аргумент могут не передать, задайте параметру запасное значение прямо в объявлении: параметр = значение. Оно подставится только тогда, когда аргумента нет.

function pow(base, exponent = 2) {
  return base ** exponent;
}

console.log(pow(5));
console.log(pow(2, 10));

Умолчание — это выражение, которое вычисляется при каждом вызове. Значит, в нём можно ссылаться на параметры, объявленные левее, и даже вызывать функции. Справа налево не работает: параметр, до которого очередь ещё не дошла, недоступен.

function rectArea(width, height = width) {
  return width * height;
}

console.log(rectArea(3));
console.log(rectArea(3, 4));

function hi(name = "гость") {
  return "Привет, " + name;
}

console.log(hi());
console.log(hi(undefined));
console.log(hi(null));

JavaScript не сверяет количество аргументов с количеством параметров. Передали больше — лишнее просто некуда положить, и оно отбрасывается. Передали меньше — оставшиеся параметры получат undefined. Ошибки не будет ни в том, ни в другом случае, будет странный результат. А сколько параметров объявлено, знает сама функция: sum.length.

function sum(a, b) {
  return a + b;
}

console.log(sum(1, 2, 3));
console.log(sum(1));
console.log(sum.length);

function total(...numbers) {
  let acc = 0;
  for (const n of numbers) acc += n;
  return acc;
}

console.log(total(1, 2, 3, 4));
console.log(total());

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

function birthday(age) {
  age = age + 1;
  return age;
}

let years = 20;
console.log(birthday(years));
console.log(years);

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

С объектами и массивами копируется не содержимое, а ссылка — адрес одного и того же объекта в памяти. Параметр и внешняя переменная указывают в одну точку, поэтому изменение поля внутри функции видно снаружи.

function birthday(user) {
  user.age = user.age + 1;
}

const anna = { name: "Аня", age: 20 };
birthday(anna);
console.log(anna.age);

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

function reset(user) {
  user = { name: "Никто", age: 0 };
}

const anna = { name: "Аня", age: 20 };
reset(anna);
console.log(anna.name);

Когда параметров становится больше трёх, вызов вида createUser("Аня", true, false, 5) невозможно прочитать. Приём: принимать один объект и сразу разбирать его в скобках функции — умолчания при этом работают как обычно, а порядок перестаёт иметь значение.

function createUser({ name, role = "user", active = true }) {
  return `${name} / ${role} / ${active}`;
}

console.log(createUser({ name: "Аня" }));
console.log(createUser({ name: "Ян", role: "admin" }));

Одна тонкость: вызов createUser() вообще без аргумента упадёт — разбирать нечего. Лечится умолчанием для всего объекта: function createUser({ name, role = "user" } = {}). Разбор самого узора — в статье «Деструктуризация»: там же и про вложенные структуры, и про новое имя переменной.