Что делает map?

Что делает метод map в Swift?

Метод map — это функция высшего порядка (higher-order function), которая преобразует элементы коллекции, применяя к каждому элементу указанное замыкание, и возвращает новую коллекцию с результатами этих преобразований.

Основные характеристики map

1. Не изменяет исходную коллекцию — создаёт новую
2. Сохраняет структуру коллекции — если применили к массиву, получите массив
3. Тип результата может отличаться от типа исходных элементов
4. Выполняет синхронное преобразование каждого элемента

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

// Самый простой пример с массивом чисел
let numbers = [1, 2, 3, 4, 5]

// Умножаем каждый элемент на 2
let doubled = numbers.map { $0 * 2 }
print(doubled) // [2, 4, 6, 8, 10]

// Более подробная запись с явным указанием параметра
let squared = numbers.map { number in
    return number * number
}
print(squared) // [1, 4, 9, 16, 25]

Различия между map, compactMap и flatMap

map — базовое преобразование

let strings = ["1", "2", "three", "4"]
let mapped = strings.map { Int($0) }
print(mapped) // [Optional(1), Optional(2), nil, Optional(4)]
// Результат содержит nil-значения

compactMap — преобразование с фильтрацией nil

let compacted = strings.compactMap { Int($0) }
print(compacted) // [1, 2, 4]
// nil-значения отфильтрованы, результат — неопциональный массив

flatMap — "разворачивание" вложенных коллекций

let nestedArray = [[1, 2, 3], [4, 5], [6]]
let flattened = nestedArray.flatMap { $0 }
print(flattened) // [1, 2, 3, 4, 5, 6]
// Преобразует массив массивов в плоский массив

Расширенное использование map

Преобразование типов

struct User {
    let name: String
    let age: Int
}

let users = [
    User(name: "Анна", age: 25),
    User(name: "Иван", age: 30),
    User(name: "Мария", age: 28)
]

// Извлекаем только имена
let names = users.map { $0.name }
print(names) // ["Анна", "Иван", "Мария"]

// Преобразуем в другой тип
let descriptions = users.map { "\($0.name), \($0.age) лет" }
print(descriptions) // ["Анна, 25 лет", "Иван, 30 лет", "Мария, 28 лет"]

Работа с опциональными значениями

let optionalArray: [Int?] = [1, nil, 3, nil, 5]

// map работает и с опциональными значениями внутри массива
let incremented = optionalArray.map { $0.map { $0 + 1 } }
print(incremented) // [Optional(2), nil, Optional(4), nil, Optional(6)]

Словари и другие коллекции

let dictionary = ["a": 1, "b": 2, "c": 3]

// map для словаря возвращает массив
let keys = dictionary.map { $0.key }
print(keys) // ["b", "a", "c"] (порядок может быть произвольным)

// Если нужно сохранить структуру словаря
let mappedDict = dictionary.mapValues { $0 * 10 }
print(mappedDict) // ["b": 20, "a": 10, "c": 30]

Производительность и внутренняя реализация

Метод map лениво не вычисляется (в отличие от lazy.map), то есть преобразование выполняется сразу для всех элементов. Его временная сложность — O(n), где n — количество элементов в коллекции.

// Эффективное использование с большими коллекциями
let largeArray = Array(1...1_000_000)

// Стандартный map — создаёт промежуточный массив
let standardMap = largeArray.map { $0 * 2 }

// Lazy map — откладывает вычисления до момента фактического использования
let lazyMap = largeArray.lazy.map { $0 * 2 }
// Вычисления происходят только при итерации
for value in lazyMap.prefix(5) {
    print(value)
}

Практические рекомендации

1. Используйте map для чистых преобразований без побочных эффектов
2. Комбинируйте с другими методами функционального программирования:

let result = numbers
    .filter { $0 % 2 == 0 }     // только чётные
    .map { $0 * 3 }             // умножаем на 3
    .sorted()                   // сортируем

1. Избегайте вложенных map для многомерных структур — используйте flatMap
2. Для опциональных значений внутри коллекции предпочитайте compactMap

Ключевые преимущества map

• Выразительность — код становится чище и понятнее
• Безопасность — отсутствие мутаций и побочных эффектов
• Композируемость — легко комбинируется с другими методами
• Читаемость — явно показывает намерение преобразования данных

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