Swift Academy · Урок

Ленивые map и filter

Объединяйте ленивые преобразования без промежуточных массивов.

Урок 2 из 413 шагов

«Ленивые map и filter» — бесплатный урок Swift Academy на CoddyKit. Это урок 2 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения Swift Academy, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс Swift Academy содержит 4 уроков всего.

Промежуточные массивы

Жадные цепочки выделяют новый массив между каждым шагом. Цепочка filter().map() для большого массива создаёт два полных массива, хотя Вам может понадобиться всего несколько элементов.

Выделение памяти жадным способом

Здесь создаются два промежуточных массива:

let nums = Array(1...6)
let result = nums
    .filter { $0 % 2 == 0 }  // builds [2, 4, 6]
    .map { $0 * 10 }         // builds [20, 40, 60]
print(result)  // [20, 40, 60]

Объединение шагов с помощью ленивого режима

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

Ленивая цепочка

Та же логика, но без промежуточных массивов:

let nums = Array(1...6)
let result = nums.lazy
    .filter { $0 % 2 == 0 }
    .map { $0 * 10 }
print(Array(result))  // [20, 40, 60]

Поток обработки по одному элементу

Трассировка показывает чередующееся выполнение, а не обработку по этапам:

let out = [1, 2, 3].lazy
    .filter { n -> Bool in print("filter \(n)"); return n > 1 }
    .map   { n -> Int  in print("map \(n)");    return n }
print(Array(out))  // filter 1, filter 2, map 2, filter 3, map 3 -> [2, 3]

Досрочное завершение экономит работу

Объедините ленивую цепочку с first(where:), чтобы остановиться при первой возможности:

let nums = Array(1...1_000_000)
let hit = nums.lazy.map { $0 + 1 }.first { $0 > 5 }
print(hit!)  // 6  -- only a handful of elements processed

Ленивый режим с prefix

Получим только первые несколько результатов затратного преобразования:

let squares = (1...).lazy.map { $0 * $0 }
print(Array(squares.prefix(5)))  // [1, 4, 9, 16, 25]

Подсчёт пропущенной работы

Счётчик показывает, как мало элементов действительно обрабатывается:

var transforms = 0
let result = Array(1...100).lazy
    .map { (n: Int) -> Int in transforms += 1; return n * 2 }
    .prefix(3)
_ = Array(result)
print(transforms)  // 3, not 100

Ленивый режим с compactMap

У compactMap тоже есть ленивый вариант:

let raw = ["1", "x", "3", "y", "5"]
let first = raw.lazy.compactMap { Int($0) }.first
print(first!)  // 1

Сочетание множества шагов

Длинные объединённые конвейеры не требуют выделения памяти до материализации:

let r = Array(1...20).lazy
    .filter { $0 % 2 == 0 }
    .map { $0 * $0 }
    .filter { $0 > 50 }
print(Array(r))  // [64, 100, 144, 196, 256, 324, 400]

Когда объединение особенно полезно

Ленивое объединение эффективно, когда исходные данные велики, а Вы сохраняете только часть результата. Если Вы всё равно полностью преобразуете результат в массив, выигрыш уменьшается, и жадный вариант может читаться проще.

let big = Array(1...10_000)
let sample = Array(big.lazy.filter { $0 % 1000 == 0 })
print(sample)  // [1000, 2000, ... 10000]

Быстрая проверка

Чего избегает ленивая цепочка filter().map(), что создаёт жадная цепочка?

Ответь в интерактивном уроке

Повторение

Вы изучили ленивые цепочки:

Жадные цепочки выделяют массив между каждым шагом
.lazy объединяет шаги — обработка выполняется по одному элементу, без промежуточных массивов
Идеально сочетается с first(where:) и prefix для досрочного завершения
Наибольшая польза заметна при больших исходных данных и частичном использовании результата

Далее: компромиссы между ленивыми и жадными вычислениями.

Можно начать бесплатно

Изучай Swift с ИИ-репетитором — бесплатно

Пиши и запускай код прямо в браузере, получай мгновенную помощь от ИИ-репетитора 24/7 и продолжи учиться на сайте или в приложении.

Курсы: 122
Уроки: 409

Начать учиться бесплатно Посмотреть полный курс

Часто задаваемые вопросы

Урок «Ленивые map и filter» бесплатный?

Да — полный текст урока «Ленивые map и filter» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс Swift Academy, подпишись на CoddyKit PRO. Курс Swift Academy содержит 4 уроков всего.

Чему я научусь в уроке «Ленивые map и filter»?

Объединяйте ленивые преобразования без промежуточных массивов. Ты практикуешь Swift Academy с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать Swift Academy?

Предыдущий опыт не требуется. Swift Academy на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 2 из 4.

Сколько времени занимает урок «Ленивые map и filter»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке Swift Academy?

Да. Каждый урок Swift Academy включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

← Назад к Swift Academy