Для чего используется метод Map?

Метод map() в JavaScript и его применение

Метод map() — один из самых используемых методов для трансформации данных в JavaScript. Он создает новый массив с результатами применения функции к каждому элементу исходного массива. Это фундаментальный инструмент функционального программирования.

Синтаксис и базовый пример

const array = [1, 2, 3, 4, 5];
const doubled = array.map((num) => num * 2);
console.log(doubled);  // [2, 4, 6, 8, 10]

Метод получает callback функцию с параметрами:

array.map((element, index, array) => {
  // element — текущий элемент
  // index — индекс элемента
  // array — исходный массив
});

Основные применения

1. Преобразование объектов

const users = [
  { id: 1, name: 'Иван', age: 25 },
  { id: 2, name: 'Мария', age: 30 },
  { id: 3, name: 'Петр', age: 28 },
];

// Получить только имена
const names = users.map((user) => user.name);
console.log(names);  // ['Иван', 'Мария', 'Петр']

// Получить только ID
const ids = users.map((user) => user.id);
console.log(ids);  // [1, 2, 3]

2. Преобразование типов данных

const numbers = ['1', '2', '3', '4'];

// Строки в числа
const parsed = numbers.map(Number);
console.log(parsed);  // [1, 2, 3, 4]

// Числа в строки
const stringified = [1, 2, 3].map(String);
console.log(stringified);  // ['1', '2', '3']

// Строки в JSON
const jsons = ['[1,2]', '{"x":5}'].map(JSON.parse);
console.log(jsons);  // [[1, 2], { x: 5 }]

3. Работа с индексом

const items = ['яблоко', 'банан', 'апельсин'];

const indexed = items.map((item, index) => `${index + 1}. ${item}`);
console.log(indexed);
// ['1. яблоко', '2. банан', '3. апельсин']

4. API запросы и обработка данных

const fetchUserData = async (userIds) => {
  // Получить данные для каждого ID
  const promises = userIds.map((id) => 
    fetch(`/api/v1/users/${id}`).then((r) => r.json())
  );
  
  const users = await Promise.all(promises);
  return users;
};

// Или преобразовать полученные данные
const users = await fetchUserData([1, 2, 3]);
const userNames = users.map((user) => user.name);

5. Создание новых структур данных

const users = [
  { id: 1, name: 'Иван' },
  { id: 2, name: 'Мария' },
];

// Преобразовать в объект
const userMap = users.reduce((acc, user) => {
  acc[user.id] = user.name;
  return acc;
}, {});
// { 1: 'Иван', 2: 'Мария' }

// Или с map
const userObjects = users.map((user) => ({
  userId: user.id,
  fullName: user.name.toUpperCase(),
  email: `${user.name.toLowerCase()}@example.com`,
}));

map() в Node.js backend

Обработка результатов БД:

const users = await User.find();  // [{ _id, name, email, password, ... }]

// Скрыть чувствительные данные
const safeUsers = users.map((user) => ({
  id: user._id,
  name: user.name,
  email: user.email,
  // password НЕ попадает в ответ
}));

res.json(safeUsers);

Преобразование данных для базы:

const csvData = [
  { name: 'Иван', age: '25' },
  { name: 'Мария', age: '30' },
];

// Привести к типам перед сохранением
const prepared = csvData.map((row) => ({
  name: row.name.trim(),
  age: parseInt(row.age, 10),
  createdAt: new Date(),
}));

await User.insertMany(prepared);

map() vs forEach() vs for

// map() — СОЗДАЕТ новый массив, функциональный подход
const doubled = [1, 2, 3].map((x) => x * 2);  // [2, 4, 6]

// forEach() — НЕ создает новый массив, для побочных эффектов
[1, 2, 3].forEach((x) => console.log(x * 2));  // вывод: 2, 4, 6

// for — самый быстрый для простых операций
const doubled = [];
for (let x of [1, 2, 3]) {
  doubled.push(x * 2);
}

Важное замечание: map() не изменяет исходный массив

const original = [1, 2, 3];
const mapped = original.map((x) => x * 2);

console.log(original);  // [1, 2, 3] — не изменился!
console.log(mapped);    // [2, 4, 6]

Производительность

// map() создает новый массив и проходит один раз
const result = array
  .map((x) => x * 2)        // O(n)
  .filter((x) => x > 5)     // O(n)
  .reduce((a, b) => a + b); // O(n)
// Итого: O(3n) = O(n)

// Чейнинг methods — нормально для читаемости
// Оптимизируй только если профилировка показала проблему

Best Practices

// ✅ Используй map для трансформации
const prices = products.map((p) => p.price);

// ✅ Используй для создания новых структур
const dto = users.map((u) => ({ id: u._id, name: u.name }));

// ❌ Не используй map если не нужен результат
// Плохо:
array.map((x) => console.log(x));
// Хорошо:
array.forEach((x) => console.log(x));

// ❌ Не меняй исходный array внутри map
// Плохо:
array.map((x) => { x.value *= 2; return x; });
// Хорошо:
array.map((x) => ({ ...x, value: x.value * 2 }));

Метод map() — это сердце функционального программирования в JavaScript и обязателен для написания чистого и эффективного кода на Node.js.