Краткий ответ

Dictionary(grouping:by:) не перезаписывает элементы с одинаковым ключом: каждому ключу соответствует массив всех связанных с ним элементов. Элементы внутри каждого массива сохраняют порядок, в котором они встретились в исходной последовательности. Порядок обхода самих ключей словаря при этом не гарантируется.

Исторический контекст

Обычный словарь естественно представляет связь «один ключ — одно значение», но при обработке коллекций часто требуется связь «один ключ — много элементов»: например, сгруппировать события по пользователю или товары по категории.

Dictionary(grouping:by:) решает эту задачу готовой операцией: он скрывает ручное создание массива для нового ключа и добавление элементов в уже существующую группу. Это уменьшает риск случайно потерять данные при повторяющихся ключах.

Постановка проблемы

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

Нужно также различать порядок элементов внутри группы и порядок ключей словаря. Первый сохраняется относительно исходной последовательности, а на порядок ключей Dictionary нельзя опираться при формировании отчёта или пользовательского интерфейса.

Подробное решение

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

struct Event {
    let user: String
    let name: String
}

let events = [
    Event(user: "Аня", name: "вход"),
    Event(user: "Борис", name: "оплата"),
    Event(user: "Аня", name: "выход")
]

let byUser = Dictionary(grouping: events, by: \.user)
print(byUser["Аня"]!.map(\.name)) // ["вход", "выход"]

Ключ должен соответствовать требованиям ключа Dictionary, то есть быть Hashable. Средняя вычислительная стоимость группировки обычно составляет O(n) операций хеширования, а память включает словарь и массивы групп; фактическая стоимость зависит от реализации хеширования и распределения ключей.

Это отличается от Dictionary(uniqueKeysWithValues:), где повторяющиеся ключи считаются ошибкой, и от инициализации с обработчиком коллизий, где для каждого конфликта нужно явно выбрать одно из значений. При группировке результатом коллизии является не выбор одного элемента, а добавление элемента в массив.

Ситуация из практики

Сервис получает поток событий аудита и должен показать историю отдельно для каждого пользователя. Вариант с обычной записью в словарь проще на первый взгляд, но при повторном пользователе он перезаписывает предыдущую историю. Вариант с reduce(into:) даёт полный контроль, однако требует вручную создавать группу и добавлять элементы, поэтому увеличивает объём кода и вероятность ошибки.

Выбор Dictionary(grouping:by:) оптимален, когда нужна стандартная группировка без специальной логики слияния: он явно выражает намерение, сохраняет все события в порядке поступления внутри группы и не требует отдельной обработки первого элемента. Если же нужно ограничить размер группы, агрегировать значения или отбрасывать элементы по сложному правилу, тогда оправдан ручной reduce(into:).

Что кандидаты часто упускают

Сохраняется ли порядок элементов внутри массива группы?

Да. Элементы каждой группы находятся в том же относительном порядке, в каком они были в исходной последовательности. Поэтому при последовательной обработке массива группы можно рассчитывать на порядок входных данных.

Это не означает, что словарь вернёт ключи в порядке их первого появления. Для стабильного порядка групп ключи нужно получить отдельно и явно отсортировать.

Что произойдёт, если функция формирования ключа выдаёт одинаковый ключ для всех элементов?

В словаре будет одна запись, а её значением станет массив всех элементов исходной последовательности. Ни один элемент не будет потерян, но размер единственной группы может стать большим и повлечь значительное потребление памяти.

Такой результат корректен, если ключ действительно описывает одну группу. Если функция случайно возвращает слишком обобщённый ключ, ошибка будет логической, а не исключением времени выполнения.

Когда Dictionary(grouping:by:) хуже ручного накопления через reduce(into:)?

Он менее удобен, когда вместо полного массива элементов нужна агрегированная информация: количество, сумма, максимум или ограниченная выборка. В таких случаях reduce(into:) позволяет хранить только итоговое состояние и не создавать массив всех элементов группы.

Например, для подсчёта количества событий группировка создаст ненужные массивы, тогда как ручное накопление может хранить только целое число на каждый ключ. Компромисс состоит в читаемости: стандартная группировка проще и безопаснее для сценария «собрать все элементы», а ручной аккумулятор экономнее и гибче для агрегации.