Optional の連鎖


Optional の連鎖 は、今は nil かもしれない optional のプロパティ、メソッド、およびサブスクリプトを照会し、呼び出すためのプロセスです。optional が値を含んでいる場合は、プロパティ、メソッド、またはサブスクリプトの呼び出しは成功します。optional が nil の場合、プロパティ、メソッド、またはサブスクリプト呼び出しは nil を返します。複数の照会を一緒に連鎖することができ、全体の連鎖は、連鎖内のどれかのリンクが nil の場合、綺麗に失敗します。



注意: Swift における Optional の連鎖は、Objective-C における nil のメッセージに似ていますが、全ての型で働き、そして、成功したか失敗したかを確認することができる点が違います。


強制開封の代替としての Optional の連鎖


optional が nil でない場合、プロパティ、メソッドまたはサブスクリプトを呼び出したい optional の値の後に疑問符(?) を置くことで、optional の連鎖を指定できます。これは、その値の開封を強制するために、optional の値の後に感嘆符(!) を置くことに非常に似ています。主な違いは、optional が nil の時には optional の連鎖が綺麗に失敗するのに対し、強制開封は、optional が nil の時実行時エラーを引き起こす事です。


optional の連鎖が nil 値で呼び出されるという事実を反映するために、optional の連鎖呼び出しの結果は、照会しているプロパティー、メソッド、またはサブスクリプトが optional でない値を返しても、常に optional の値になります。この optional の戻り値を使用して、optional の連鎖の呼び出しが成功したか (返された optional に値が含まれているか)、連鎖の nil 値のために成功しなかったかどうか (返された optional 値が nil か) をチェックすることができます。


具体的には、optional の連鎖の呼び出しの結果は、期待される戻り値と同じ型ですが、optional に包まれています。通常は Int として返るプロパティは optional の連鎖を通してアクセスする時 Int? で返ります。


以下に挙げるいくつかのコードスニペットでは、どのように optional の 連鎖が強制開封とは異なり、成功を確認できるように説明しています。


まず、PersonResidence と言う2つのクラスが定義されています。


  1. class Person {
  2.         var residence: Residence?
  3. }
  4. class Residence {
  5.         var numberOfRooms = 1
  6. }


Residence インスタンスは 1 の デフォルト値を持つ numberOfRooms と言う一つの Int プロパティを持っています。Person インスタンスは Residence? 型の optional の residence プロパティーを持っています


新しい Person インスタンスを作成した場合、その residence プロパティは、デフォルトでは optional であることによって、nil に初期化されます。下に示すコードでは、johnnilresidence プロパティ値を持っています。


let john = Person()



その値の開封を強制的に行うため、residence の後に感嘆符を置くことによって、この person の residencenumberOfRooms プロパティにアクセスしようとすると、開封するべき residence 値がないので、実行時エラーを引き起こします:


  1. let roomCount = john.residence!.numberOfRooms
  2. // this triggers a runtime error


john.residencenil でない値を有しており、部屋の適切な数を含む Int 値に roomCount を設定したときに上記のコードは、成功します。しかし、上に示したように residence は、nil なので、このコードは常に実行時エラーを引き起こします。


Optional の連鎖は numberOfRooms の値にアクセスする別の方法を提供します。optional の連鎖を使用するには、感嘆符(!)の代わりに疑問符(?)を使用して下さい。


  1. if let roomCount = john.residence?.numberOfRooms {
  2.         print("John's residence has \(roomCount) room(s).")
  3. } else {
  4.         print("Unable to retrieve the number of rooms.")
  5. }
  6. // prints "Unable to retrieve the number of rooms."


これは、Swift に、optional の residence プロパティの"連鎖" と residence が存在する場合、numberOfRooms の値を取得するように指示します。


numberOfRooms にアクセスする試みが失敗する可能性があるため、optional の連鎖の試みは、Int? 型または "optional Int" 型の値を返します。residencenil の時、上記の例のように、この optional の Int はまた、numberOfRooms にアクセスできなかったという事実を反映して、nil になります。optional の Int は、整数を開封して optional でない値を roomCount 変数に代入するための optional の結合によってアクセスされます。


これは、numberOfRooms が optional でない Int であったとしても正しいことに注意してください。それが、optional の連鎖を介して照会されているという事実は、numberOfRooms への呼び出しは常に Int の代わりに Int? を返すことを意味します。


Residence インスタンスを、john.residence に代入でき、そのためそれはもはや nil 値を持ちません。


john.residence = Residence()



john.residence は今や、むしろ nil よりも、実際の Residence インスタンスを含んでいます。以前と同じ optional の連鎖で numberOfRooms にアクセスしようとすると、それは今や numberOfRooms のデフォルト値 1 を含む Int? を返します。


  1. if let roomCount = john.residence?.numberOfRooms {
  2.         print("John's residence has \(roomCount) room(s).")
  3. } else {
  4.         print("Unable to retrieve the number of rooms.")
  5. }
  6. // prints "John's residence has 1 room(s)."


Optional の連鎖のモデルクラスの定義


一つ以上のレベルの深さのプロパティ、メソッド、およびサブスクリプトへの呼び出しで、optional の連鎖を使用できます。これは、相互に関連する型の複雑なモデル内のサブプロパティに貫いていき、それらのサブプロパティのプロパティ、メソッド、およびサブスクリプトにアクセスできるかどうかを確認できます。


以下のコードスニペットは、マルチレベルの optional の連鎖の例を含む、いくつかの後の例で使用する、4つのモデルクラスを定義しています。これらのクラスは、プロパティ、メソッド、およびサブスクリプトと関連した、RoomAddress クラスを追加することにより、上記に示した PersonResidence モデルを発展させます。


Person クラスは、以前と同じ方法で定義されます。


  1. class Person {
  2.         var residence: Residence?
  3. }


Residence クラスは、以前よりも複雑です。今回は、Residence クラスは [Room] 型の空の配列で初期化される、rooms と言う変数プロパティを定義しています。


  1. class Residence {
  2.         var rooms = [Room]()
  3.         var numberOfRooms: Int {
  4.                 return rooms.count
  5.         }
  6.         subscript(i: Int) -> Room {
  7.                 get {
  8.                 return rooms[i]
  9.                 }
  10.                 set {
  11.                 rooms[i] = newValue
  12.                 }
  13.         }
  14.         func printNumberOfRooms() {
  15.                 print("The number of rooms is \(numberOfRooms)")
  16.         }
  17.         var address: Address?
  18. }


Residence のこのバージョンは、Room インスタンスの配列を格納しているため、その numberOfRooms プロパティは格納されたプロパティではなく、計算されたプロパティとして実装されています。計算された numberOfRooms プロパティは、単に rooms 配列から count プロパティの値を返します。


その rooms 配列にアクセスする近道として、このバージョンの Residence では、rooms 配列の要求された索引の room へのアクセスを提供する読み書きできるサブスクリプトを提供しています。


Residence のこのバージョンはまた、printNumberOfRooms と言うメソッドも提供し、単に residence の部屋 (rooms) の数を印刷します。


最後に、Residentt は、Address? の型で address と言う optional のプロパティを定義しています。このプロパティの Address クラスの型は以下に定義されています。


rooms 配列に使用される Room クラスは、name と言う1つのプロパティと、そのプロパティを適切な room の name(部屋の名前) に設定するイニシャライザを持つ単純なクラスです。


  1. class Room {
  2.         let name: String
  3.         init(name: String) { self.name = name }
  4. }


このモデルでの最後のクラスは、Address と言います。このクラスには、String? 型の3つの optional のプロパティがあります。最初の2つのプロパティ、buildingNamebuildingNumber は、address(住所) の一部として特定の建物を識別するための別の方法です。第3のプロパティ、street は、そのアドレスの通りに名前を付けるために使用されます。


  1. class Address {
  2.         var buildingName: String?
  3.         var buildingNumber: String?
  4.         var street: String?
  5.         func buildingIdentifier() -> String? {
  6.                 if let buildingNumber = buildingNumber, let street = street {
  7.                         return "\(buildingNumber) \(street)"
  8.                 } else if buildingNumber != nil {
  9.                         return buildingNumber
  10.                 } else {
  11.                         return nil
  12.                 }
  13.         }
  14. }


Address クラスはまた、String? の戻り値の型を持っている buildingIdentifier() と言うメソッドも提供します。このメソッドは、address のプロパティをチェックし、それが値を持っていれば、buildingName を返し、または buildingNumber と繋ぎ合わされた street の両方が値を持っている場合は、それらを返し、そうでなければ nil を返します。


Optional の連鎖を使用したプロパティへのアクセス


強制開封の代替としての Optional の連鎖 で示したように、optional の値を持つプロパティにアクセスするには、optional の連鎖を使用でき、またそのプロパティへのアクセスが成功したかどうかをチェックできます。


新しい Person インスタンスを作成するには上記のように定義されたクラスを使用し、以前のようにその numberOfRooms プロパティにアクセスしてみて下さい。


  1. let john = Person()
  2. if let roomCount = john.residence?.numberOfRooms {
  3.         print("John's residence has \(roomCount) room(s).")
  4. } else {
  5.         print("Unable to retrieve the number of rooms.")
  6. }
  7. // prints "Unable to retrieve the number of rooms."


john.residencenil であるため、この optional の連鎖の呼び出しは以前と同じように失敗します。


また、optional の連鎖を通じてプロパティの値を設定しようとすることもできます:


  1. let someAddress = Address()
  2. someAddress.buildingNumber = "29"
  3. someAddress.street = "Acacia Road"
  4. john.residence?.address = someAddress


この例では、john.residence は現在 nil であるため、john.residenceaddress プロパティを設定しようとする試みは失敗します。


代入は、optional の連鎖の一部であり、= 演算子の右辺のコードのいずれも評価されていないことを意味します。以前の例では、定数にアクセスするのは全く副作用がないため、その someAddress が評価されることは全くない事を見ることは容易ではありません。以下のリストは同じ代入を行いますが、それは address を作成する関数を使用しています。"関数が呼び出されました" と関数は、値を返す前に印刷し、= 演算子の右辺が評価されたかどうかを確認することができます。


  1. func createAddress() -> Address {
  2.         print("Function was called.")
  3.         let someAddress = Address()
  4.         someAddress.buildingNumber = "29"
  5.         someAddress.street = "Acacia Road"
  6.         return someAddress
  7. }
  8. john.residence?.address = createAddress()

何も印刷されないので、createAddress() 関数が呼び出されていないと言うことができます。


Optional の連鎖を通じてメソッドを呼び出す


optional の値でメソッドを呼び出すために、またそのメソッドの呼び出しが成功したかどうかを確認するために、optional の連鎖を使用できます。そのメソッドが戻り値を定義していない場合でも、これを行うことができます。


Residence クラスでの printNumberOfRooms() メソッドは numberOfRooms の現在の値を出力します。ここでこのメソッドがどのように見えるかを示します:


  1. func printNumberOfRooms() {
  2.         print("The number of rooms is \(numberOfRooms)")
  3. }


このメソッドは、戻り値の型を指定していません。しかし、戻り値なしの関数 で説明したように、戻り値の型のない関数やメソッドは、Void 型の暗黙の戻り値の型を持っています。これは、それらが () の値、または空のタプルを返すことを意味します。


Optional の連鎖での optional の値でこのメソッドを呼び出すと、optional の連鎖を通じて呼び出されたとき、戻り値は常に optional 型のものであるため、このメソッドの戻り値の型は、Void ではなく、Void? になります。このメソッドが、戻り値を自分で定義していなくても、printNumberOfRooms() メソッドを呼び出すことができたかどうかを確認するために if 文を使えるようになります。printNumberOfRooms 呼び出しからの戻り値と、nil を比較し、そのメソッド呼び出しが成功したかどうかを確認します。


  1. if john.residence?.printNumberOfRooms() != nil {
  2.         print("It was possible to print the number of rooms.")
  3. } else {
  4.         print("It was not possible to print the number of rooms.")
  5. }
  6. // prints "It was not possible to print the number of rooms."


optional の連鎖を通じてプロパティを設定しようとする場合も同様です。Optional の連鎖を使用したプロパティへのアクセス での上記の例は residence プロパティが nil であっても、john.residenceaddress 値を設定しようとします。optional の連鎖を通じてプロパティを設定しようとしても、プロパティが正常に設定されたかどうかを確認するため、nil に対して比較することができる Void? 型の値を返します。


  1. if (john.residence?.address = someAddress) != nil {
  2.         print("It was possible to set the address.")
  3. } else {
  4.         print("It was not possible to set the address.")
  5. }
  6. // prints "It was not possible to set the address."



Optional の連鎖を通じてサブスクリプトへのアクセス


Optional の連鎖を使用して、optional の値のサブスクリプトから値を取得し設定する事が可能で、そのサブスクリプトの呼び出しが成功したかどうかをチェックできます。



注意: Optional の連鎖を通じて optional の値のサブスクリプトにアクセスする時は、サブスクリプトの括弧の後ではなく 前に 疑問符を置いて下さい。optional の連鎖の疑問符は常に optional の式の一部の直後に続きます。


以下の例は、Residence クラスで定義されたサブスクリプトを使用して john.residence プロパティの rooms 配列内の最初の room の名前を取得しようとします。 john.residence は現在 nil のため、サブスクリプトの呼び出しは失敗します。


  1. if let firstRoomName = john.residence?[0].name {
  2.         print("The first room name is \(firstRoomName).")
  3. } else {
  4.         print("Unable to retrieve the first room name.")
  5. }
  6. // prints "Unable to retrieve the first room name."


john.residence は optional の連鎖が試みられている optional の値であるため、このサブスクリプトの呼び出しでの optional の連鎖の疑問符は、サブスクリプトの括弧の前に、john.residence の直後に置かれています。


同様に、optional の連鎖でサブスクリプトを通じて新しい値を設定しようとすることができます。


john.residence?[0] = Room(name: "Bathroom")



residence は現在 nil のため、このサブスクリプトを設定しようとする試みは、失敗します。


その rooms の配列内の1つ以上の Room インスタンスと、john.residence に、実際の Residence インスタンスを作成し、代入する場合は、optional の連鎖を通じて room 配列内の実際のアイテムにアクセスするには Residence サブスクリプトを使用できます。


  1. let johnsHouse = Residence()
  2. johnsHouse.rooms.append(Room(name: "Living Room"))
  3. johnsHouse.rooms.append(Room(name: "Kitchen"))
  4. john.residence = johnsHouse
  5. if let firstRoomName = john.residence?[0].name {
  6.         print("The first room name is \(firstRoomName).")
  7. } else {
  8.         print("Unable to retrieve the first room name.")
  9. }
  10. // prints "The first room name is Living Room."



Optional 型のサブスクリプトにアクセス


サブスクリプトが、Swift の Dictionary 型のキーサブスクリプトのような、optional 型の値を返す場合、その optional の戻り値上に連鎖するためにサブスクリプトの閉じ括弧の 後に 疑問符を書きます:


  1. var testScores = ["Dave": [86, 82, 84], "Bev": [79, 94, 81]]
  2. testScores["Dave"]?[0] = 91
  3. testScores["Bev"]?[0] += 1
  4. testScores["Brian"]?[0] = 72
  5. // the "Dave" array is now [91, 82, 84] and the "Bev" array is now [80, 94, 81]


上記の例では、Int 値の配列に String キーをマッピングする2つのキー値のペアを含む testScores と言う dictionary を定義しています。この例では、"Dave" 配列の最初の項目を 91 に設定するため optional の連鎖を使用し、"Bev" 配列の最初の項目を 1 増分し、そして "Brian" のキーの配列内の最初の項目を設定しようとします。testScores の dictionary は "Dave""Bev" のキーを含んでいるため、最初の2つの呼び出しは、成功します。testScores の dictionary は "Brian" のキーを含んでいないため、第3の呼び出しは失敗します。



連鎖の複数レベルのリンク


より深いモデル内のプロパティ、メソッド、およびサブスクリプトに貫き通して行くには、optional の連鎖の複数のレベルを一緒にリンクできます。しかし、optional の連鎖の複数のレベルは、返された値への optional 性のより深いレベルを追加しません。


それを別の言い方をすると:


そのため:


下記の例は、johnresidence プロパティの address プロパティの street プロパティにアクセスしようとしています。ここでは使われている optional の連鎖には 2つの レベルがあり、どちらも optional 型の、residenceaddress プロパティを通じて連鎖します。


  1. if let johnsStreet = john.residence?.address?.street {
  2.         print("John's street name is \(johnsStreet).")
  3. } else {
  4.         print("Unable to retrieve the address.")
  5. }
  6. // prints "Unable to retrieve the address."


john.residence の値は、現在有効な Residence のインスタンスを含んでいます。しかし、john.residence.address の値は、現在 nil です。このことから、john.residence?.address?.street への呼び出しは失敗します。


上記の例では、street プロパティの値を取得しようとしていることに注意してください。このプロパティの型は String? です。john.residence?.address?.street の戻り値は、そのため、optional の連鎖の2つのレベルが、プロパティの基本となる optional の型に加えて適用されているにもかかわらず、String? です。


john.residence.address の値として実際の Address インスタンスを設定し、address の street プロパティの実際の値を設定する場合は、複数レベルの optional の連鎖を通じて street プロパティの値にアクセスできます。


  1. let johnsAddress = Address()
  2. johnsAddress.buildingName = "The Larches"
  3. johnsAddress.street = "Laurel Street"
  4. john.residence?.address = johnsAddress
  5. if let johnsStreet = john.residence?.address?.street {
  6.         print("John's street name is \(johnsStreet).")
  7. } else {
  8.         print("Unable to retrieve the address.")
  9. }
  10. // prints "John's street name is Laurel Street."


この例では、john.residence の値が現在有効な Residence インスタンスを含んでいるため、john.residenceaddress プロパティを設定しようとする試みは、成功します。


optional の戻り値を持つメソッドでの連鎖


以前の例では、optional の連鎖を通じて、optional の型のプロパティの値を取得する方法を示しました。また、optional の連鎖を使用して optional 型の値を返すメソッドを呼び出し、また必要に応じて、そのメソッドの戻り値上で連鎖できます。


以下の例は、optional の連鎖を通じて Address クラスの buildingIdentifier() メソッドを呼び出します。このメソッドは、String? 型の値を返します。前述したように、optional の連鎖をした後、このメソッド呼び出しの究極の戻り値の型も String? です。


  1. if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
  2.         print("John's building identifier is \(buildingIdentifier).")
  3. }
  4. // prints "John's building identifier is The Larches."


このメソッドの戻り値で更なる optional の連鎖を実行したい場合は、メソッドの括弧の 後に、optional の連鎖の疑問符を書いて下さい。


  1. if let beginsWithThe =
  2.         john.residence?.address?.buildingIdentifier()?.hasPrefix("The") {
  3.                 if beginsWithThe {
  4.                         print("John's building identifier begins with \"The\".")
  5.                 } else {
  6.                         print("John's building identifier does not begin with \"The\".")
  7.                 }
  8. }
  9. // prints "John's building identifier begins with "The"."


注意: 上記の例では、optional の連鎖の値が buildingIdentifier() メソッドの戻り値であり、buildingIdentifier() メソッド自体ではないため、optional の連鎖の疑問符を括弧の後に置きます。





前:デイニシャライザ 次:エラー処理
目次
Xcode 10 の新機能

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 句
    汎用引数句
  • 文法のまとめ
  • 語彙の構造



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