Ответ
Оператор идентичности (===) используется для проверки, ссылаются ли две переменные или константы на один и тот же экземпляр класса в памяти.
Пример использования:
class User {
let id: String
init(id: String) { self.id = id }
}
// Создаем экземпляры
let user1 = User(id: "123")
let user2 = user1 // Копируется ссылка
let user3 = User(id: "123") // Новый экземпляр
// Сравнение по ссылке:
print(user1 === user2) // true - одна и та же ссылка
print(user1 === user3) // false - разные экземпляры
print(user1 !== user3) // true - разные экземплярыКлючевые моменты:
- Работает только с классами (reference types)
- Не работает со структурами и перечислениями (value types), так как они всегда копируются
- Отличается от оператора равенства (
==) который сравнивает значения
Когда использовать ===:
- Проверка, является ли объект
singleton - Отслеживание конкретного экземпляра в делегатах или наблюдателях
- Оптимизация при работе с тяжелыми объектами
Для структур используйте сравнение значений:
struct Point {
let x, y: Int
}
let p1 = Point(x: 10, y: 20)
let p2 = Point(x: 10, y: 20)
// Для структур нужно реализовать Equatable
// или сравнивать свойства напрямую
print(p1.x == p2.x && p1.y == p2.y) // trueОтвет 18+ 🔞
А, ну вот, опять про эти ваши операторы, блядь! Слушай, давай разжую, как для совсем тупых, а то у меня терпения ноль ебать с этими объяснениями.
Вот представь, блядь, у тебя есть бутылка водки. Одна, ёпта. Ты её держишь в руке — это user1. Потом ты передаёшь её своему корешу — это user2. Это одна и та же, сука, бутылка или нет? Да, пиздец, одна! Ты пальцем на неё показываешь, он пальцем на неё показывает. Это оператор === — он проверяет, ты и твой кореш на одну и ту же, блядь, бутылку смотрите или нет.
class User {
let id: String
init(id: String) { self.id = id }
}
// Купил бутылку
let user1 = User(id: "123")
// Передал её корегу, он держит ту же самую
let user2 = user1
// Пошёл в магазин, купил ещё одну, внешне такую же
let user3 = User(id: "123")
// Ты и кореш трясёте одну бутылку?
print(user1 === user2) // true — ага, одну и ту же, сука!
// А та, что из магазина, это та же самая, что у тебя была?
print(user1 === user3) // false — да не, блядь, другая же!
// Это точно не одна и та же бутылка?
print(user1 !== user3) // true — точно не одна, ёпта!А теперь, внимание, ебать мои старые костыли, главный подвох! Этот трюк работает только с классами, потому что классы — это как та самая бутылка: все на неё ссылаются. А структуры (struct) и перечисления — это как рецепт самогона. Ты одному дал рецепт, другому дал рецепт. Это два одинаковых листочка бумаги, но это же не одна и та же, блядь, бумажка! Для них === вообще нихуя не работает, он только мозги пудрит.
И не путай, ёперный театр, с обычным равенством ==! == — это про то, что внутри бутылок одинаково (та же водка, тот же градус). А === — это про то, что это физически одна и та же, сука, бутылка в руках.
Короче, когда это юзать:
- Когда нужно проверить, не тот ли это единственный, блядь, начальник на всём проекте (синглтон).
- Когда следишь, не подсунули ли тебе какого-то левого делегата вместо твоего.
- Когда объект весит, как чугунный мост, и копировать его — себя не уважать.
А для структур (тех самых рецептов) делай так:
struct Point {
let x, y: Int
}
let p1 = Point(x: 10, y: 20)
let p2 = Point(x: 10, y: 20)
// Сравнивай, что в рецептах написано одно и то же
print(p1.x == p2.x && p1.y == p2.y) // true — ну да, ингредиенты совпалиВот и вся магия, блядь. Не усложняй.