Swift Dictionaries and Sets

var prices = ["tea": 2.5, "cake": 3.75]      // [String: Double]
var empty: [String: Int] = [:]

let tea = prices["tea"]                      // Optional(2.5)
let pizza = prices["pizza"]                  // nil
let cost = prices["pizza", default: 0]       // 0.0

• The type [String: Double] means keys are Strings and values are Doubles.
• Reading by key returns an optional, because the key might not exist. Unwrap it with if let or give a fallback with ?? or default:.
• Keys are unique; values can repeat. Keys must be Hashable, which all basic types are.
• count, isEmpty, keys and values describe the dictionary.

prices["soup"] = 4.0           // add
prices["tea"] = 2.8            // update
prices["cake"] = nil           // remove
prices["visits", default: 0] += 1   // not for prices, but a handy counting pattern

Setting a key adds it if it's new and replaces the value if it exists. Assigning nil removes the key. updateValue(_:forKey:) and removeValue(forKey:) do the same but also return the old value, which is useful when you need to know what was there.

for (item, price) in prices {
    print("\(item): \(price)")         // order not guaranteed
}
for item in prices.keys.sorted() {
    print("\(item): \(prices[item]!)") // alphabetical every time
}

Because dictionaries are unordered, sort the keys (or the pairs, with sorted { $0.key < $1.key }) whenever order matters, such as for display or tests. Dictionary(grouping: items, by: { $0.category }) builds a dictionary of arrays, grouping items by any property.

var tags: Set = ["swift", "ios"]
tags.insert("swift")           // ignored: already there
tags.contains("ios")           // true

To display a set in a predictable order, sort it: tags.sorted().

Several methods work on every entry at once and return a new dictionary:

let prices = ["tea": 2.5, "cake": 3.75, "soup": 4.0]

let withTax = prices.mapValues { $0 * 1.2 }     // same keys, new values
let cheap = prices.filter { $0.value < 3.5 }    // ["tea": 2.5]
let menu = Dictionary(uniqueKeysWithValues: zip(["a", "b"], [1, 2]))
let updated = ["a": 1, "b": 2].merging(["b": 20, "c": 3]) { old, new in new }

• mapValues keeps the keys and transforms each value.
• filter on a dictionary returns a dictionary of the entries that pass.
• Dictionary(uniqueKeysWithValues:) builds one from pairs. It crashes if a key appears twice, so only use it when keys are guaranteed unique.
• merging combines two dictionaries, and its closure decides which value wins when both have the same key. Here the new value 20 replaces 2.

Dictionary keys and set items must be Hashable: Swift needs to turn each one into a number, called a hash, to find it instantly. Strings, numbers and Bools already are. For your own struct, add Hashable and Swift writes the code for you, as long as every property is Hashable too:

struct Point: Hashable {
    var x: Int
    var y: Int
}
var visited: Set<Point> = [Point(x: 0, y: 0)]
visited.insert(Point(x: 0, y: 0))     // ignored: an equal point is there
print(visited.count)                  // 1

Two points with the same x and y count as the same item. This is a common way to track which squares of a game board you've already visited.