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

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

🔤 Параметры vs аргументы: в чём разница?

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

//         параметры (при объявлении)
//              ↓     ↓
function greet(name, age) {
  console.log("Привет, " + name + "! Тебе " + age + " лет.");
}
//               ↑       ↑
//        аргументы (при вызове)
greet("Иван", 25);

// Что происходит:
// name = "Иван"  (первый аргумент → первый параметр)
// age = 25       (второй аргумент → второй параметр)

🤷 Что если аргументов меньше, чем параметров?

JavaScript не выбрасывает ошибку, если вы передали меньше аргументов, чем объявлено параметров. Вместо этого «незаполненные» параметры получают значение undefined.

function introduce(name, city, hobby) {
  console.log("Меня зовут " + name);
  console.log("Я из " + city);
  console.log("Моё хобби: " + hobby);
}

introduce("Иван", "Москва", "программирование");
// Меня зовут Иван
// Я из Москвы
// Моё хобби: программирование

introduce("Мария", "Питер");
// Меня зовут Мария
// Я из Питера
// Моё хобби: undefined  ← hobby не получил значение!

introduce("Алекс");
// Меня зовут Алекс
// Я из undefined  ← city не получил значение
// Моё хобби: undefined  ← hobby не получил значение

А что если аргументов больше, чем параметров? JavaScript просто проигнорирует лишние — ошибки не будет, но значения пропадут. (В следующем уроке покажем как их «поймать» через rest-параметры.)

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

add(1, 2, 3, 4); // Вернёт 3. Числа 3 и 4 — проигнорированы.
add(5, 10);      // Вернёт 15.

До ES6 разработчики писали проверки вручную:

// Старый способ защиты от undefined (до ES6)
function greet(name) {
  if (name === undefined) {
    name = "друг"; // подставляем запасное значение
  }
  console.log("Привет, " + name + "!");
}

// Или короче через оператор ||:
function greet(name) {
  name = name || "друг"; // если name — falsy, используем "друг"
  console.log("Привет, " + name + "!");
}

Работает, но выглядит громоздко. ES6 решил эту проблему красиво.

⭐ Значения по умолчанию (ES6)

ES6 (версия JavaScript 2015 года) добавил значения по умолчанию прямо в синтаксис параметров. Теперь не нужны никакие проверки внутри функции — всё указывается прямо при объявлении.

// Синтаксис: параметр = значение_по_умолчанию
function greet(name = "друг") {
  console.log("Привет, " + name + "!");
}

greet("Иван");   // Привет, Иван!   — используется переданный аргумент
greet();          // Привет, друг!   — аргумент не передан, используется дефолт
greet(undefined); // Привет, друг!   — undefined тоже запускает дефолт

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

function createPost(title, author = "Аноним", views = 0, published = false) {
  return {
    title: title,
    author: author,
    views: views,
    published: published
  };
}

// Только заголовок — всё остальное по умолчанию
let post1 = createPost("Мой первый пост");
console.log(post1);
// { title: "Мой первый пост", author: "Аноним", views: 0, published: false }

// Заголовок и автор — остальное по умолчанию
let post2 = createPost("Гайд по JS", "Иван");
console.log(post2);
// { title: "Гайд по JS", author: "Иван", views: 0, published: false }

// Всё явно
let post3 = createPost("Топ 10 ошибок", "Мария", 1500, true);
console.log(post3);
// { title: "Топ 10 ошибок", author: "Мария", views: 1500, published: true }

function show(value = "дефолт") {
  console.log(value);
}

show();          // "дефолт"    — аргумента нет
show(undefined); // "дефолт"    — undefined запускает дефолт
show(null);      // null        — дефолт НЕ сработал
show(0);         // 0           — дефолт НЕ сработал
show("");        // ""          — дефолт НЕ сработал
show(false);     // false       — дефолт НЕ сработал

📏 Порядок имеет значение: дефолты — в конец!

Параметры со значениями по умолчанию должны стоять в конце списка параметров. Это логично: аргументы передаются по порядку — слева направо. Если параметр с дефолтом стоит в середине, JavaScript не сможет понять, для кого предназначен следующий аргумент.

// ❌ ПЛОХО: параметр с дефолтом стоит до параметра без дефолта
function createUser(name = "Аноним", age) {
  return name + ", " + age + " лет";
}

createUser("Иван", 25); // "Иван, 25 лет" — OK
createUser(25);          // "25, undefined лет" — не то, что ожидали!
// JavaScript думает, что 25 — это name, а age не получил значения

// ✅ ХОРОШО: параметры с дефолтами — в конце
function createUser(age, name = "Аноним") {
  return name + ", " + age + " лет";
}

createUser(25);          // "Аноним, 25 лет" — работает правильно!
createUser(30, "Иван");  // "Иван, 30 лет" — тоже работает

🛠️ Практические примеры

Давайте закрепим знания на реальных примерах.

function greet(name, greeting = "Привет") {
  return greeting + ", " + name + "!";
}

console.log(greet("Иван"));              // "Привет, Иван!"
console.log(greet("Мария", "Здравствуй")); // "Здравствуй, Мария!"
console.log(greet("Алекс", "Yo"));       // "Yo, Алекс!"

function calculate(a, b, operation = "add") {
  if (operation === "add") return a + b;
  if (operation === "subtract") return a - b;
  if (operation === "multiply") return a * b;
  if (operation === "divide") {
    if (b === 0) return "Ошибка: деление на ноль";
    return a / b;
  }
  return "Неизвестная операция";
}

console.log(calculate(10, 5));             // 15 (сложение по умолчанию)
console.log(calculate(10, 5, "subtract")); // 5
console.log(calculate(10, 5, "multiply")); // 50
console.log(calculate(10, 5, "divide"));   // 2

function formatCurrency(amount, currency = "₽", decimals = 2) {
  return amount.toFixed(decimals) + " " + currency;
}

console.log(formatCurrency(1499.9));          // "1499.90 ₽"
console.log(formatCurrency(99.99, "$"));      // "99.99 $"
console.log(formatCurrency(1000, "€", 0));    // "1000 €"

✅ Итоги урока

• Параметры — переменные в объявлении функции (пустые «слоты»)
• Аргументы — конкретные значения при вызове функции
• Если аргументов меньше, чем параметров — «лишние» параметры получают undefined
• undefined в вычислениях даёт NaN — коварная ошибка
• ES6: function f(param = defaultValue) — значение по умолчанию срабатывает при отсутствии аргумента или при передаче undefined
• Параметры с дефолтами всегда ставь в конец списка параметров
• Значение по умолчанию не срабатывает при передаче null, 0, "" или false