Всегда ли Set гарантирует уникальность элементов?

Гарантирует ли Set уникальность элементов в Swift?

Короткий ответ: да, тип Set в Swift всегда гарантирует уникальность элементов на уровне коллекции, но с важными нюансами, касающимися семантики равенства и хеширования.

Как Set обеспечивает уникальность

Set — это неупорядоченная коллекция уникальных элементов, которая для обеспечения уникальности и быстрого доступа (O(1) в среднем) использует хеш-таблицу. При добавлении нового элемента происходит следующее:

1. Вычисляется хеш-значение элемента через метод hashValue
2. Проверяется равенство через метод ==
3. Если элемент с таким же хешем и равный уже существует, он не добавляется

var numbers: Set = [1, 2, 3, 2, 1]
print(numbers) // [2, 3, 1] - дубликаты удалены

Ключевые требования к элементам Set

Для корректной работы Set тип элемента должен соответствовать протоколу Hashable, который наследуется от Equatable:

struct Person: Hashable {
    let id: Int
    let name: String
    
    // Hashable требует определить:
    static func ==(lhs: Person, rhs: Person) -> Bool {
        return lhs.id == rhs.id // Уникальность по id
    }
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(id) // Хеширование по id
    }
}

var people: Set<Person> = [
    Person(id: 1, name: "Анна"),
    Person(id: 1, name: "Анна"), // Не добавится - одинаковый id
    Person(id: 2, name: "Анна")  // Добавится - другой id
]

Граничные случаи и важные нюансы

1. Изменяемые объекты в Set — потенциальная проблема:

class MutableUser: Hashable {
    var id: Int
    
    init(id: Int) { self.id = id }
    
    static func ==(lhs: MutableUser, rhs: MutableUser) -> Bool {
        return lhs.id == rhs.id
    }
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(id)
    }
}

var user = MutableUser(id: 1)
var userSet: Set = [user]
user.id = 2 // ОПАСНО: изменили хешируемое свойство!
// Теперь элемент может быть потерян при поиске

1. Разные хеш-коллизии — разные объекты с одинаковым хешем:

struct CollidingType: Hashable {
    let value: Int
    
    // Плохая хеш-функция - всегда возвращает 1
    func hash(into hasher: inout Hasher) {
        hasher.combine(1)
    }
}

var set: Set<CollidingType> = []
set.insert(CollidingType(value: 1))
set.insert(CollidingType(value: 2)) // Добавится, т.к. value отличается
// Хотя хеши одинаковы, равенство проверяется через ==

1. Типы с reference semantics — Set сравнивает ссылки:

class ReferenceType { /* не реализует Hashable */ }
let obj = ReferenceType()
let set = [obj, obj] // Ошибка: ReferenceType не соответствует Hashable

Рекомендации по использованию

• Для value-типов (структур, перечислений) Set работает предсказуемо
• Для reference-типов (классов) убедитесь, что:
  • Класс соответствует Hashable
  • Хешируемые свойства неизменяемы (let)
  • Методы == и hash(into:) используют одни и те же свойства
• Избегайте изменения объектов, находящихся в Set
• Помните, что уникальность определяется семантикой равенства, которую вы задаете

Альтернативы для специальных случаев

Если требуется особая логика уникальности:

1. Кастомная коллекция на основе Dictionary, где ключ — критерий уникальности
2. Массив с проверкой перед добавлением:

extension Array where Element: Equatable {
    func insertingIfUnique(_ element: Element) -> [Element] {
        return contains(element) ? self : self + [element]
    }
}

Вывод

Set гарантирует уникальность элементов в соответствии с реализацией протокола Hashable для типа элемента. Однако эта гарантия зависит от корректной реализации hash(into:) и ==, а также от неизменности хешируемых свойств объектов после их добавления в коллекцию. Понимание этих деталей критично для написания надежного кода, особенно при работе с mutable-объектами в Set.