> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Swift Identical To
The `===` operator, known as the identity operator, evaluates whether two constants or variables point to the exact same object instance in memory. It returns a Boolean value: `true` if both operands reference the same memory address, and `false` otherwise.
## Technical Characteristics
* **Applicable Types:** The `===` operator applies to instances of classes, actors, and class-bound (or `AnyObject`) protocols. It cannot be used with value types (such as `struct`, `enum`, `Int`, or `String`) because value types are copied upon assignment and do not share memory addresses. Additionally, while functions and closures are reference types in Swift, the `===` operator cannot be used to compare them.
* **Pointer Equality:** Under the hood, `===` performs a pointer comparison. It checks the memory address of the references rather than evaluating the data stored within the instances.
* **No Protocol Conformance Required:** Unlike the equality operator (`==`), which requires types to conform to the `Equatable` protocol, `===` is available by default for supported object instances without any explicit protocol adoption.
## Syntax Visualization
```swift theme={"dark"}
class ReferenceType {
var value: Int
init(value: Int) { self.value = value }
}
let instanceA = ReferenceType(value: 100)
let instanceB = instanceA // instanceB points to the same memory address as instanceA
let instanceC = ReferenceType(value: 100) // instanceC is a new instance with identical data
// Identity Comparison
let isSameInstance = (instanceA === instanceB) // Evaluates to true
let isDifferentInstance = (instanceA === instanceC) // Evaluates to false
```
## Distinction from the Equality Operator (`==`)
It is critical to distinguish between identity (`===`) and equality (`==`):
* `===` answers: *Are these two references pointing to the same allocation in memory?*
* `==` answers: *Do these two instances hold the same observable data/state?* (Requires custom implementation via `Equatable`).
## The Inverse Operator (`!==`)
Swift also provides the `!==` operator (the "not identical to" operator). It is the logical negation of `===` and returns `true` if two references point to different instances in memory.
```swift theme={"dark"}
let instancesDiffer = (instanceA !== instanceC) // Evaluates to true
```
Tired of Poor Swift Skills? Fix That With Deep Grasping!
Learn More
