> ## 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 Deinitializer
A deinitializer is a special method invoked automatically by Swift immediately before an instance of a class, actor, or noncopyable type is deallocated from memory. It provides a deterministic execution block that runs just before the memory occupied by the instance is reclaimed.
## Syntax
A deinitializer is declared using the `deinit` keyword. Unlike initializers or standard methods, it does not take parameters, requires no parentheses, and returns no value.
```swift theme={"dark"}
class StandardClass {
deinit {
// Execution block
}
}
struct NoncopyableStruct: ~Copyable {
deinit {
// Execution block
}
}
```
## Core Mechanics and Rules
* **Supported Types:** Deinitializers are available for reference types (`class` and `actor`) and noncopyable value types (`struct` and `enum` declared with `~Copyable`). Standard copyable value types do not support deinitialization hooks.
* **Automatic Invocation:** You cannot call a `deinit` method explicitly. The trigger mechanism depends on the type:
* **Reference Types:** Automatic Reference Counting (ARC) triggers the deinitializer when an instance's strong reference count drops to zero.
* **Noncopyable Types:** The compiler injects the deinitializer call when the unique instance is destroyed at the end of its lifetime (e.g., falling out of scope). Explicitly consuming a value (e.g., `let newOwner = consume oldOwner`) transfers ownership; it does not trigger the deinitializer. The deinitializer only runs when the value is ultimately destroyed by its final owner.
* **Instance Validity and Isolation:** During the execution of the `deinit` block, the instance remains initialized and its properties are accessible. For `actor` types, the deinitializer is synchronous and non-isolated. Because the actor's reference count has dropped to zero—guaranteeing no other code can be executing concurrently on the actor—Swift explicitly permits accessing the actor's actor-isolated *stored* properties within the deinitializer. However, calling actor-isolated *methods* or accessing actor-isolated *computed* properties remains strictly prohibited.
* **Single Declaration:** A type can have at most one deinitializer.
## Bypassing Deinitialization with `discard`
For noncopyable types, you can explicitly prevent the deinitializer from running by using the `discard` operator. Calling `discard self` inside a `consuming` method ends the instance's lifetime and reclaims its memory *without* invoking the `deinit` block.
```swift theme={"dark"}
struct Resource: ~Copyable {
deinit {
print("Resource destroyed")
}
consuming func close() {
// Ends lifetime and prevents deinit from executing
discard self
}
}
```
## Inheritance and Chaining
In a class hierarchy, deinitialization propagates upwards from the subclass to the ultimate base class. Swift handles this chaining automatically.
1. When a subclass instance is deallocated, the subclass's `deinit` block executes first.
2. Upon completion of the subclass's `deinit`, the superclass's `deinit` is called automatically.
3. This upward delegation continues until the root base class is reached.
4. A superclass deinitializer is guaranteed to execute, even if the subclass does not explicitly define its own `deinit` block.
```swift theme={"dark"}
class BaseClass {
deinit {
print("BaseClass deinit executed")
}
}
class SubClass: BaseClass {
deinit {
print("SubClass deinit executed")
}
}
var reference: SubClass? = SubClass()
reference = nil
// Execution Order:
// 1. "SubClass deinit executed"
// 2. "BaseClass deinit executed"
```
Tired of Poor Swift Skills? Fix That With Deep Grasping!
Learn More
