Swift 5.0 日本語化計画 : Swift 5.0


コレクション型


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


CollectionTypes_intro_2x


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



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


コレクションの可変性


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


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


配列


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


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

Foundation と Cocoa で Array を使う詳細については、Array と NSArray 間のブリッジ をご覧になって下さい。


配列型省略構文


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" と書いて、配列の末尾に項目を追加しようとすると実行時エラーが発生します。


また、値の置換 Set が交換する範囲とは異なる長さであっても、一度に値の範囲を変更するためにサブスクリプト構文を使用することもできます。以下の例では、"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


配列の繰り返し処理


配列内の値の Set 全体を 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 ループ を参照してください。



Set


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



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

Foundation と Cocoa で Set を使用する詳細については、Set と NSSet の間のブリッジ を参照してください。


Set 型のハッシュ値


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


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


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

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

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


Set 型の構文


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



空の Set の作成と初期化


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


  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> であるることが推定されます。

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


  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>


配列リテラルで Set の作成


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


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


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


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



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


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



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



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



Set へのアクセスと変更


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


Set 内の項目数を調べるには、その読み取り専用の 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."


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


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


Set の remove(_:) メソッドを呼び出して Set から項目を削除すると、それが Set のメンバーであればその項目を削除し、削除された値を返し、または Set が値を含んでいない場合は nil を返します。その他として、Set 内のすべての項目は、その 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."


Set が、特定の項目を含んでいるかどうかを確認するには、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."


Set を反復処理


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


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


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


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


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


Set 操作の実行


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


基本的な Set の操作


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


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]


Set の身分と等価性


以下の図は、3組の Set 、すなわち a,b 及び c を示し、 Set 間の共有要素を表す領域を重ねて示しています。 ab のすべての要素を含んでいるため、 Set a は、 Set bスーパー Set です。逆に、b のすべての要素が a に含まれているため、 Set b は Set aサブ Set です。共通の要素を共有しないため、 Set b と Set 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 の型は、 Set の値型のように、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 リテラルでは、各キー値のペアのキーと値とは、コロンで区切られます。キー値のペアは、角括弧のペアで囲まれ、カンマで区切られた、リストとして書かれます。


[: , : , : ]


以下の例は、国際空港の名前を格納するための 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() メソッドを使用します。


前:文字列と文字 次:フロー制御

<BETA SOFTWARE>
このドキュメントには、開発中の API または技術に関する予備的な情報が含まれています。この情報は変更されることがあり、このドキュメントに従って実装されたソフトウェアは、最終的なオペレーティングシステムソフトウェアでテストする必要があります。

Apple の Beta ソフトウエアについての詳細


















トップへ












トップへ












トップへ












トップへ
目次
Xcode 10 の新機能

Swift について
Swift と Cocoa と Objective-C (obsolete)
Swift Blog より (obsolete)

SwiftLogo
  • Swift 5.0 全メニュー


  • Swift へようこそ

  • Swift 言語のガイド
  • 基本演算子
  • 文字列と文字
  • コレクション型
  • フロー制御
  • 関数
  • クロージャ
  • 列挙型
  • クラスと構造体
  • プロパティ
  • メソッド
  • サブスクリプト
  • 継承
  • 初期化
  • デイニシャライザ
  • Optional の連鎖
  • エラー処理
  • 型キャスト
  • ネストした型
  • 拡張機能
  • プロトコル
  • ジェネリック(汎用)
  • 自動参照カウント
  • メモリの安全性
  • アクセス制御
  • 高度な演算子

  • 言語リファレンス

  • マニュアルの変更履歴













  • トップへ












    トップへ












    トップへ












    トップへ












    トップへ












    トップへ












    トップへ












    トップへ












    トップへ












    トップへ