Kaken He

参考資料

コレクション型

Swiftは、値のコレクションを格納するための3つの主要なコレクション型として、配列、セット、辞書を提供しています。配列は値の順序付きコレクションです。セットは一意の値の順序なしコレクションです。辞書はキーと値の関連付けの順序なしコレクションです。

コレクション型

Swiftは、値のコレクションを格納するための3つの主要なコレクション型として、配列、セット、辞書を提供しています。配列は値の順序付きコレクションです。セットは一意の値の順序なしコレクションです。辞書はキーと値の関連付けの順序なしコレクションです。

CollectionTypes_intro

Swiftの配列、セット、辞書は、格納できる値とキーの型が常に明確です。これは、間違った型の値をコレクションに誤って挿入することができないことを意味します。また、コレクションから取得する値の型について確信を持つことができます。

注記 Swiftの配列、セット、辞書型はジェネリックコレクションとして実装されています。ジェネリック型とコレクションの詳細については、ジェネリクスを参照してください。

コレクションの可変性

配列、セット、または辞書を作成して変数に代入すると、作成されたコレクションは可変になります。これは、コレクションの作成後に、アイテムの追加、削除、または変更によってコレクションを変更（または変異）できることを意味します。配列、セット、または辞書を定数に代入すると、そのコレクションは不変となり、そのサイズと内容は変更できません。

注記 コレクションを変更する必要がないすべてのケースで不変コレクションを作成することは良い習慣です。そうすることで、コードについて推論しやすくなり、Swiftコンパイラが作成するコレクションのパフォーマンスを最適化できるようになります。

配列

配列は、同じ型の値を順序付きリストに格納します。同じ値が配列内の異なる位置に複数回出現することができます。

注記 SwiftのArray型はFoundationのNSArrayクラスにブリッジされています。

Foundationおよび CocoaでArrayを使用する方法の詳細については、Bridging Between Array and NSArrayを参照してください。

配列型の省略構文

Swift配列の型は完全にArray<Element>と書かれ、Elementは配列が格納できる値の型です。配列の型は省略形として[Element]と書くこともできます。2つの形式は機能的に同一ですが、省略形が推奨され、このガイド全体で配列の型を参照するときに使用されています。

空の配列の作成

Swiftでは2つの方法で空の配列を作成できます。関数の引数や、すでに型が指定された変数や定数など、コンテキストがすでに型情報を提供している場合は、[]（空の角括弧のペア）と書かれる空の配列リテラルを使用できます：

var someInts: [Int] = []
print("someInts is of type [Int] with \(someInts.count) items.")
// Prints "someInts is of type [Int] with 0 items."

あるいは、明示的なイニシャライザ構文を使用して特定の型の空の配列を作成できます。角括弧内に要素の型を書き、その後に括弧を付けます。例えば、以下の[Int]()：

var someInts = [Int]()
print("someInts is of type [Int] with \(someInts.count) items.")
// Prints "someInts is of type [Int] with 0 items."

両方の方法で同じ結果が得られます。ただし、空の配列リテラルの方が短く、通常は読みやすいです。

どちらの場合も、空の配列リテラル（[]）を使用して既存の変数に空の配列を再代入できます：

someInts.append(3)
// someInts now contains 1 value of type Int
someInts = []
// someInts is now an empty array, but is still of type [Int]

デフォルト値を持つ配列の作成

SwiftのArray型は、すべての値が同じデフォルト値に設定された特定のサイズの配列を作成するためのイニシャライザも提供しています。このイニシャライザに適切な型のデフォルト値（repeatingと呼ばれる）と、その値が新しい配列で繰り返される回数（countと呼ばれる）を渡します：

var threeDoubles = Array(repeating: 0.0, count: 3)
// threeDoubles is of type [Double], and equals [0.0, 0.0, 0.0]

2つの配列を結合して配列を作成

加算演算子（+）を使用して、互換性のある型を持つ2つの既存の配列を結合して新しい配列を作成できます。新しい配列の型は、結合する2つの配列の型から推論されます：

var anotherThreeDoubles = Array(repeating: 2.5, count: 3)
// anotherThreeDoubles is of type [Double], and equals [2.5, 2.5, 2.5]

var sixDoubles = threeDoubles + anotherThreeDoubles
// sixDoubles is inferred as [Double], and equals [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]

配列リテラルを使用した配列の作成

配列リテラルを使用して配列を初期化することもできます。これは、1つ以上の値を配列コレクションとして書く省略方法です。配列リテラルは、カンマで区切られた値のリストとして書かれ、角括弧のペアで囲まれています：

[<#value 1#>, <#value 2#>, <#value 3#>]

以下の例では、String値を格納するshoppingListという配列を作成しています：

var shoppingList: [String] = ["Eggs", "Milk"]
// shoppingList has been initialized with two initial items

shoppingList変数は、[String]と書かれた「文字列値の配列」として宣言されています。この特定の配列はStringの値型を指定しているため、String値のみを格納できます。ここでは、shoppingList配列は、配列リテラル内に書かれた2つのString値（"Eggs"と"Milk"）で初期化されています。

注記 shoppingList配列は、定数（let導入子を使用）ではなく変数（var導入子を使用）として宣言されています。これは、以下の例でショッピングリストにさらにアイテムが追加されるためです。

この場合、配列リテラルには2つのString値のみが含まれています。これはshoppingList変数の宣言の型（String値のみを含むことができる配列）と一致するため、配列リテラルの代入は2つの初期アイテムでshoppingListを初期化する方法として許可されています。

Swiftの型推論のおかげで、同じ型の値を含む配列リテラルで初期化する場合は、配列の型を書く必要はありません。shoppingListの初期化は、代わりに短い形式で書くこともできます：

var shoppingList = ["Eggs", "Milk"]

配列リテラル内のすべての値が同じ型であるため、Swiftは[String]がshoppingList変数に使用する正しい型であると推論できます。

配列へのアクセスと変更

配列のメソッドとプロパティ、またはサブスクリプト構文を使用して、配列にアクセスして変更します。

配列内のアイテム数を調べるには、読み取り専用のcountプロパティを確認します：

print("The shopping list contains \(shoppingList.count) items.")
// Prints "The shopping list contains 2 items."

countプロパティが0に等しいかどうかを確認するショートカットとして、Boolean型のisEmptyプロパティを使用します：

if shoppingList.isEmpty {
    print("The shopping list is empty.")
} else {
    print("The shopping list isn't empty.")
}
// Prints "The shopping list isn't empty."

配列のappend(_:)メソッドを呼び出すことで、配列の末尾に新しいアイテムを追加できます：

shoppingList.append("Flour")
// shoppingList now contains 3 items, and someone is making pancakes

あるいは、加算代入演算子（+=）を使用して、1つ以上の互換性のあるアイテムの配列を追加します：

shoppingList += ["Baking Powder"]
// shoppingList now contains 4 items
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
// shoppingList now contains 7 items

サブスクリプト構文を使用して配列から値を取得します。取得したい値のインデックスを配列名の直後の角括弧内に渡します：

var firstItem = shoppingList[0]
// firstItem is equal to "Eggs"

注記 配列の最初のアイテムのインデックスは1ではなく0です。Swiftの配列は常にゼロインデックスです。

サブスクリプト構文を使用して、指定されたインデックスの既存の値を変更できます：

shoppingList[0] = "Six eggs"
// the first item in the list is now equal to "Six eggs" rather than "Eggs"

サブスクリプト構文を使用する場合、指定するインデックスは有効である必要があります。例えば、配列の末尾にアイテムを追加しようとしてshoppingList[shoppingList.count] = "Salt"と書くと、ランタイムエラーが発生します。

サブスクリプト構文を使用して、置換する値のセットが置換する範囲と異なる長さであっても、値の範囲を一度に変更することもできます。次の例では、"Chocolate Spread"、"Cheese"、"Butter"を"Bananas"と"Apples"に置き換えます：

shoppingList[4...6] = ["Bananas", "Apples"]
// shoppingList now contains 6 items

指定されたインデックスに配列にアイテムを挿入するには、配列のinsert(_:at:)メソッドを呼び出します：

shoppingList.insert("Maple Syrup", at: 0)
// shoppingList now contains 7 items
// "Maple Syrup" is now the first item in the list

このinsert(_:at:)メソッドの呼び出しは、ショッピングリストの一番最初に、インデックス0で示される位置に、"Maple Syrup"の値を持つ新しいアイテムを挿入します。

同様に、remove(at:)メソッドを使用して配列からアイテムを削除します。このメソッドは指定されたインデックスのアイテムを削除し、削除されたアイテムを返します（必要ない場合は戻り値を無視できます）：

let mapleSyrup = shoppingList.remove(at: 0)
// the item that was at index 0 has just been removed
// shoppingList now contains 6 items, and no Maple Syrup
// the mapleSyrup constant is now equal to the removed "Maple Syrup" string

注記 配列の既存の境界外のインデックスの値にアクセスまたは変更しようとすると、ランタイムエラーが発生します。配列のcountプロパティと比較することで、インデックスを使用する前に有効かどうかを確認できます。配列内の最大の有効なインデックスはcount - 1です。配列はゼロからインデックス付けされているためです。ただし、countが0の場合（配列が空であることを意味）、有効なインデックスはありません。

アイテムが削除されると配列のギャップは埋められるため、インデックス0の値は再び"Six eggs"に等しくなります：

firstItem = shoppingList[0]
// firstItem is now equal to "Six eggs"

配列から最後のアイテムを削除したい場合は、配列のcountプロパティをクエリする必要を避けるために、remove(at:)メソッドではなくremoveLast()メソッドを使用します。remove(at:)メソッドと同様に、removeLast()は削除されたアイテムを返します：

let apples = shoppingList.removeLast()
// the last item in the array has just been removed
// shoppingList now contains 5 items, and no apples
// the apples constant is now equal to the removed "Apples" string

配列の反復処理

for-inループを使用して、配列内の値のセット全体を反復処理できます：

for item in shoppingList {
    print(item)
}
// Six eggs
// Milk
// Flour
// Baking Powder
// Bananas

各アイテムの値に加えて整数のインデックスが必要な場合は、代わりにenumerated()メソッドを使用して配列を反復処理します。配列内の各アイテムについて、enumerated()メソッドは整数とアイテムで構成されるタプルを返します。整数はゼロから始まり、各アイテムについて1ずつカウントアップします。配列全体を列挙すると、これらの整数はアイテムのインデックスと一致します。反復処理の一部として、タプルを一時的な定数または変数に分解できます：

for (index, value) in shoppingList.enumerated() {
    print("Item \(index + 1): \(value)")
}
// Item 1: Six eggs
// Item 2: Milk
// Item 3: Flour
// Item 4: Baking Powder
// Item 5: Bananas

for-inループの詳細については、For-Inループを参照してください。

セット

セットは、定義された順序のないコレクションに同じ型の異なる値を格納します。アイテムの順序が重要でない場合、またはアイテムが一度だけ出現することを保証する必要がある場合は、配列の代わりにセットを使用できます。

注記 SwiftのSet型はFoundationのNSSetクラスにブリッジされています。

FoundationおよびCocoaでSetを使用する方法の詳細については、Bridging Between Set and NSSetを参照してください。

セット型のハッシュ値

型がセットに格納されるにはハッシュ可能である必要があります。つまり、型は自身のハッシュ値を計算する方法を提供する必要があります。ハッシュ値は、等しいと比較されるすべてのオブジェクトで同じInt値であり、a == bの場合、aのハッシュ値はbのハッシュ値と等しくなります。

Swiftのすべての基本型（String、Int、Double、Boolなど）はデフォルトでハッシュ可能であり、セットの値型または辞書のキー型として使用できます。関連値を持たない列挙型のケース値（列挙型で説明）もデフォルトでハッシュ可能です。

注記 Swift標準ライブラリのHashableプロトコルに準拠させることで、独自のカスタム型をセットの値型または辞書のキー型として使用できます。必要なhash(into:)メソッドの実装については、Hashableを参照してください。プロトコルへの準拠については、プロトコルを参照してください。

セット型の構文

Swiftセットの型はSet<Element>と書かれ、Elementはセットが格納できる型です。配列とは異なり、セットには同等の省略形がありません。

空のセットの作成と初期化

イニシャライザ構文を使用して、特定の型の空のセットを作成できます：

var letters = Set<Character>()
print("letters is of type Set<Character> with \(letters.count) items.")
// Prints "letters is of type Set<Character> with 0 items."

注記 letters変数の型は、イニシャライザの型からSet<Character>と推論されます。

あるいは、関数の引数や、すでに型が指定された変数や定数など、コンテキストがすでに型情報を提供している場合は、空の配列リテラルを使用して空のセットを作成できます：

letters.insert("a")
// letters now contains 1 value of type Character
letters = []
// letters is now an empty set, but is still of type Set<Character>

配列リテラルを使用したセットの作成

配列リテラルを使用してセットを初期化することもできます。これは、1つ以上の値をセットコレクションとして書く省略方法です。

以下の例では、String値を格納するfavoriteGenresというセットを作成しています：

var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]
// favoriteGenres has been initialized with three initial items

favoriteGenres変数は、Set<String>と書かれた「String値のセット」として宣言されています。この特定のセットはStringの値型を指定しているため、String値のみを格納できます。ここでは、favoriteGenresセットは、配列リテラル内に書かれた3つのString値（"Rock"、"Classical"、"Hip hop"）で初期化されています。

注記 favoriteGenresセットは、定数（let導入子を使用）ではなく変数（var導入子を使用）として宣言されています。これは、以下の例でアイテムが追加および削除されるためです。

セット型は配列リテラルだけからは推論できないため、Set型を明示的に宣言する必要があります。ただし、Swiftの型推論のおかげで、1つの型の値のみを含む配列リテラルで初期化する場合は、セットの要素の型を書く必要はありません。favoriteGenresの初期化は、代わりに短い形式で書くこともできます：

var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"]

配列リテラル内のすべての値が同じ型であるため、SwiftはSet<String>がfavoriteGenres変数に使用する正しい型であると推論できます。

セットへのアクセスと変更

セットのメソッドとプロパティを通じて、セットにアクセスして変更します。

セット内のアイテム数を調べるには、読み取り専用のcountプロパティを確認します：

print("I have \(favoriteGenres.count) favorite music genres.")
// Prints "I have 3 favorite music genres."

countプロパティが0に等しいかどうかを確認するショートカットとして、Boolean型のisEmptyプロパティを使用します：

if favoriteGenres.isEmpty {
    print("As far as music goes, I'm not picky.")
} else {
    print("I have particular music preferences.")
}
// Prints "I have particular music preferences."

セットのinsert(_:)メソッドを呼び出すことで、セットに新しいアイテムを追加できます：

favoriteGenres.insert("Jazz")
// favoriteGenres now contains 4 items

セットのremove(_:)メソッドを呼び出すことで、セットからアイテムを削除できます。このメソッドは、アイテムがセットのメンバーである場合はアイテムを削除して削除された値を返し、セットにそのアイテムが含まれていない場合はnilを返します。あるいは、removeAll()メソッドを使用してセット内のすべてのアイテムを削除できます。

if let removedGenre = favoriteGenres.remove("Rock") {
    print("\(removedGenre)? I'm over it.")
} else {
    print("I never much cared for that.")
}
// Prints "Rock? I'm over it."

セットに特定のアイテムが含まれているかどうかを確認するには、contains(_:)メソッドを使用します。

if favoriteGenres.contains("Funk") {
    print("I get up on the good foot.")
} else {
    print("It's too funky in here.")
}
// Prints "It's too funky in here."

セットの反復処理

for-inループを使用して、セット内の値を反復処理できます。

for genre in favoriteGenres {
    print("\(genre)")
}
// Classical
// Jazz
// Hip hop

for-inループの詳細については、For-Inループを参照してください。

SwiftのSet型には定義された順序がありません。特定の順序でセットの値を反復処理するには、sorted()メソッドを使用します。これは、<演算子を使用してソートされた配列としてセットの要素を返します。

for genre in favoriteGenres.sorted() {
    print("\(genre)")
}
// Classical
// Hip hop
// Jazz

セット演算の実行

2つのセットを結合したり、2つのセットに共通する値を判断したり、2つのセットにすべて、一部、または同じ値がまったく含まれているかどうかを判断したりするなど、基本的なセット演算を効率的に実行できます。

基本的なセット演算

下の図は、2つのセットaとbを示しており、さまざまなセット演算の結果が網掛けの領域で表されています。

setVennDiagram

  • intersection(_:)メソッドを使用して、両方のセットに共通する値のみを持つ新しいセットを作成します。
  • symmetricDifference(_:)メソッドを使用して、どちらかのセットにはあるが両方にはない値を持つ新しいセットを作成します。
  • union(_:)メソッドを使用して、両方のセットのすべての値を持つ新しいセットを作成します。
  • subtracting(_:)メソッドを使用して、指定されたセットにない値を持つ新しいセットを作成します。
let oddDigits: Set = [1, 3, 5, 7, 9]
let evenDigits: Set = [0, 2, 4, 6, 8]
let singleDigitPrimeNumbers: Set = [2, 3, 5, 7]

oddDigits.union(evenDigits).sorted()
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
oddDigits.intersection(evenDigits).sorted()
// []
oddDigits.subtracting(singleDigitPrimeNumbers).sorted()
// [1, 9]
oddDigits.symmetricDifference(singleDigitPrimeNumbers).sorted()
// [1, 2, 9]

セットのメンバーシップと等価性

下の図は、3つのセットa、b、cを示しており、重なり合う領域はセット間で共有される要素を表しています。セットaは、aがbのすべての要素を含んでいるため、セットbのスーパーセットです。逆に、セットbは、bのすべての要素がaにも含まれているため、セットaのサブセットです。セットbとセットcは、共通する要素がないため、互いに素です。

setEulerDiagram

  • 「等しい」演算子（==）を使用して、2つのセットがすべて同じ値を含んでいるかどうかを判断します。
  • isSubset(of:)メソッドを使用して、セットのすべての値が指定されたセットに含まれているかどうかを判断します。
  • isSuperset(of:)メソッドを使用して、セットが指定されたセットのすべての値を含んでいるかどうかを判断します。
  • isStrictSubset(of:)またはisStrictSuperset(of:)メソッドを使用して、セットが指定されたセットのサブセットまたはスーパーセットであるが、等しくはないかどうかを判断します。
  • isDisjoint(with:)メソッドを使用して、2つのセットに共通する値がないかどうかを判断します。
let houseAnimals: Set = ["🐶", "🐱"]
let farmAnimals: Set = ["🐮", "🐔", "🐑", "🐶", "🐱"]
let cityAnimals: Set = ["🐦", "🐭"]

houseAnimals.isSubset(of: farmAnimals)
// true
farmAnimals.isSuperset(of: houseAnimals)
// true
farmAnimals.isDisjoint(with: cityAnimals)
// true

辞書

辞書は、定義された順序のないコレクションに同じ型のキーと同じ型の値の間の関連付けを格納します。各値は一意のキーに関連付けられ、辞書内のその値の識別子として機能します。配列のアイテムとは異なり、辞書のアイテムには指定された順序がありません。辞書は、実際の辞書が特定の単語の定義を調べるのに使用されるのと同じように、識別子に基づいて値を調べる必要がある場合に使用します。

注記 SwiftのDictionary型はFoundationのNSDictionaryクラスにブリッジされています。

FoundationおよびCocoaでDictionaryを使用する方法の詳細については、Bridging Between Dictionary and NSDictionaryを参照してください。

辞書型の省略構文

Swift辞書の型は完全にDictionary<Key, Value>と書かれ、Keyは辞書キーとして使用できる値の型であり、Valueはそれらのキーに対して辞書が格納する値の型です。

注記 辞書のKey型は、セットの値型と同様に、Hashableプロトコルに準拠している必要があります。

辞書の型は省略形として[Key: Value]と書くこともできます。2つの形式は機能的に同一ですが、省略形が推奨され、このガイド全体で辞書の型を参照するときに使用されています。

空の辞書の作成

配列と同様に、イニシャライザ構文を使用して特定の型の空のDictionaryを作成できます：

var namesOfIntegers: [Int: String] = [:]
// namesOfIntegers is an empty [Int: String] dictionary

この例では、整数値の人間が読める名前を格納するための[Int: String]型の空の辞書を作成しています。キーはInt型であり、値はString型です。

コンテキストがすでに型情報を提供している場合は、[:]（角括弧のペア内のコロン）と書かれる空の辞書リテラルを使用して空の辞書を作成できます：

namesOfIntegers[16] = "sixteen"
// namesOfIntegers now contains 1 key-value pair
namesOfIntegers = [:]
// namesOfIntegers is once again an empty dictionary of type [Int: String]

辞書リテラルを使用した辞書の作成

辞書リテラルを使用して辞書を初期化することもできます。これは、前に見た配列リテラルと同様の構文を持っています。辞書リテラルは、1つ以上のキーと値のペアをDictionaryコレクションとして書く省略方法です。

キーと値のペアは、キーと値の組み合わせです。辞書リテラルでは、各キーと値のペアのキーと値はコロンで区切られます。キーと値のペアは、カンマで区切られたリストとして書かれ、角括弧のペアで囲まれています：

[<#key 1#>: <#value 1#>, <#key 2#>: <#value 2#>, <#key 3#>: <#value 3#>]

以下の例では、国際空港の名前を格納する辞書を作成しています。この辞書では、キーは3文字の国際航空運送協会コードであり、値は空港名です：

var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]

airports辞書は、[String: String]の型を持つものとして宣言されています。これは「キーがString型であり、値もString型であるDictionary」を意味します。

注記 airports辞書は、定数（let導入子を使用）ではなく変数（var導入子を使用）として宣言されています。これは、以下の例で辞書にさらに空港が追加されるためです。

airports辞書は、2つのキーと値のペアを含む辞書リテラルで初期化されています。最初のペアは"YYZ"のキーと"Toronto Pearson"の値を持っています。2番目のペアは"DUB"のキーと"Dublin"の値を持っています。

この辞書リテラルには2つのString: Stringペアが含まれています。このキーと値の型はairports変数の宣言の型（StringキーのみとString値のみを持つ辞書）と一致するため、辞書リテラルの代入は2つの初期アイテムでairports辞書を初期化する方法として許可されています。

配列と同様に、キーと値が一貫した型を持つ辞書リテラルで初期化する場合は、辞書の型を書く必要はありません。airportsの初期化は、代わりに短い形式で書くこともできます：

var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]

リテラル内のすべてのキーが互いに同じ型であり、同様にすべての値が互いに同じ型であるため、Swiftは[String: String]がairports辞書に使用する正しい型であると推論できます。

辞書へのアクセスと変更

辞書のメソッドとプロパティ、またはサブスクリプト構文を使用して、辞書にアクセスして変更します。

配列と同様に、Dictionary内のアイテム数を調べるには、読み取り専用のcountプロパティを確認します：

print("The airports dictionary contains \(airports.count) items.")
// Prints "The airports dictionary contains 2 items."

countプロパティが0に等しいかどうかを確認するショートカットとして、Boolean型のisEmptyプロパティを使用します：

if airports.isEmpty {
    print("The airports dictionary is empty.")
} else {
    print("The airports dictionary isn't empty.")
}
// Prints "The airports dictionary isn't empty."

サブスクリプト構文を使用して辞書に新しいアイテムを追加できます。適切な型の新しいキーをサブスクリプトのインデックスとして使用し、適切な型の新しい値を代入します：

airports["LHR"] = "London"
// the airports dictionary now contains 3 items

サブスクリプト構文を使用して、特定のキーに関連付けられた値を変更することもできます：

airports["LHR"] = "London Heathrow"
// the value for "LHR" has been changed to "London Heathrow"

サブスクリプトの代わりに、辞書のupdateValue(_:forKey:)メソッドを使用して、特定のキーの値を設定または更新できます。上記のサブスクリプトの例と同様に、updateValue(_:forKey:)メソッドは、キーが存在しない場合は値を設定し、そのキーがすでに存在する場合は値を更新します。ただし、サブスクリプトとは異なり、updateValue(_:forKey:)メソッドは更新を実行した後に古い値を返します。これにより、更新が行われたかどうかを確認できます。

updateValue(_:forKey:)メソッドは、辞書の値型のオプショナル値を返します。例えば、String値を格納する辞書の場合、メソッドはString?型、つまり「オプショナルのString」型の値を返します。このオプショナル値は、更新前にそのキーに値が存在していた場合はその古い値を含み、値が存在しなかった場合はnilを含みます：

if let oldValue = airports.updateValue("Dublin Airport", forKey: "DUB") {
    print("The old value for DUB was \(oldValue).")
}
// Prints "The old value for DUB was Dublin."

サブスクリプト構文を使用して、特定のキーの値を辞書から取得することもできます。値が存在しないキーをリクエストする可能性があるため、辞書のサブスクリプトは辞書の値型のオプショナル値を返します。辞書がリクエストされたキーの値を含んでいる場合、サブスクリプトはそのキーの既存の値を含むオプショナル値を返します。それ以外の場合、サブスクリプトはnilを返します：

if let airportName = airports["DUB"] {
    print("The name of the airport is \(airportName).")
} else {
    print("That airport isn't in the airports dictionary.")
}
// Prints "The name of the airport is Dublin Airport."

サブスクリプト構文を使用して、そのキーにnilの値を代入することで、辞書からキーと値のペアを削除できます：

airports["APL"] = "Apple International"
// "Apple International" isn't the real airport for APL, so delete it
airports["APL"] = nil
// APL has now been removed from the dictionary

あるいは、removeValue(forKey:)メソッドを使用して辞書からキーと値のペアを削除できます。このメソッドは、キーと値のペアが存在する場合はそれを削除して削除された値を返し、値が存在しなかった場合はnilを返します：

if let removedValue = airports.removeValue(forKey: "DUB") {
    print("The removed airport's name is \(removedValue).")
} else {
    print("The airports dictionary doesn't contain a value for DUB.")
}
// Prints "The removed airport's name is Dublin Airport."

辞書の反復処理

for-inループを使用して、辞書内のキーと値のペアを反復処理できます。辞書内の各アイテムは(key, value)タプルとして返され、反復処理の一部としてタプルのメンバーを一時的な定数または変数に分解できます：

for (airportCode, airportName) in airports {
    print("\(airportCode): \(airportName)")
}
// LHR: London Heathrow
// YYZ: Toronto Pearson

for-inループの詳細については、For-Inループを参照してください。

keysおよびvaluesプロパティにアクセスすることで、辞書のキーまたは値の反復可能なコレクションを取得することもできます：

for airportCode in airports.keys {
    print("Airport code: \(airportCode)")
}
// Airport code: LHR
// Airport code: YYZ

for airportName in airports.values {
    print("Airport name: \(airportName)")
}
// Airport name: London Heathrow
// Airport name: Toronto Pearson

Arrayインスタンスを受け取るAPIで辞書のキーまたは値を使用する必要がある場合は、keysまたはvaluesプロパティを使用して新しい配列を初期化します：

let airportCodes = [String](airports.keys)
// airportCodes is ["LHR", "YYZ"]

let airportNames = [String](airports.values)
// airportNames is ["London Heathrow", "Toronto Pearson"]

SwiftのDictionary型には定義された順序がありません。特定の順序で辞書のキーまたは値を反復処理するには、keysまたはvaluesプロパティでsorted()メソッドを使用します。