コレクション型


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


CollectionTypes_intro_2x


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



注意: Swift の配列、セット、および辞書の型は、汎用のコレクション として実装されています。汎用型とコレクションの詳細については、ジェネリック(汎用) を参照してください。


コレクションの可変性


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


注意: コレクションが、変更する必要がないすべての場合、不変コレクションを作成することをお勧めします。そうすることで、あなたのコードについて推論することが容易になり、あなたが作成したコレクションのパフォーマンスを最適化するのを、Swift コンパイラに可能にします。


配列


配列 は、順序付けられたリストの同じ型の複数の値を格納します。同じ値が異なる位置に、配列内で複数回現れる事があります。


注意: Swift の Array 型は、Foundation の NSArray クラスにブリッジされます。

Foundation と Cocoa で Array を使う詳細については、ココアと Object-C を Swift で使う(Swift 4.0.3)ココアのデータ型での操作 をご覧になって下さい。


配列型省略構文


Swift の配列の型は、すべて書くと Array<Element>であり、ここで Element は、配列が格納するのを許可されている値の型です。また、[Element] と省略形式で配列の型を書くこともできます。二つの形式は機能的に同一ですが、省略形が好まれ、配列の型を参照するときに、このガイド全体で使用されています。



空の配列の作成


イニシャライザの構文を使用して、特定の型の空の配列を作成できます。


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


someInts 変数の型はイニシャライザの型から [Int] であることが推測されることに注意してください。


代わりに、コンテキストがすでにこのような関数の引数や、既に入力された変数または定数などの型情報を提供する場合、[] (角括弧の空のペア) のように書いて空の配列リテラルを持つ空の配列を作成できます。



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


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


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


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


2つの配列を共にして一つの配列に


加算演算子(+)で互換性のある型を持つ2つの既存の配列を共にすることで、新しい配列を作成できます。新しい配列の型は、一緒に追加した、2つの配列の型から推測されます。


  1. var anotherThreeDoubles = Array(repeating: 2.5, count: 3)
  2. // anotherThreeDoubles is of type [Double], and equals [2.5, 2.5, 2.5]
  3. var sixDoubles = threeDoubles + anotherThreeDoubles
  4. // sixDoubles is inferred as [Double], and equals [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]


配列リテラルでの配列の作成


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



[, , ]



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



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


shoppingList 変数は、[String] と書かれ、"String 値の配列" として宣言されています。この特有の配列は String の値型を指定しており、String 値だけを格納する事が許可されています。ここでは、shoppingList 配列は配列リテラル内に書かれている、2つの String 値("Eggs""Milk")で初期化されています。



注意: shoppingList 配列は、変数として宣言されており(var に引き続き宣言)、定数(let に引き続き宣言)ではなく、それはもっと多くの項目が以下の例のショッピングリストに追加されているためです。


この場合、配列リテラルには2つの String 値以外には何も含まれていません。これは shoppingList 変数の宣言の型(String 値のみを含める配列)と一致し、したがって配列リテラルの代入は、2つの初期項目で shoppingList を初期化する方法として許可されています。


Swift の型推論のおかげで、同じ型の値を含む配列リテラルでそれを初期化する場合は、配列の型を記述する必要はありません。shoppingList の初期化は、その代わり、短い形式で書けます:


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



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



配列へのアクセスと変更


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


配列内の項目の数を調べ、その読み取り専用の count プロパティをチェックします:


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


count プロパティが 0 に等しいかどうかをチェックするための省略形としてブール値の isEmpty プロパティを使用します。


  1. if shoppingList.isEmpty {
  2.        print("The shopping list is empty.")
  3. } else {
  4.        print("The shopping list is not empty.")
  5. }
  6. // prints "The shopping list is not empty."


配列の append(_:) メソッドを呼び出すことによって配列の末尾に、新しい項目を追加できます。


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


代わりに、加算代入演算子(+=)で1つ以上の互換性のある項目を配列に追加します。


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


配列の名前のすぐ後に角括弧内を書き、取り出したい値のインデックスを渡し、サブスクリプト構文 を使用して配列から値を取得できます。


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


注意: 配列の最初の項目は 1 ではなく 0 のインデックスを持っています。Swift では配列は常にゼロから始まります。


与えられたインデックスの既存の値を変更するには、サブスクリプト構文を使用できます。


  1. shoppingList[0] = "Six eggs"
  2. // 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" で置き換えます。


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


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


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


insert(_:at:) メソッドのこの呼び出しは、インデックス 0 で示される買い物リストの先頭に "Maple Syrup" の値を、新しいアイテムとして挿入します。


同様に、remove(at:) メソッドで配列から項目を削除します。このメソッドは、指定されたインデックスにある項目を削除し、(それを必要としない場合は、戻り値を無視することができますが)削除された項目を返します。


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


注意: 配列の既存の境界の外にあるインデックスの値にアクセスしたり、変更しようとすると、実行時エラーが引き起こされます。インデックスは配列の count プロパティと比較することによって、それを使用する前に有効であることを確認できます。配列は、ゼロからインデックスされているため、配列内の有効な最大のインデックスは count - 1 ですが、count0 の時(配列が空である事を意味する)有効なインデックスはありません。


配列内の全てのギャップは項目が削除されたときに閉じられ、インデックス 0 の値は、再び "Six eggs" に等しくなります:


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


配列から最後の項目を削除したい場合は、配列の count プロパティを照会する必要を回避するために、remove(at:) メソッドではなく、removeLast() メソッドを使用して下さい。remove(at:) メソッドと同様に、removeLast() は削除した項目を返します:


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


配列の繰り返し処理


配列内の値のセット全体を for-in ループで反復処理することができます:


  1. for item in shoppingList {
  2.        print(item)
  3. }
  4. // Six eggs
  5. // Milk
  6. // Flour
  7. // Baking Powder
  8. // Bananas


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


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


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



セット


定義された順序なしでコレクションの同じ型の個別の値を セット は保存します。項目が一度だけ表われることを保証する必要があるか、項目の順序が重要でない場合配列の代わりにセットを使用できます。



注意: Swift の Set 型は、Foundation の NSSet クラスにブリッジされます。

Foundation と Cocoa で Set を使用する詳細については、Cocoa と Objective-C で Swift を使う(Swift 4)ココアのデータ型での操作 を参照してください。


セット型のハッシュ値


型はセットに格納されるために ハッシュ可能 でなければならず、つまり、型は自分自身の ハッシュ値 を計算する方法を提供しなければなりません。ハッシュ値は a == b のような場合、それはその a.hashValue == b.hashValue が続く場合、均等を比較するすべてのオブジェクトに対して同じである Int 値です。


(String、Int、Double、および ブール のような) Swift の基本型のすべては、デフォルトでハッシュ可能であり、セットの値型または辞書のキー型として使用できます。関連する値のない列挙型 case の値は、(列挙型 で説明したように) デフォルトでハッシュも可能です。


注意: それらを Swift の標準ライブラリから Hashable(ハッシュ可能な) プロトコルに準拠することにより、セットの値型または辞書のキー型として独自のカスタム型を使用できます。Hashable プロトコルに準拠する型は、hashValue と呼ばれる取得可能な Int プロパティを提供しなければなりません。型の hashValue プロパティによって返される値は、同じプログラムの、または異なるプログラムの異なる実行間で同じである必要はありません。

Hashable プロトコルは Equatable に準拠しているため、準拠している型も等号演算子(==) の実装を提供しなければなりません。Equatable プロトコルは同値関係である事を == の全ての準拠実装に必要とします。つまり、すべての a、b、c の値のために == の実装は、以下の3つの条件を満たしていなりませんなりません。:
  • a == a(再帰性)
  • a == bb == a を意味する(対称)
  • a == b && b == ca == c を意味する(推移)

プロトコルに準拠する方法の詳細については、プロトコル を参照してください。


セット型の構文


Swift のセット型は、Set<Element> と書かれ、ここで Element はセットが格納するのを許可されている型です。配列とは異なり、セットは同等の省略形を持っていません。



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


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


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


注意: letters 変数の型はイニシャライザの型から、Set<Character> であるることが推定されます。

代わりに、コンテキストがすでに関数の引数や、既に型付けられた変数または定数のような型情報を提供している場合、空の配列リテラルで空のセットを作成できます。


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


配列リテラルでセットの作成


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


以下の例では、String 値を格納する favoriteGenres と呼ばれるセットを作成します。


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


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



注意: favoriteGenres セットは変数として(var に引き続き)宣言され、定数(let に引き続き)ではなく宣言されていますが、以下の例では項目が追加されたり削除するからです。


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



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



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



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


セットにアクセスし、変更するにはそのメソッドとプロパティを使用して行います。


セット内の項目数を調べるには、その読み取り専用の count プロパティをチェックして下さい。


  1. print("I have \(favoriteGenres.count) favorite music genres.")
  2. // prints ""I have 3 favorite music genres.""


count プロパティが 0 に等しいかどうかをチェックするための省略形としてブール値の isEmpty プロパティを使用して下さい。


  1. if favoriteGenres.isEmpty {
  2.         print("As far as music goes, I'm not picky.")
  3. } else {
  4.         print("I have particular music preferences.")
  5. }
  6. // prints "I have particular music preferences."


セットの insert(_:) メソッドを呼び出すことによって、セットに新しい項目を追加できます。


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


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


  1. if let removedGenre = favoriteGenres.remove("Rock") {
  2.         print("\(removedGenre)? I'm over it.")
  3. } else {
  4.         print("I never much cared for that.")
  5. }
  6. // prints "Rock? I'm over it."


セットが、特定の項目を含んでいるかどうかを確認するには、contain(_:) メソッドを使って下さい。


  1. if favoriteGenres.contains("Funk") {
  2.         print("I get up on the good foot.")
  3. } else {
  4.         print("It's too funky in here.")
  5. }
  6. // prints "It's too funky in here."


セットを反復処理


for-in ループで、セットの中の値を反復処理できます。


  1. for genre in favoriteGenres {
  2.         print("\(value)")
  3. }
  4. // Classical
  5. // Jazz
  6. // Hip hop


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


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


  1. for genre in favoriteGenres.sorted() {
  2.         print("\(genre)")
  3. }
  4. // Classical
  5. // Hip hop
  6. // Jazz


セット操作の実行


効率的に、2つのセットを組み合わせたり、2つのセットに共通している値はどれかを決定したり、2つのセットが同じ値のすべて、一部を含むか、または全く含まないかどうかを決定するなどの基本的なセットの演算を実行できます。


基本的なセットの操作


下の図は、2つのセット- ab- が各種のセット操作の結果を、網掛け領域で示しています。


setVennDiagram_2x


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


セットの身分と等価性


以下の図は、3組のセット、すなわち a,b 及び c を示し、セット間の共有要素を表す領域を重ねて示しています。 ab のすべての要素を含んでいるため、セット a は、セット bスーパーセット です。逆に、b のすべての要素が a に含まれているため、セット b はセット aサブセット です。共通の要素を共有しないため、セット b とセット c は、互いに です。



setEulerDiagram_2x


  1. let houseAnimals: Set = ["🐶", "🐱"]
  2. let farmAnimals: Set = ["🐮", "🐔", "🐑", "🐶", "🐱"]
  3. let cityAnimals: Set = ["🐦", "🐭"]
  4. houseAnimals.isSubset(of: farmAnimals)
  5. // true
  6. farmAnimals.isSuperset(of: houseAnimals)
  7. // true
  8. farmAnimals.isDisjoint(with: cityAnimals)
  9. // true


Dictionary


dictionary は、同じ型のキーと同じ型の値を関連付けて格納し、定義されない順序で集めるものです。各々の値は、dictionary 内のその値の識別子として機能する一意の キー として関連付けられています。配列内の項目とは異なり、dictionary 内の項目には、特定の順序はありません。現実世界の辞書が、特定の単語の定義を検索するために使用されるのとほとんど同じ方法で、その識別子に基づいて値を検索する必要があるときに、dictionary を使用して下さい。


注意: Swift の Dictionary は Foundation の NSDictionary にブリッジされます。

Foundation と Cocoa で Dictionary を使用する方法の詳細については、Cocoa と Objective-C で Swift を使う(Swift 4)ココアのデータ型での操作 を参照して下さい。


Dictionary 型の省略型構文


Swift の Dictionary の型は、略さず書くと Dictionary<Key,Value> であり、ここで Key は Dictionary のキーとして使用できる値の型であり、Value は、それらのキーを、dictionary が格納している値の型です。


注意: Dictionary の Key の型は、セットの値型のように、Hashable プロトコルに準拠しなければなりません。


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



空の Dictionary を作成


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


  1. var namesOfIntegers = [Int: String]()
  2. // namesOfIntegers is an empty [Int: String] dictionary


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


コンテキストがすでに型情報を提供している場合は、[:] (ペアの角カッコ内のコロン)のように書かれる空の辞書リテラルで、空の辞書を作成できます。


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


Dictionary リテラルで Dictionary の作成


以前見た配列リテラルと似た構文を持つ dictionary リテラル でも、dictionary を初期化できます。dictionary リテラルは Dictionary コレクションのような、1つ以上のキー値のペアを書き込むための省略方法です。


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


[key 1: value 1, key 2: value 2, key 3: value 3]


以下の例は、国際空港の名前を格納するための dictionary を作成します。この dictionary では、キーが3文字の国際航空運送協会コードで、値は、空港名です:


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



airports の dictionary は、[String: String] の型を持つものとして宣言され、それは"キーが String 型の Dictionary であり、その値もまた String 型です" と言う意味です。


注意: 以下の例では dictionary に、より多くの空港が加えられるため、airports dictionary は変数として宣言(var に引き続き宣言)され、定数(let に引き続き宣言)ではありません。


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


この dictionary リテラルは、2つの String: String ペアを含んでいます。このキー値の型は airports 変数宣言(String キーのみで、String 値のみの dictionary)の型と一致し、そのように dictionary リテラルの割り当ては、airports dictionary が2つの初期項目で初期化するための方法として許可されています。


配列と同じように、そのキーと値が一貫した型を持つ dictionary リテラルで初期化している場合、dictionary の型を記述する必要はありません。airports の初期化は、代わりに省略形で書けます:


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



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



Dictionary のアクセスと変更


dictionary のメソッドとプロパティを通じて、またはサブスクリプト構文を使用して dictionary にアクセスし、変更して下さい。


配列と同様に、その読み取り専用の count プロパティをチェックして、Dictionary 内の項目数を調べて下さい。


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


count プロパティが 0 に等しいかどうかをチェックするための省略形としてブール値の isEmpty プロパティを使用します。


  1. if airports.isEmpty {
  2.        print("The airports dictionary is empty.")
  3. } else {
  4.        print("The airports dictionary is not empty.")
  5. }
  6. // prints "The airports dictionary is not empty."


サブスクリプト構文を使用して、dictionary に新しい項目を追加できます。サブスクリプトインデックスとして適切な型の新しいキーを使用して、適切な型の新しい値を代入して下さい。


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


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


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

サブスクリプトに代わるものとして、特定のキーの値を設定または更新する為に、dictionary の updateValue(_:forKey:) メソッドを使用して下さい。上記のサブスクリプトの例と同様に、 updateValue(_:forKey:) メソッドは、何も値やキーが存在しない、またはそのキーがすでに存在する時、値を設定します。しかし、サブスクリプトとは異なり、updateValue(_:forKey:) メソッドは、更新を実行した後、以前の 値を返します。これで、更新が行われたかどうかをチェックすることができます。


updateValue(_:forKey:) メソッドは、dictionary の値型の optional 値を返します。String 値を格納した dictionary は、例えば、メソッドは String? 型の値、または "Optional String" を返します。この optional 値は、更新前に存在した古い値、または何も値が存在しない場合は nil を含んでいます。


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


また、特定のキーで dictionary から値を取得するためにサブスクリプト構文も使用できます。何も値が存在しないのにキーを要求する場合があるため、dictionary のサブスクリプトは、dictionary の値型の optional 値を返します。dictionary が要求されたキーの値を含んでいる場合は、サブスクリプトはそのキーの既存の値を含む optional 値を返します。そうでない場合、サブスクリプトは nil を返します:


  1. if let airportName = airports["DUB"] {
  2.        print("The name of the airport is \(airportName).")
  3. } else {
  4.        print("That airport is not in the airports dictionary.")
  5. }
  6. // prints "The name of the airport is Dublin Airport."


そのキーに nil の値を代入することにより、dictionary からキー値のペアを削除するにはサブスクリプト構文を使用できます。


  1. airports["APL"] = "Apple International"
  2. // "Apple International" is not the real airport for APL, so delete it
  3. airports["APL"] = nil
  4. // APL has now been removed from the dictionary


代わりに、removeValue(forKey:) メソッドで dictionary からキー値のペアを削除します。それが存在する場合、このメソッドは、キー値のペアを削除し、削除された値を返し、または値が存在しない場合 nil を返します。


  1. if let removedValue = airports.removeValue(forKey: "DUB") {
  2.        print("The removed airport's name is \(removedValue).")
  3. } else {
  4.        print("The airports dictionary does not contain a value for DUB.")
  5. }
  6. // prints "The removed airport's name is Dublin International."


Dictionary を繰り返し処理


for-in ループで dictionary 内のキー値のペアを繰り返し処理できます。dictionary 内の各項目は、(key,value) のタプルとして返され、反復の一部として、一時的な定数や変数にタプルのメンバーを分解できます。


  1. for (airportCode, airportName) in airports {
  2.        print("\(airportCode): \(airportName)")
  3. }
  4. // YYZ: Toronto Pearson
  5. // LHR: London Heathrow


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


また、その keysvalues のプロパティにアクセスすることにより、dictionary のキーまたは値の反復するコレクションも取得できます。


  1. for airportCode in airports.keys {
  2.        print("Airport code: \(airportCode)")
  3. }
  4. // Airport code: YYZ
  5. // Airport code: LHR
  6. for airportName in airports.values {
  7.        print("Airport name: \(airportName)")
  8. }
  9. // Airport name: Toronto Pearson
  10. // Airport name: London Heathrow


Array のインスタンスを取る API で dictionary のキーまたは値を使用する必要がある場合は、keys または values プロパティを持つ新しい配列を初期化して下さい。


  1. let airportCodes = [String](1airports.keys)
  2. // airportCodes is ["YYZ","LHR"]
  3. let airportNames = [String](airports.values)
  4. // airportNames is ["Toronto Pearson","London Heathrow"]


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





前:文字列と文字 次:フロー制御
目次
Xcode 9 の新機能

Swift:はじめに
Swift と Cocoa と Objective-C
Swift Blog より

  • ようこそ Swift へ(Part I)
  • Swift について
  • バージョン互換性
  • Swift のツアー
  • 単純な値
    制御フロー
    関数とクロージャ
    オブジェクトとクラス
    列挙型と構造体
    プロトコルと拡張機能
    エラー処理
    汎用(ジェネリック)
  • Swift 言語のガイド(Part II)
  • Swift の基本
  • 定数と変数
  • 定数と変数の宣言
    型注釈
    定数と変数の命名
    定数と変数の印刷
    コメント
    セミコロン
  • 整数
  • 整数の境界
    Int
    UInt
    浮動小数点数
    安全な型と型推論
    数値リテラル
  • 数値型変換
  • 整数変換
    整数と浮動小数点間の変換
    型エイリアス
    ブール型
    タプル
  • Optional
  • nil
    if 文と強制開封
    Optional の結合
    暗黙に開封された Optionals
    エラー処理
  • アサーション(断言)と前提条件
  • アサーションを使用したデバッグ
    前提条件の実施
  • 基本演算子
  • 専門用語
    代入演算子
  • 算術演算子
  • 剰余演算子
    単項マイナス演算子
    単項プラス演算子
    複合代入演算子
    比較演算子
    三項条件演算子
    Nil 合体演算子
  • 範囲演算子
  • 閉鎖範囲演算子
    半開放範囲演算子
    片方の範囲
  • 論理演算子
  • 論理 NOT 演算子
    論理 AND 演算子
    論理 OR 演算子
    論理演算子の組み合わせ
    明示的な括弧
  • 文字列と文字
  • 文字列リテラル
    複数行の文字列リテラル
    文字列リテラル内の特殊文字
    空の文字列の初期化
    文字列の可変性
    文字列は値の型
    文字を使った作業
    文字列と文字を連結
    文字列補間
  • ユニコード(Unicode)
  • Unicode スカラー
    文字列リテラルの中の特別の文字
    拡張書記クラスタ
    文字を数える
  • 文字列のアクセスと変更
  • 文字列のインデックス
    部分文字列
    挿入と削除
  • 文字列の比較
  • 文字列と文字の等価性
    接頭辞と接尾辞の等価性
  • 文字列の Unicode 表現
  • UTF-8 の表現
    UTF-16 表現
    Unicode のスカラー表現
  • コレクション型
  • コレクションの可変性
  • 配列
  • 配列型省略構文
    空の配列の作成
    デフォルト値を持つ配列の作成
    2つの配列を共にして一つの配列に
    配列リテラルでの配列の作成
    配列へのアクセスと変更
    配列の繰り返し処理
  • セット
  • セット型のハッシュ値
    セット型の構文
    空のセットの作成と初期化
    配列リテラルでセットの作成
    セットへのアクセスと変更
    セットを反復処理
  • セット操作の実行
  • 基本的なセットの操作
    セットの身分と等価性
  • Dictionary
  • Dictionary 型の省略型構文
    空の Dictionary を作成
    Dictionary リテラルで Dictionary の作成
    Dictionary のアクセスと変更
    Dictionary を繰り返し処理
  • フロー制御
  • For-In ループ
  • While ループ
  • While
    Repeat-While
  • 条件文
  • if 文
  • Switch
  • 暗黙の Fallthrough なし
    範囲の一致
    タプル(Tuples)
    値の結合
    Where
    複合した case
  • 制御転送文
  • Continue
  • Break
  • ループ文内の Break
    Switch 文内の Break
    Fallthrough
    ラベル付きの文
    早期終了
    API 利用可能性の確認
  • 関数
  • 関数の定義と呼び出し
  • 関数のパラメータと戻り値
  • パラメータなしの関数
    複数パラメータの関数
    戻り値なしの関数
    複数の戻り値を持つ関数
    optional のタプル型の戻り値
  • 関数引数のラベルとパラメータ名
  • 引数のラベルの指定
    引数ラベルの省略
    デフォルトのパラメータ値
    可変個引数のパラメータ
    In-Out パラメータ
  • 関数型
  • 関数型の使用
    パラメータ型としての関数型
    戻り値の型としての関数型
    入れ子になった関数
  • クロージャ
  • クロージャ式
  • ソートするメソッド
    クロージャ式の構文
    文脈から型を推論
    単一式クロージャからの暗黙的戻り値
    引数名の省略
    演算子メソッド
    後続クロージャ
    値のキャプチャ
    クロージャは参照型
    クロージャのエスケープ
    オートクロージャ
  • 列挙型
  • 列挙型の構文
    switch 文で列挙型の値の一致
    関連する値
  • 生の値
  • 暗黙に割り当てられた生の値
    生の値からの初期化
    再帰的な列挙型
  • クラスと構造体
  • クラスと構造体を比較
  • 定義の構文
    クラスと構造体のインスタンス
    プロパティにアクセス
    構造体型のためのメンバー化イニシャライザ
    構造体と列挙型は値型
  • クラスは参照型
  • ID 演算子
    ポインタ
    クラスと構造体の間の選択
    文字列、配列、辞書の代入とコピーの動作
  • プロパティ
  • 格納されたプロパティ
  • 定数構造体インスタンスの格納されたプロパティ
    遅延した格納されたプロパティ
    格納されたプロパティとインスタンス変数
  • 計算されたプロパティ
  • セッタ宣言の省略形
    読み取り専用の計算されたプロパティ
    プロパティ監視者
    グローバルとローカル変数
  • 型プロパティ
  • 型プロパティの構文
    型プロパティの照会と設定
  • メソッド
  • インスタンスメソッド
  • self プロパティ
    インスタンスメソッド内から値の型を変更
    変異メソッド内で self に代入
    型メソッド
  • サブスクリプト
  • サブスクリプトの構文
    サブスクリプトの使用法
    サブスクリプトのオプション
  • 継承
  • 基本クラスの定義
    サブクラス化
  • オーバーライド(上書き)
  • スーパークラスメソッド、プロパティ、サブスクリプトへのアクセス
    オーバーライドするメソッド
  • オーバーライドするプロパティ
  • プロパティのゲッタとセッタのオーバーライド
    プロパティ監視者のオーバーライド
    オーバーライドの防止
  • 初期化
  • 格納されたプロパティの初期値を設定
  • イニシャライザ
    デフォルトのプロパティ値
  • 初期化のカスタマイズ
  • 初期化パラメータ
    パラメータ名と引数ラベル
    引数ラベルのないイニシャライザのパラメータ
    Optional のプロパティ型
    初期化中に定数プロパティへの代入
  • デフォルトのイニシャライザ
  • 構造体型のためのメンバ化イニシャライザ
    値型のイニシャライザデリゲート
  • クラスの継承と初期化
  • 指定イニシャライザとコンビニエンスイニシャライザ
    指定とコンビニエンスイニシャライザの構文
    クラス型のイニシャライザデリゲート
    二相の初期化
    イニシャライザ継承とオーバーライド
    自動イニシャライザの継承
    実際の指定とコンビニエンスイニシャライザ
  • 失敗可能イニシャライザ
  • 生の値を持つ列挙型のための失敗可能イニシャライザ
    初期化失敗の伝播
    失敗可能イニシャライザのオーバーライド
    init! の失敗可能イニシャライザ
    必須イニシャライザ
    クロージャや関数でのデフォルトのプロパティ値設定
  • デイニシャライザ
  • デイニシャライザはどのように働くか
    作動中のデイニシャライザ
  • Optional の連鎖
  • 強制開封の代替としての Optional の連鎖
    Optional の連鎖のモデルクラスの定義
    Optional の連鎖を使用したプロパティへのアクセス
    Optional の連鎖を通じてメソッドを呼び出す
  • Optional の連鎖を通じてサブスクリプトへのアクセス
  • Optional 型のサブスクリプトにアクセス
    連鎖の複数レベルのリンク
    optional の戻り値を持つメソッドでの連鎖
  • エラー処理
  • エラーの表現と Throw
    エラーの処理
    throw 関数を使用したエラーの伝播
    Do-Catch を使用したエラー処理
    エラー をOptional の値に変換
    エラー伝播を無効に
    クリーンアップアクションの指定
  • 型キャスト
  • 型キャストのためのクラス階層の定義
    型のチェック
    ダウンキャスト
  • Any と AnyObjecgt 用の型キャスティング
  • ネストした型
  • 実際のネストした型
    ネストした型への参照
  • 拡張機能
  • 拡張機能の構文
    計算されたプロパティ
    イニシャライザ
  • メソッド
  • 変異インスタンスメソッド
    サブスクリプト
    ネストした型
  • プロトコル
  • プロトコルの構文
    プロパティの要件
    メソッドの要件
    変異メソッドの要件
  • イニシャライザの要件
  • プロトコルイニシャライザ要件のクラス実装
    失敗可能イニシャライザの要件
    型としてのプロトコル
    デリゲート
  • 拡張機能を持つプロトコル準拠の追加
  • 拡張機能を持つプロトコルの採用を宣言
    プロトコル型のコレクション
    プロトコルの継承
    クラス専用プロトコル
    プロトコルの構成
    プロトコル準拠の確認
    Optional のプロトコル要件
  • プロトコル拡張機能
  • デフォルトの実装の提供
    プロトコル拡張機能に制約を追加
  • ジェネリック(汎用)
  • 汎用が解決する問題
    汎用関数
    型パラメータ
    型パラメータの命名
    汎用の型
    汎用型の拡張
  • 型の制約
  • 型制約の構文
    実際の型の制約
  • 関連型
  • 実際の関連型
    既存の型を拡張して関連型を指定
    型注釈を使用して関連型を制約
    汎用の Where 句
    汎用の Where 句を含む拡張機能
    関連する型と汎用の Where 句
    汎用のサブスクリプト
  • 自動参照カウント
  • どのように ARC は働くか
    実際の ARC
    クラスインスタンス間の強い循環参照
  • クラスインスタンス間の強い循環参照の解決
  • 弱い参照
    所有されていない参照
    所有されていない参照と暗黙に開封された Optional のプロパティ
    クロージャの strong な循環参照
  • クロージャの strong な循環参照の解決
  • キャプチャリストの定義
    弱い参照と所有されていない参照
  • メモリの安全性
  • メモリへのアクセス競合の理解
    メモリアクセスの特徴
    In-Out パラメータへのアクセスの競合
    メソッド内の Self へのアクセスの競合
    プロパティへのアクセスの競合
  • アクセス制御
  • モジュールとソースファイル
  • アクセスレベル
  • アクセスレベルの全体的指針
    デフォルトのアクセスレベル
    ターゲット一つのアプリのアクセスレベル
    フレームワークのアクセスレベル
    ユニットテストのターゲット用のアクセスレベル
    アクセス制御の構文
  • カスタム型
  • タプル型
    関数型
  • 列挙型
  • 生の値と関連する値
    ネストした型
    サブクラス化
  • 定数、変数、プロパティ、およびサブスクリプト
  • ゲッタとセッタ
  • イニシャライザ
  • デフォルトのイニシャライザ
    構造体型用のデフォルトメンバ化イニシャライザ
  • プロトコル
  • プロトコルの継承
    プロトコルの準拠
  • 拡張機能
  • 拡張機能の private メンバ
    汎用
    型エイリアス
  • 高度な演算子
  • ビット単位演算子
  • ビット単位の NOT 演算子
    ビット単位の AND 演算子
    ビット単位の OR 演算子
    ビット単位の XOR 演算子
  • ビット単位の左と右シフト演算子
  • 符号なし整数のシフト動作
    符号付き整数のシフト動作
  • オーバーフロー演算子
  • 値オーバーフロー
    優先順位と結合性
  • 演算子メソッド
  • 接頭辞と接尾辞演算子
    複合代入演算子
    等価演算子
  • カスタム演算子
  • カスタム挿入辞演算子の優先順位
  • 言語のガイド(Part III)
  • 言語リファレンスについて
  • 文法の読み方
  • 語彙の構造
  • 空白とコメント
    識別子
    キーワードと句読点
  • リテラル
  • 整数リテラル
    浮動小数点リテラル
    文字列のリテラル
    演算子

  • 型注釈
    型識別子
    タプル型
    関数型
    エスケープしないクロージャの制限事項
    配列型
    辞書型
    Optional の型
    暗黙に開封された Optional の型
    プロトコル構成の型
    メタタイプ型
    型の継承句
    型の推測

  • 接頭辞式
    Try 演算子
  • 二項式
  • 代入演算子
    三項条件演算子
    型キャスト演算子
  • 一次式
  • リテラル式
    Self 式
    スーパークラス式
  • クロージャ式
  • キャプチャ・リスト
    暗黙のメンバ式
    括弧で囲まれた式
    タプル式
    ワイルドカード式
    キーパス式
    セレクタ式
    キーパス文字列式
  • 接尾辞の式
  • 関数呼び出し式
    イニシャライザ式
    明示的なメンバ式
    接尾辞の Self 式
    サブスクリプト 式
    強制値の式
    Optional の連鎖式

  • ループ文
  • For-In 文
    While 文
    Repeat-While 文
  • 分岐文
  • if 文
    Guard 文
  • switch 文
  • switch 文は、網羅的である必要あり
    実行が暗黙的に case を Fall Through しない
    ラベル付き文
  • 制御転送文
  • break 文
    continue 文
    fallthrough 文
    return 文
    throw 文
    defer 文
    do 文
  • コンパイラ制御文
  • 条件コンパイルブロック
    行制御文
    利用可能条件
  • 宣言
  • トップレベルのコード
    コードブロック
    Import 宣言
    ­定数の宣言
  • 変数の宣言
  • 格納された変数と格納された変数のプロパティ
    計算された変数と計算されたプロパティ
    格納された変数監視者とプロパティの監視者
    型変数プロパティ
    型エイリアス宣言
  • 関数の宣言
  • パラメータ名
    In-Out パラメータ
    パラメータの特殊な種類
    メソッドの特殊な種類
    Throw する関数とメソッド
    Rethrow する関数とメソッド
    決して返さない関数
  • 列挙型の宣言
  • 任意の型の case を列挙
  • 間接による列挙
    生の値型の case を列挙
    列挙型 case へのアクセス
    構造体の宣言
    クラスの宣言
  • プロトコルの宣言
  • プロトコル・プロパティ宣言
    プロトコル・メソッド宣言
    プロトコル・イニシャライザ宣言
    プロトコル・サブスクリプト宣言
    プロトコルに関連した型の宣言
  • イニシャライザ宣言
  • 失敗可能イニシャライザ
    デイニシャライザ宣言
    拡張機能の宣言
    サブスクリプト宣言
    演算子の宣言
    優先順位グループ宣言
  • 宣言修飾子
  • アクセス制御レベル
  • 属性
  • 宣言の属性
  • インターフェイスビルダーで使われる宣言属性
    型の属性
  • パターン
  • ワイルドカードパターン
    識別子パターン
    値結合パターン
    タプルパターン
    列挙型 case パターン
    Optional のパターン
    型キャストパターン
    式のパターン
  • 汎用パラメータと引数
  • 汎用パラメータ句
  • 汎用の where 句
    汎用引数句
  • 文法のまとめ
  • 語彙の構造



    宣言
    属性
    パターン
    汎用パラメータと引数
  • マニュアルの変更履歴
  • 変更履歴












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)