Swift Dictionary

A Swift Dictionary is a generic, unordered collection that stores associations between keys of the same type and values of the same type. It is implemented as a hash table, requiring the Key type to conform to the Hashable protocol to guarantee key uniqueness and enable

O(1)

average time complexity for lookups, insertions, and deletions.

Type Signature and Initialization

The standard library defines a dictionary as Dictionary<Key, Value>, but the syntactic sugar [Key: Value] is the preferred convention.

// Explicit type declaration with an empty dictionary
var explicitDict: Dictionary<String, Int> = [:]

// Shorthand syntax (Preferred)
var shorthandDict: [String: Int] = [:]

// Initialization via dictionary literal
var initializedDict: [String: Int] = ["Alpha": 1, "Beta": 2]

Accessing and Modifying Values

Dictionary lookups via subscripting always return an Optional<Value> because the requested key may not exist in the collection.

let dict = ["Alpha": 1]

// Returns Optional(1)
let value = dict["Alpha"] 

// Returns nil
let missingValue = dict["Gamma"] 

// Subscripting with a default fallback (returns non-optional Int)
let safeValue = dict["Gamma", default: 0] 

Mutations can be performed using subscript assignment or dedicated mutating methods. Methods provide the advantage of returning the previous value prior to the mutation.

var mutableDict = ["Alpha": 1]

// Subscript assignment (inserts or updates)
mutableDict["Beta"] = 2 

// Subscript deletion
mutableDict["Alpha"] = nil 

// Method-based update (returns Optional containing the old value, or nil if new)
let oldValue = mutableDict.updateValue(3, forKey: "Beta") 

// Method-based removal (returns Optional containing the removed value)
let removedValue = mutableDict.removeValue(forKey: "Beta")

Iteration

Because dictionaries are unordered, iteration order is not guaranteed. Iterating over a dictionary yields a tuple containing the key and value.

let dict = ["Alpha": 1, "Beta": 2]

// Iterating over key-value tuples
for (key, value) in dict {
    print("\(key): \(value)")
}

// Accessing keys or values independently (returns Dictionary.Keys / Dictionary.Values)
let keys = dict.keys
let values = dict.values

Value Semantics and Memory

Dictionaries in Swift are value types implemented as structs. They utilize a copy-on-write (CoW) optimization strategy. When a dictionary is assigned to a new variable or passed to a function, it shares the same memory reference as the original until a mutation occurs, at which point a deep copy is allocated. To optimize memory allocations when the final size of a dictionary is known in advance, you can preallocate contiguous memory using the reserveCapacity(_:) method. This prevents the overhead of dynamic reallocation and rehashing during bulk insertions.

var largeDict: [Int: String] = [:]
largeDict.reserveCapacity(10_000) 

Tired of Poor Swift Skills? Fix That With Deep Grasping!Learn More

Methods

Initializers

Closures

Type Declarations

Properties

Generics

Optional Binding

Patterns

Extensions

Error Handling

Attributes

Subscripts

Parameters

Constants & Variables

Conditionals

Loops

Collection Types

Basic Types

Numeric Types

Imports

Comments

Optional Operators

Arithmetic Operators

Overflow Operators

Assignment Operators

Bitwise Operators

Comparison Operators

Conditional Operators

Logical Operators

Range Operators

Type-Casting Operators

Type Signature and Initialization

Accessing and Modifying Values

Iteration

Value Semantics and Memory

​Type Signature and Initialization

​Accessing and Modifying Values

​Iteration

​Value Semantics and Memory

Type Signature and Initialization

Accessing and Modifying Values

Iteration

Value Semantics and Memory