Swift では、式には4種類があります:接頭辞式、二項式、一次式、そして接尾辞式です。式を評価すると値を返し、副作用を起こすか、またはその両方。


接頭辞と二項式を使用すると、演算子は、より小さな式になります。一次式は、概念的には、式の最も簡単な種類であり、それらは値にアクセスする方法を提供します。接尾辞式は、接頭辞と二項式のように、関数呼び出しとメンバへのアクセスのような接尾辞を使用して、より複雑な式をビルドできます。それぞれの種類の式は、以下のセクションで詳細に記載しました。


式の文法

expressiontry-operator opt ­prefix-expression ­binary-expressions ­opt
expression-listexpressionexpression ­, ­expression-list



接頭辞式


接頭辞式 は式に、optional の接頭辞演算子を組み合わせたものです。接頭辞演算子は、一つの引数を取り、それらに式が続きます。


これらの演算子の動作については、基本演算子 および 高度な演算子 を参照してください。


Swift 標準ライブラリで提供される演算子については、演算子の宣言 を参照してください。


標準ライブラリの演算子に加え、関数の呼び出し式への in-out 引数として渡される変数の名前の直前に & を使用して下さい。詳細と例を参照するには、In-Out パラメータ をご覧ください。


接頭辞の式の文法

prefix-expressionprefix-operator opt ­postfix-expression
prefix-expressionin-out-expression
in-out-expression identifier



Try 演算子


try 式 はエラーを throw できる式が続く try 演算子で構成されています。これは以下の形式を持っています。


try


optional の try 式は、エラーを throw できる式が続く try? 演算子で構成されています。これは以下の形式を持っています。


try?


がエラーを throw しない場合は、optional の try 式の値は、 の値を含む optional です。それ以外の場合は、optional の try 式の値は nil です。


強制 try 式 は、エラーを throw できる式が続く try! で構成されています。これは以下の形式を持っています:


try!


がエラーを throw した場合、実行時エラーが生まれます。


二項演算子の左側の式が try,try? または try! でマークされている場合、その演算子は二項演算式全体に適用されます。つまり、演算子の適用範囲を明示するために、括弧を使用できる、と言う事です。


  1. sum = try someThrowingFunction() + anotherThrowingFunction()    // try applies to both function calls
  2. sum = try (someThrowingFunction() + anotherThrowingFunction()) // try applies to both function calls
  3. sum = (try someThrowingFunction()) + anotherThrowingFunction() // Error: try applies only to the first function call


二項演算子が代入演算子でないか、try 式が括弧で囲まれていない場合は、try 式は、二項演算子の右側に表示できません。


詳細および try,try? 及び try! を使用する方法の例については、エラー処理 を参照してください。


TRY 式の文法

try-operatortry | try ? | try ­!



二項式


二項式 は、その左側と右側の引数として取る式と挿入辞の二項演算子を組み合わせます。これは以下の形式があります:




これらの演算子の動作については、基本演算子高度な演算子 を参照してください。


Swift 標準ライブラリで提供される演算子についての詳細は、演算子の宣言 を参照してください。


注意: 解析時に、二項演算子で構成される式はフラットなリストとして表されます。このリストは、演算子の優先順位を適用することにより、ツリーに変換されます。たとえば、式 2 + 3 * 5 は、最初、2 ,+ ,3 ,* , および 5 の5項目のフラットリストとして理解されます。このプロセスはこれを (2+(3*5)) のツリーに変換します。


二項式の文法

binary-expressionbinary-operator prefix-expression
­ binary-expressionassignment-operator ­try-operator opt prefix-expression
­ binary-expressionconditional-operator ­try-operator opt ­ prefix-expression
­ binary-expressiontype-casting-operator
­ binary-expressionsbinary-expression ­binary-expressions opt



代入演算子


代入演算子 は、与えられた式の新しい値を設定します。これには以下の形式があります:


=



の値は、 を評価して得た値に設定されます。 がタプルの場合は、 は同じ数の要素を持つタプルでなければなりません。(ネストしたタプルも許可されます。) 代入は の対応する部分に の各部分から行われます。例えば:


  1. (a, _, (b, c)) = ("test", 9.45, (12, 3))
  2. // a is "test", b is 12, c is 3, and 9.45 is ignored


代入演算子は、全く値を返しません。


代入演算子の文法

assignment-operator → =



三項条件演算子


­

三項条件演算子 は、条件の値に基づいて、与えられた2つの値の1つに評価されます。これは以下の形式です:


? :



条件true と評価された場合は、条件演算子は最初の式を評価し、その値を返します。それ以外の場合は、第二式を評価し、その値を返します。未使用の式は評価されません。


三項条件演算子を使用する例については、三項条件演算子 を参照してください。


条件演算子の文法

conditional-operator → ? ­­expression ­:



­

型キャスト演算子


型キャスト演算子には4つあり、is 演算子、as 演算子、as? 演算子、そして as! 演算子があります。


それらは、以下のような形式です:


実行時に is 演算子は、 が、指定した にキャストできるかどうかチェックします。 が指定された にキャストできれば true を返します。それ以外の場合は false を返します。


as 演算子は、アップキャストやブリッジのように、キャストが常に成功するとコンパイル時に知られている時、キャストを実行します。アップキャストは、中間変数を使用せずに、その型のスーパータイプのインスタンスとして式を使用できるようになります。以下のアプローチは同じです。


  1. func f(_ any: Any) { print("Function for Any") }
  2. func f(_ int: Int) { print("Function for Int") }
  3. let x = 10
  4. f(x)
  5. // prints "Function for Int"
  6. let y: Any = x
  7. f(y)
  8. // prints "Function for Any"
  9. f(x as Any)
  10. // prints "Function for Any"


ブリッジは、新しいインスタンスを作成する必要なしに、NSString のような、それに対応する Foundation 型の String のように Swift 標準ライブラリ型の式を使用することができます。ブリッジの詳細については、ココアと Objective-C で Swift を使用する(Swift 4.0.3)ココアのデータ型での作業 を参照してください。


as? 演算子は、指定した の条件キャストを実行します。as? 演算子は、指定した の optional を返します。実行時に、キャストが成功した場合、 の値は、optional で包まれ、返されます。そうでない場合、戻り値は nil です。指定した へのキャストが失敗することが保証されているか、成功することが保証されている場合は、コンパイル時エラーが発生します。


as! 演算子は、指定した の強制キャストを実行します。as! 演算子は optional の型 ではなく、指定した の値を返します。キャストが失敗した場合、実行時エラーが発生します。x as! T の動作は、(x as? T)! の動作と同じです。


型キャストの更なる情報と型キャスト演算子を使用する際の例に付いては、型キャスト を参照してください。



型キャスト演算子の文法

type-casting-operatoris type
type-casting-operatoras type
type-casting-operatoras ­? type
type-casting-operatoras ­! ­type



一次式


一次式 は、式の最も基本的な種類です。それらは、接頭辞式、二項式、及び接尾辞式を作るために他のトークンと、組み合わせることができ、それら自体で式として使用できます。



一次式の文法

primary-expressionidentifier generic-argument-clause opt
primary-expressionliteral-expression
­ primary-expressionself-expression
primary-expressionsuperclass-expression
primary-expressionclosure-expression
primary-expressionparenthesized-expression
primary-expressiontuple-expression
primary-expressionimplicit-member-expression
primary-expressionwildcard-expression
primary-expressionkey-path-expression­
primary-expressionselector-expression­
primary-expressionkey-path-string-expression­



リテラル式


リテラル式 は、通常のリテラル (文字列や数字など) か、配列または辞書リテラル、プレイグラウンドリテラル、または以下の特別なリテラルのいずれかで構成されます。


リテラル
#file Stringそれがその中に表示されているファイルの名前。
#line Intその上にそれが表示されている行番号。
#column Intそれが始まる列番号。
#function Stringそれが表示されている宣言の名前。


関数の内部では、#function の値は、その関数の名前であり、メソッドの内部ではそのメソッドの名前であり、プロパティのゲッタまたはセッタの内部では、プロパティの名前であり、initsubscript のような特別なメンバの内部では、そのキーワードの名前であり、またファイルのトップレベルでは、現在のモジュールの名前です。


関数またはメソッドのデフォルト値として使用する場合、デフォルト値の式を呼び出しサイトで評価した場合、特別なリテラルの値が決定されます。


  1. func logFunctionName(string: String = #function) {
  2.         print(string)
  3. }
  4. func myFunction() {
  5.         logFunctionName() // Prints "myFunction()".
  6. }


配列リテラル は、順序付けられた値の集合です。これは以下の形式です:


[, , ]



配列の最後の式は、オプションのカンマで続けることができます。配列リテラルの値は、[T] 型であり、ここで T はその内部の式の型です。複数の型の式がある場合、T は、最も近い一般的なスーパータイプです。空の配列リテラルは、角括弧の空のペアを使用して書かれ、指定した型の空の配列を作成するために使用できます。


var emptyArray: [Double] = []



辞書リテラル は、キーと値のペアの順不同の集合です。これは以下の形式です:


[:,:,]



辞書の最後の式は、オプションのカンマで続けられます。Key は、キー式の型であり、Value はその値の式の型であり、辞書リテラルの値は [Key: Value] 型です。複数の型の式がある場合は、KeyValue は、それぞれの値の最も近い共通のスーパータイプです。空の辞書リテラルは、空の配列リテラルと区別するために、一対の括弧の内側のコロンとして書かれます。([:])。指定したキーと値の型の空の辞書リテラルを作成して空の辞書リテラルを使用できます。


var emptyDictionary: [String: Double] = [:]



プレイグラウンドのリテラル は、プログラムエディタ内部の色、ファイル、または画像のインタラクティブな表現を作成するために Xcode で使用されます。Xcode の外部のプレーンテキストでのプレイグラウンドのリテラルは特別なリテラル構文を用いて表現されます。


Xcode でのプレイグラウンドのリテラルの使用方法については、Xcode のヘルプ > Use playgrounds > Add a literal を参照してください。


リテラル式の文法

literal-expressionliteral
literal-expressionarray-literaldictionary-literal­ | playground-literal
literal-expression#file­ | #line­ | #column | #function

array-literal[ ­array-literal-items opt ­]
array-literal-itemsarray-literal-item ­, opt­ | array-literal-item ­, ­array-literal-items
array-literal-itemexpression­

dictionary-literal[ ­dictionary-literal-items ­] | [­:­]
­ dictionary-literal-itemsdictionary-literal-item­ , optdictionary-literal-item ­, dictionary-literal-items
­ dictionary-literal-itemexpression­ ­: expression­

playground-literal#colorLiteral ( ­red ­: expression­ , ­green­ : ­expression­ ­, ­blue : expression­ ­,­ alpha­:­ expression­­ )
playground-literal#fileLiteral ­( ­resourceName­ : ­expression­­­ )
playground-literal#imageLiteral ­( ­resourceName­ : ­expression­ )



Self 式


self 式は、それが発生する型の現在の型またはインスタンスへの明示的な参照です。これには、以下の形式があります。


イニシャライザ、サブスクリプト、またはインスタンス・メソッドでは、self は、それが発生する型の現在のインスタンスを参照します。型メソッドでは、self は、それが発生する現在の型を参照します。


self 式は、スコープ内に同じ名前の別の変数がある場合、関数のパラメータのように、区別する方法を提供し、メンバにアクセスする際にスコープを指定するために使用されます。例えば:


  1. class SomeClass {
  2.         var greeting: String
  3.         init(greeting: String) {
  4.                 self.greeting = greeting
  5.         }
  6. }


値型の変異メソッドでは、self へのその値型の新しいインスタンスを割り当てることができます。例えば:


  1. struct Point {
  2.         var x = 0.0, y = 0.0
  3.         mutating func moveBy(x deltaX: Double, y deltaY: Double) {
  4.                 self = Point(x: x + deltaX, y: y + deltaY)
  5.         }
  6. }


Self 式の文法

self-expressionself | self-method-expression | self-subscript-expression | self-initializer-expression­
self-method-expressionself ­. identifier
self-subscript-expressionself ­[ function-call-argument-list ­]
­ self-initializer-expressionself ­. ­init



スーパークラス式


スーパークラス式 は、そのスーパークラスと、クラスを相互作用することができます。それは、以下のいずれかの形式です:


最初の形式は、スーパークラスのメンバにアクセスするために使用されます。第2の形式は、スーパークラスのサブスクリプトの実装にアクセスするために使用されます。3番目の形式は、スーパークラスのイニシャライザにアクセスするために使用されます。


サブクラスは、それらのスーパークラスでの実装を利用するメンバ、サブスクリプト、およびイニシャライザの実装で、スーパークラス式を使用できます。


スーパークラス式の文法

superclass-expressionsuperclass-method-expressionsuperclass-subscript-expression­ | superclass-initializer-expression­

superclass-method-expressionsuper ­. ­identifier
­ superclass-subscript-expressionsuper ­[ function-call-argument-list ­]
­ superclass-initializer-expressionsuper ­. ­init



クロージャ式


クロージャ式 は、ラムダ または他のプログラミング言語で 無名関数 としても知られているクロージャを作成します。関数宣言と同様に、クロージャは文を含み、それらが囲む範囲から定数と変数をキャプチャします。これは以下の形式です:


パラメータ は、関数の宣言 で説明したように、関数の宣言におけるパラメータと同じ形式を持っています。


クロージャを、より簡潔に書くことができるいくつかの特別な形式があります。


以下のクロージャ式は等価です。


  1. myFunction { (x: Int, y: Int) -> Int in
  2.         return x + y
  3. }
  4. myFunction { x, y in
  5.         return x + y
  6. }
  7. myFunction { return $0 + $1 }
  8. myFunction { $0 + $1 }


関数の引数としてクロージャを渡す方法については、関数呼び出し式 を参照してください。


クロージャ式は、関数呼び出しの一環としてクロージャをすぐに使用する場合など、変数や定数に格納されなくても使用できます。上記のコードで myFunction に渡されるクロージャ式は、この種のすぐに使用する例です。結果として、クロージャ式がエスケープしているかエスケープしていないかは、その式の周囲のコンテキストによって決まります。クロージャ式がすぐ呼び出されるか、またはエスケープされていない関数の引数として渡された場合、クロージャ式はエスケープしていません。それ以外の場合は、クロージャ式はエスケープしています。


クロージャをエスケープする方法の詳細については、クロージャのエスケープ を参照してください。


キャプチャ・リスト


デフォルトでは、クロージャ式は、その周囲の範囲からそれらの値への強い参照を使って定数や変数をキャプチャします。キャプチャ・リスト を、値がどのようにクロージャでキャプチャされるか、明示的に制御するのに使用できます。


キャプチャ・リストは、パラメータのリストの前に、角括弧で囲まれカンマで区切られた式のリストとして書かれます。キャプチャ・リストを使用する場合、パラメータ名、パラメータ型、戻り値の型を省略している場合でも、in キーワードは使用しなければなりません。


キャプチャ・リストのエントリは、クロージャが作成される時、初期化されます。キャプチャ・リストの各エントリについて、定数は、周囲の範囲内で同じ名前を持つ定数または変数の値に初期化されます。以下のコードの例では、a はキャプチャ・リストに含まれますが、b はそうでなく、それらに異なる動作を与えます。


  1. var a = 0
  2. var b = 0
  3. let closure = { [a] in
  4.         print(a, b)
  5. }
  6. a = 10
  7. b = 10
  8. closure()
  9. // Prints "0 10"


2つの異なる名前のついたもの a と、周囲の範囲内の変数と、クロージャの範囲内の定数で、一つだけの名前の付いた変数の b があります。内側の範囲内の a はクロージャが作成される時、外側の範囲内の a の値で初期化されますが、それらの値は、いかなる特別な方法でも接続されてはいません。これは、外側の範囲の a の値への変化は、内側の範囲内の a の値に影響を与えないことを意味し、またクロージャ内部の a への変更がクロージャ外側の a の値に影響を与えない事を意味します。これとは対照的に、一つだけ b という変数があり、外側の範囲での b であり、クロージャの内側または外側からの変更は、両方の場所から見えます。


キャプチャされた変数の型が参照する意味がある場合は、この区別は見えません。たとえば、以下のコードでは x という名前のついた物が2つあり、外側の範囲内の変数と内側の範囲内での定数ですが、それらの両方とも、参照の意味で同じオブジェクトを参照しています。


  1. class SimpleClass {
  2.         var value: Int = 0
  3. }
  4. var x = SimpleClass()
  5. var y = SimpleClass()
  6. let closure = { [x] in
  7.         print(x.value, y.value)
  8. }
  9. x.value = 10
  10. y.value = 10
  11. closure()
  12. // Prints "10 10"


式の値の型がクラスである場合、弱いまたは所有されない参照で式の値をキャプチャするため、キャプチャ・リストの式を weak または unowned でマークできます。


  1. myFunction { print(self.title) }                                // strong capture
  2. myFunction { [weak self] in print(self!.title) }        // weak capture
  3. myFunction { [unowned self] in print(self.title) }    // unowned capture


また、キャプチャリストの名前の付いた値に任意の式を結合する事もできます。式は、クロージャが作成された時評価され、値は指定された強度でキャプチャされます。例えば:


  1. // Weak capture of "self.parent" as "parent"
  2. myFunction { [weak parent = self.parent] in print(parent!.title) }


クロージャ式の詳細と例については、クロージャ式 を参照してください。キャプチャリストの詳細と例については、クロージャの強い循環参照の解決 を参照してください。



クロージャ式の文法

closure-expression{ ­closure-signature ­opt statements opt ­}

closure-signaturecapture-list opt closure-parameter-clause throws opt function-result ­opt ­in
closure-signaturecapture-list ­in

closure-parameter-clause(­) | (­closure-parameter-list­ | identifier-list
closure-parameter-listclosure-parameter | closure-parameter ­, closure-parameter-list
closure-parameterclosure-parameter-name­ type-annotation opt
closure-parameterclosure-parameter-name­ type-annotation ...­
closure-parameter-nameidentifier­

capture-list capture-list-items ­]
capture-list-itemscapture-list-item | capture-list-item ­, capture-list-items
­ capture-list-itemcapture-specifier ­opt ­ expression
capture-specifierweak­ | unowned | unowned(safe) | unowned(unsafe)



暗黙のメンバ式


暗黙のメンバ式 は、型推論が暗黙の型を決定できる文脈で、列挙型の case や型メソッドのように型のメンバにアクセスするための近道の方法です。これは以下の形式です:


.



例えば:


  1. var x = MyEnumeration.someValue
  2. x = .anotherValue


暗黙のメンバ式の文法

implicit-member-expression → . ­identifier



括弧で囲まれた式


括弧で囲まれた式 は、括弧で囲まれた式で構成されています。明示的にグループ化した式で演算の優先順位を指定するために、括弧を使用できます。グループ化する括弧は、式の型を変更しません。例えば、(1) の型は、単純に Int です。


括弧で囲まれた式の文法

parenthesized-expression( ­expression ­)



タプル式


タプル式 は括弧で囲まれた式の、コンマ区切りのリストで構成されています。それぞれの式は、コロン (:) で区切られた、その前の任意の識別子を持つことができます。これは以下の形式を持っています。


( : , : , )



タプル式はゼロ個の式を含むことができ、または2つ以上の式を含むことができます。カッコ内の単一の式は括弧で囲まれた式です。


注意: 空のタプル式と空のタプル型の両方は Swift では () と書かれます。Void() の型エイリアスなので、それを使用して空のタプル型を書くことができます。しかし、すべての型エイリアスと同様に、Void は常に型です。空のタプル式を記述するためには使用できません。


タプル式の文法

tuple-expression( ) | ( ­tuple-element , ­tuple-element-list ­)
tuple-element-listtuple-element | tuple-element , ­tuple-element-list
tuple-elementexpression­ | identifier­ : expression­



ワイルドカード式


ワイルドカード式 は、代入の間、値を明示的に無視するために使用されます。たとえば、以下の代入式で 10 は x に代入され、20 は無視されます。


  1. (x, _) = ( 10, 20 )
  2. // x is 10, and 20 is ignored


ワイルドカードの文法

wildcard-expression → _



キーパス式


キーパス式 は、ある型のプロパティまたはサブスクリプトを参照します。キー値監視などの動的プログラミングタスクでは、キーパス式を使用して下さい。それらは以下の形式です:


\ .


型名 (type name) は、String,[Int], または Set<Int> などの汎用パラメータを含む具象型の名前です。


パス (path) は、プロパティ名、サブスクリプト、optional の連鎖式、および強制開封式で構成されます。これらのキーパス成分のそれぞれは、任意の順序で、必要に応じて何度も繰り返すことができます。


コンパイル時に、キーパス式は KeyPath クラスのインスタンスに置き換えられます。


キーパスを使用して値にアクセスするには、すべての型で使用可能な subscript(keyPath:) サブスクリプトにキーパスを渡します。例えば:


  1. struct SomeStructure {
  2.         var someValue: Int
  3. }
  4. let s = SomeStructure(someValue: 12)
  5. let pathToProperty = \SomeStructure.someValue
  6. let value = s[keyPath: pathToProperty]
  7. // value is 12


型名(type name) は、型推論が暗黙の型を決定できるコンテキストでは省略できます。以下のコードでは、\SomeClass.someProperty の代わりに\.someProperty を使用しています。


  1. class SomeClass: NSObject {
  2.         @objc var someProperty: Int
  3.         init(someProperty: Int) {
  4.                 self.someProperty = someProperty
  5.         }
  6. }
  7. let c = SomeClass(someProperty: 10)
  8. c.observe(\.someProperty) { object, change in
  9.         // ...
  10. }


パス (path) には、プロパティー値のプロパティーを参照する複数のプロパティー名をピリオドで区切って指定することができます。以下のコードでは、キーパス式 \OuterStructure.outer.someValue を使用して、OuterStructure 型の outer プロパティの someValue プロパティにアクセスしています。


  1. struct OuterStructure {
  2.         var outer: SomeStructure
  3.         init(someValue: Int) {
  4.                 self.outer = SomeStructure(someValue: someValue)
  5.         }
  6. }
  7. let nested = OuterStructure(someValue: 24)
  8. let nestedKeyPath = \OuterStructure.outer.someValue
  9. let nestedValue = nested[keyPath: nestedKeyPath]
  10. // nestedValue is 24


サブスクリプトのパラメータ型が Hashable プロトコルに準拠しているかぎり、パス(path) には括弧を使用したサブスクリプトを含めることができます。この例では、キーパスのサブスクリプトを使用して配列の 2 番目の要素にアクセスします。


  1. let greetings = ["hello", "hola", "bonjour", "안녕"]
  2. let myGreeting = greetings[keyPath: \[String].[1]]
  3. // myGreeting is 'hola'


サブスクリプトで使用される値は、名前付き値またはリテラルにすることができます。値は、値セマンティクスを使用してキーパスにキャプチャされます。以下のコードでは、key-path 式と closure の両方で変数 index を使用して、greetings 配列の3番目の要素にアクセスします。index が変更されると、キーパス式はまだ 3 番目の要素を参照しますが、クロージャは新しいインデックスを使用します。


  1. var index = 2
  2. let path = \[String].[index]
  3. let fn: ([String]) -> String = { strings in strings[index] }
  4. print(greetings[keyPath: path])
  5. // Prints "bonjour"
  6. print(fn(greetings))
  7. // Prints "bonjour"
  8. // Setting 'index' to a new value doesn't affect 'path'
  9. index += 1
  10. print(greetings[keyPath: path])
  11. // Prints "bonjour"
  12. // Because 'fn' closes over 'index', it uses the new value
  13. print(fn(greetings))
  14. // Prints "안녕"


パス(path) には、optional の連鎖と強制開封を使用できます。以下のコードでは、キーパスで optional の連鎖を使用して、optional の文字列のプロパティにアクセスしています。


  1. let firstGreeting: String? = greetings.first
  2. print(firstGreeting?.count as Any)
  3. // Prints "Optional(5)"
  4. // Do the same thing using a key path.
  5. let count = greetings[keyPath: \[String].first?.count]
  6. print(count as Any)
  7. // Prints "Optional(5)"


キーパスの成分を混在させて一致させることで、ある型のなかで深くネストされた値にアクセスできます。以下のコードは、これらの成分を結合するキーパス式を使用して、配列の辞書の異なる値とプロパティにアクセスしています。


  1. let interestingNumbers = ["prime": [2, 3, 5, 7, 11, 13, 15],
  2.                                         "triangular": [1, 3, 6, 10, 15, 21, 28],
  3.                                         "hexagonal": [1, 6, 15, 28, 45, 66, 91]]
  4. print(interestingNumbers[keyPath: \[String: [Int]].["prime"]] as Any)
  5. // Prints "Optional([2, 3, 5, 7, 11, 13, 15])"
  6. print(interestingNumbers[keyPath: \[String: [Int]].["prime"]![0]])
  7. // Prints "2"
  8. print(interestingNumbers[keyPath: \[String: [Int]].["hexagonal"]!.count])
  9. // Prints "7"
  10. print(interestingNumbers[keyPath: \[String: [Int]].["hexagonal"]!.count.bitWidth])
  11. // Prints "64"


Objective-C の API と相互作用するコードでキーパスを使用する方法の詳細については、ココアと Objective-C で Swift を使用する(Swift 4.0.3)キーとキーパス を参照してください。キー値コーディングとキー値監視については、キー値コーディングプログラミングガイド および キー値監視プログラミングガイド を参照してください。


キーパス式の文法

key-path-expression\­ type opt ­. ­key-path-components
key-path-componentskey-path-component­ | key-path-component­. key-path-components
­ key-path-componentidentifier key-path-postfixes ­opt­ | key-path-postfixes

key-path-postfixeskey-path-postfix ­key-path-postfixes ­opt
­ key-path-postfix?! ­| [ ­ function-call-argument-list­ ]



セレクタ式


セレクタ式で、Objective-C でのプロパティのゲッタやセッタ、またはメソッドを参照するために使用されるセレクタにアクセスできます。


    #selector()


    #selector(getter : )


    #selector(setter : )



メソッド名(method name)プロパティ名(property name) は、Objective-C の実行時に利用できるメソッドまたはプロパティへの参照でなければなりません。セレクタ式の値は、Selector 型のインスタンスです。例えば:


  1. class SomeClass: NSObject {
  2.         @objc let property: String
  3.         @objc(doSomethingWithInt:)
  4.         func doSomething(_ x: Int) {}
  5.         init(property: String) {
  6.                 self.property = property
  7.         }
  8. }
  9. let selectorForMethod = #selector(SomeClass.doSomething(_:))
  10. let selectorForPropertyGetter = #selector(getter: SomeClass.property)


プロパティのゲッタ用のセレクタを作成する場合、プロパティ名 は、変数または定数プロパティへの参照になることができます。それに対し、プロパティのセッタ用のセレクタを作成するときには、プロパティ名 は、変数プロパティのみへの参照でなければなりません。


メソッド名 は、as 演算子と同様に、グループ化するのに括弧を含める事ができ、名前を共有するが異なる型のシグナチャを持つメソッドの間で明確にすることができます。例えば:


  1. extension SomeClass {
  2.         @objc(doSomethingWithString:)
  3.         func doSomething(_ x: String) { }
  4. }
  5. let anotherSelector = #selector(SomeClass.doSomething(_:) as (SomeClass) -> (String) -> Void)


セレクタは、実行時にではなく、コンパイル時に作成されるため、コンパイラは、メソッドやプロパティが存在し、それらは Objective-C 実行時の影響を受けている事を確認できます。


注意: メソッド名プロパティ名 は式ですが、それらは決して評価されません。


Objective-C の API と対話する Swift コードでのセレクタの使用する方法の詳細については、ココアと Objective-C で Swift を使用する(Swift 4.0.3)Objective-C のセレクタ を参照してください。


セレクタ式の文法

selector-expression#selector ­( expression ­)
selector-expression#selector ­( ­getter : expression ­)
selector-expression#selector ­( ­setter : expression )



キーパス文字列式


キーパス文字列式を使用すると、Objective-C でのプロパティを参照するために使用される文字列にアクセスし、キー値コーディングおよびキー値監視 API で使用できます。これは以下の形式を持ちます:


#keyPath(


プロパティー名(property name) は、Objective-C 実行時環境で使用可能なプロパティーへの参照でなければなりません。コンパイル時に、キーパス文字列式は文字列リテラルに置き換えられます。例えば:


  1. class SomeClass: NSObject {
  2.         @objc var someProperty: Int
  3.         init(someProperty: Int) {
  4.                 self.someProperty = someProperty
  5.         }
  6. }
  7. let c = SomeClass(someProperty: 12)
  8. let keyPath = #keyPath(SomeClass.someProperty)
  9. if let value = c.value(forKey: keyPath) {
  10.         print(value)
  11. }
  12. // Prints "12"


クラス内でキーパス文字列式を使用する場合は、クラス名なしで、プロパティ名だけを記述することで、そのクラスのプロパティを参照できます。


  1. extension SomeClass {
  2.         func getSomeKeyPath() -> String {
  3.                 return #keyPath(someProperty)
  4.         }
  5. }
  6. print(keyPath == c.getSomeKeyPath())
  7. // Prints "true"


キーパス文字列は実行時ではなくコンパイル時に作成されるため、コンパイラはプロパティが存在し、プロパティが Objective-C 実行時環境に公開されていることを確認できます。


Objective-C API と相互作用する Swift コードでキーパスを使用する方法の詳細については、ココアと Objective-C で Swift を使用する (Swift 4.0.3)キーとキーパス を参照してください。キー値コーディングとキー値監視については、キー値コーディングプログラミングガイド および キー値監視プログラミングガイド を参照してください。


注意: プロパティ名 は式ですが、決して評価されません。


キーパス文字列式の文法

key-path-string-expression#keyPath ( expression ­)



­

接尾辞の式


接尾辞の式 は、接尾辞演算子または他の接尾辞構文を式に当てはめて形成されます。構文的には、すべての一次式は、また接尾辞式です。


これらの演算子の動作については、基本演算子 および 高度な演算子 を参照してください。


Swift の標準ライブラリで提供される演算子の詳細については、演算子の宣言 を参照してください。


接尾辞の式の文法

postfix-expressionprimary-expression
postfix-expressionpostfix-expression ­postfix-operator
postfix-expressionfunction-call-expression
postfix-expressioninitializer-expression
postfix-expressionexplicit-member-expression
postfix-expressionpostfix-self-expression
postfix-expressionsubscript-expression
postfix-expressionforced-value-expression
postfix-expressionoptional-chaining-expression­



関数呼び出し式


関数呼び出し式 は、カッコ内の関数の引数をカンマで区切ったリストが続く、関数名で構成されています。関数呼び出し式は、以下のような形式です。


(, )



関数名 は、式の値が関数の型である、任意の式でありえます。


関数の定義が、そのパラメータが名前を含んでいる場合は、関数呼び出しには、コロン (:) で区切られた引数値の前に、名前を含んでいなければなりません。関数呼び出し式のこの種の形式は以下のとおりです。


(: , : )



関数呼び出し式は、閉じ括弧の直後にクロージャ式の形式が末尾に続くクロージャを含めることができます。末尾に続くクロージャは、最後の括弧内の引数の後に追加された、関数への引数として理解されます。以下の関数呼び出しは等価です。


  1. // someFunction takes an integer and a closure as its arguments
  2. someFunction(x: x, f: {$0 == 13})
  3. someFunction(x: x) {$0 == 13}


末尾に続くクロージャが、関数の唯一の引数である場合は、括弧を省略することができます。


  1. // someFunction takes a closure as its only argument
  2. myData.someMethod() {$0 == 13}
  3. myData.someMethod {$0 == 13}


関数呼び出し式の文法

function-call-expressionpostfix-expression ­function-call-argument-clause
­ function-call-expressionpostfix-expression ­function-call-argument-clause opt trailing-closure

function-call-argument-clause( ­) | ( ­function-call-argument-list ­)
function-call-argument-listfunction-call-argument | function-call-argument , function-call-argument-list
function-call-argumentexpression | identifier­ :­ expression
function-call-argumentoperator | identifier­ : operator

trailing-closureclosure-expression



イニシャライザ式


イニシャライザ式 は、型のイニシャライザへのアクセスを提供します。これは以下の形式です:


.init()



型の新しいインスタンスを初期化する関数呼び出し式でイニシャライザ式を使用できます。また、スーパークラスのイニシャライザにデリゲートするイニシャライザ式も使用できます。


  1. class SomeSubClass: SomeSuperClass {
  2.         override init() {
  3.                 // subclass initialization goes here
  4.                 super.init()
  5.         }
  6. }


関数のように、イニシャライザは値として使用できます。例えば:


  1. // Type annotation is required because String has multiple initializers.
  2. let initializer: (Int) -> String = String..init
  3. let oneTwoThree = [1, 2, 3].map(initializer).reduce("", +)
  4. print(oneTwoThree)
  5. // Prints "123"


名前で型を指定する場合は、イニシャライザ式を使用せずに、型イニシャライザにアクセスできます。他のすべての場合では、イニシャライザ式を使用しなければなりません。


  1. let s1 = SomeType.init(data: 3)    // Valid
  2. let s2 = SomeType(data: 1)          // Also valid
  3. let s3 = type(of: someValue).init(data: 7)    // Valid
  4. let s4 = type(of: someValue)(data: 5)           // Error


イニシャライザ式の文法

initializer-expressionpostfix-expression­. ­init
initializer-expressionpostfix-expression­. ­init ( argument-names )



明示的なメンバ式


明示的なメンバ式 は、名前付きの型、タプル、またはモジュールのメンバへのアクセスを可能にします。それは、項目とそのメンバの識別子との間のピリオド (.) で構成されています。


.



名前付きの型のメンバは、型の宣言または拡張機能の一部として命名されます。例えば:


  1. class SomeClass {
  2.         var someProperty = 42
  3. }
  4. let c = SomeClass()
  5. let y = c.someProperty // Member access


タプルのメンバは、ゼロから始まる整数を使って表示される順に、暗黙のうちに名前が付けられます。例えば:


  1. var t = (10, 20, 30)
  2. t.0 = t.1
  3. // Now t is (20, 20, 30)


モジュールのメンバは、そのモジュールの最上位レベルの宣言にアクセスします。


引数の名前によってのみその名前が異なるメソッドまたはイニシャライザを区別するには、コロン(:) が続く各引数名で、括弧内の引数名を含めまて下さい。名前のない引数ではアンダースコア(_) を書きます。オーバーロードされたメソッドを区別するためには、型注釈を使用して下さい。例えば:


  1. class SomeClass {
  2.         func someMethod(x: Int, y: Int) {}
  3.         func someMethod(x: Int, z: Int) {}
  4.         func overloadedMethod(x: Int, y: Int) {}
  5.         func overloadedMethod(x: Int, y: Bool) {}
  6. }
  7. let instance = SomeClass()
  8. let a = instance.someMethod                // Ambiguous
  9. let b = instance.someMethod(x:y:)        // Unambiguous
  10. let d = instance.overloadedMethod        // Ambiguous
  11. let d = instance.overloadedMethod(x:y:)    // Still ambiguous
  12. let d: (Int, Bool) -> Void = instance.overloadedMethod(x:y:)    // Unambiguous


ピリオドが行の先頭に表示されている場合、それは暗黙のメンバ式としてではなく、明示的なメンバ式の一部として理解されます。たとえば、以下のリストは、連鎖したメソッドの呼び出しが複数の行にわたって分割されている事を示します。


  1. let x = [10, 3, 20, 15, 4]
  2.         .sorted()
  3.         .filter { $0 > 5 }
  4.         .map { $0 * 100 }


明示的なメンバ式の文法

explicit-member-expressionpostfix-expression ­. ­decimal-digits
explicit-member-expressionpostfix-expression ­. identifier generic-argument-clause ­opt
explicit-member-expressionpostfix-expression . identifier­ ­( ­argument-names ­)

argument-namesargument-name ­argument-names ­opt
argument-nameidentifier­ :



接尾辞の self 式


接尾辞の self 式は、式または型の名前から成り立ち、直後に .self が続きます。これには、以下の形式があります。


最初の形式は の値に評価します。たとえば、x.self は、x と評価します。


二番目の形式は、 の値に評価します。値としての型にアクセスするためにこの形式を使用して下さい。例えば、SomeClass.selfSomeClass 型自体に評価するため、型レベルの引数を受け取る関数やメソッドにそれを渡すことができます。


self 式の文法

postfix-self-expressionpostfix-expression ­. ­self



サブスクリプト式


サブスクリプト式 は対応するサブスクリプトの宣言のゲッタとセッタを使用して、サブスクリプトアクセスを提供します。これは以下の形式です:


[ ]



サブスクリプト式の値を評価するために、 の型のサブスクリプトゲッタは、サブスクリプト・パラメータとして渡された インデックス式 で呼び出されます。その値を設定するためには、サブスクリプト・セッタも同様に呼び出されます。


サブスクリプト宣言の詳細については、プロトコルサブスクリプト宣言 を参照してください。


サブスクリプト式の文法

subscript-expressionpostfix-expression ­[ ­expression-list ­]



強制値の式


強制値の式 は、nil でないと確信される、optional の値を開封します。これには以下の形式があります:


!



の値が nil でない場合、optional の値は開封され、対応する optional でない型を返します。それ以外の場合は、実行時エラーが発生します。


強制値の式の開封された値は、値自体を変異させることによってか、あるいは値のメンバの一つに代入することによってか、どちらかで変更できます。例えば:


  1. var x: Int? = 0
  2. x! += 1
  3. // x is now 1
  4. var someDictionary = ["a": [1, 2, 3], "b": [10, 20]]
  5. someDictionary["a"]![0] = 100
  6. // someDictionary is now ["b": [10, 20], "a": [100, 2, 3]]


強制値の式の文法

forced-value-expressionpostfix-expression­ !



Optional の連鎖式


optional の連鎖式 は、接尾辞の式で optional の値を使用するための簡単な構文を提供します。これは以下の形式です:


?



接尾辞の ? 演算子は、式の値を変更せずに式から optional の連鎖式を作ります。


Optional の連鎖式は接尾辞式内に表示されなければならず、接尾辞式は、特別な方法で評価されます。optional の連鎖式が nil である場合、接尾辞式の他のすべての演算は無視され、全体の接尾辞式は nil に評価されます。optional の連鎖式の値が nil でない場合は、Optional の連鎖式の値は開封され、接尾辞式の残りの部分を評価するために使用されます。いずれの場合も、接尾辞式の値はまだ optional の型のままです。


optional の連鎖式を含む接尾辞式が、他の接尾辞式内にネストされている場合、最も外側の式だけが、optional の型を返します。以下の例では、cnil でない場合は、その値は開封されて、 .property を評価するために使用され、その値は .performAction() を評価するために使用されます。全体の式 c?.property.performAction() が optional の型の値を持っています。


  1. var c: SomeClass?
  2. var result: Bool? = c?.property.performAction()


以下の例は、optional の連鎖を使用せずに上記の例の動作を示します。


  1. var result: Bool? = nil
  2. if let unwrappedC = c {
  3.         result = unwrappedC.property.performAction()
  4. }


optional の連鎖式の開封された値は、値自体を変異させることによってか、あるいは値のメンバの一つに代入することによってかのいずれかによって、変更できます。optional の連鎖式の値が nil である場合、代入演算子の右側の式は評価されません。例えば:


  1. func someFunctionWithSideEffects() -> Int {
  2.         return 42 // No actual side effects.
  3. }
  4. var someDictionary = ["a": [1, 2, 3], "b": [10, 20]]
  5. someDictionary["not here"]?[0] = someFunctionWithSideEffects()
  6. // someFunctionWithSideEffects is not evaluated
  7. // someDictionary is still ["b": [10, 20], "a": [1, 2, 3]]
  8. someDictionary["a"]?[0] = someFunctionWithSideEffects()
  9. // someFunctionWithSideEffects is evaluated and returns 42
  10. // someDictionary is now ["b": [10, 20], "a": [42, 2, 3]]


optional の連鎖式

optional-chaining-expressionpostfix-expression ­?






前:型 次:文
目次
Xcode 10 の新機能

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

    << SWIFT >>


  1. ようこそ Swift へ(Part I)
  2. Swift について
  3. バージョン互換性
  4. Swift のツアー
  5. 単純な値
    制御フロー
    関数とクロージャ
    オブジェクトとクラス
    列挙型と構造体
    プロトコルと拡張機能
    エラー処理
    汎用(ジェネリック)
  6. Swift 言語のガイド(Part II)
  7. Swift の基本
  8. 定数と変数
  9. 定数と変数の宣言
    型注釈
    定数と変数の命名
    定数と変数の印刷
    コメント
    セミコロン
  10. 整数
  11. 整数の境界
    Int
    UInt
    浮動小数点数
    安全な型と型推論
    数値リテラル
  12. 数値型変換
  13. 整数変換
    整数と浮動小数点間の変換
    型エイリアス
    ブール型
    タプル
  14. Optional
  15. nil
    if 文と強制開封
    Optional の結合
    暗黙に開封された Optionals
    エラー処理
  16. アサーション(断言)と前提条件
  17. アサーションを使用したデバッグ
    前提条件の実施
  18. 基本演算子
  19. 専門用語
    代入演算子
  20. 算術演算子
  21. 剰余演算子
    単項マイナス演算子
    単項プラス演算子
    複合代入演算子
    比較演算子
    三項条件演算子
    Nil 合体演算子
  22. 範囲演算子
  23. 閉鎖範囲演算子
    半開放範囲演算子
    片方の範囲
  24. 論理演算子
  25. 論理 NOT 演算子
    論理 AND 演算子
    論理 OR 演算子
    論理演算子の組み合わせ
    明示的な括弧
  26. 文字列と文字
  27. 文字列リテラル
    複数行の文字列リテラル
    文字列リテラル内の特殊文字
    空の文字列の初期化
    文字列の可変性
    文字列は値の型
    文字を使った作業
    文字列と文字を連結
    文字列補間
  28. ユニコード(Unicode)
  29. Unicode スカラー
    文字列リテラルの中の特別の文字
    拡張書記クラスタ
    文字を数える
  30. 文字列のアクセスと変更
  31. 文字列のインデックス
    部分文字列
    挿入と削除
  32. 文字列の比較
  33. 文字列と文字の等価性
    接頭辞と接尾辞の等価性
  34. 文字列の Unicode 表現
  35. UTF-8 の表現
    UTF-16 表現
    Unicode のスカラー表現
  36. コレクション型
  37. コレクションの可変性
  38. 配列
  39. 配列型省略構文
    空の配列の作成
    デフォルト値を持つ配列の作成
    2つの配列を共にして一つの配列に
    配列リテラルでの配列の作成
    配列へのアクセスと変更
    配列の繰り返し処理
  40. セット
  41. セット型のハッシュ値
    セット型の構文
    空のセットの作成と初期化
    配列リテラルでセットの作成
    セットへのアクセスと変更
    セットを反復処理
  42. セット操作の実行
  43. 基本的なセットの操作
    セットの身分と等価性
  44. Dictionary
  45. Dictionary 型の省略型構文
    空の Dictionary を作成
    Dictionary リテラルで Dictionary の作成
    Dictionary のアクセスと変更
    Dictionary を繰り返し処理
  46. フロー制御
  47. For-In ループ
  48. While ループ
  49. While
    Repeat-While
  50. 条件文
  51. if 文
  52. Switch
  53. 暗黙の Fallthrough なし
    範囲の一致
    タプル(Tuples)
    値の結合
    Where
    複合した case
  54. 制御転送文
  55. Continue
  56. Break
  57. ループ文内の Break
    Switch 文内の Break
    Fallthrough
    ラベル付きの文
    早期終了
    API 利用可能性の確認
  58. 関数
  59. 関数の定義と呼び出し
  60. 関数のパラメータと戻り値
  61. パラメータなしの関数
    複数パラメータの関数
    戻り値なしの関数
    複数の戻り値を持つ関数
    optional のタプル型の戻り値
  62. 関数引数のラベルとパラメータ名
  63. 引数のラベルの指定
    引数ラベルの省略
    デフォルトのパラメータ値
    可変個引数のパラメータ
    In-Out パラメータ
  64. 関数型
  65. 関数型の使用
    パラメータ型としての関数型
    戻り値の型としての関数型
    入れ子になった関数
  66. クロージャ
  67. クロージャ式
  68. ソートするメソッド
    クロージャ式の構文
    文脈から型を推論
    単一式クロージャからの暗黙的戻り値
    引数名の省略
    演算子メソッド
    後続クロージャ
    値のキャプチャ
    クロージャは参照型
    クロージャのエスケープ
    オートクロージャ
  69. 列挙型
  70. 列挙型の構文
    switch 文で列挙型の値の一致
    関連する値
  71. 生の値
  72. 暗黙に割り当てられた生の値
    生の値からの初期化
    再帰的な列挙型
  73. クラスと構造体
  74. クラスと構造体を比較
  75. 定義の構文
    クラスと構造体のインスタンス
    プロパティにアクセス
    構造体型のためのメンバー化イニシャライザ
    構造体と列挙型は値型
  76. クラスは参照型
  77. ID 演算子
    ポインタ
    クラスと構造体の間の選択
    文字列、配列、辞書の代入とコピーの動作
  78. プロパティ
  79. 格納されたプロパティ
  80. 定数構造体インスタンスの格納されたプロパティ
    遅延した格納されたプロパティ
    格納されたプロパティとインスタンス変数
  81. 計算されたプロパティ
  82. セッタ宣言の省略形
    読み取り専用の計算されたプロパティ
    プロパティ監視者
    グローバルとローカル変数
  83. 型プロパティ
  84. 型プロパティの構文
    型プロパティの照会と設定
  85. メソッド
  86. インスタンスメソッド
  87. self プロパティ
    インスタンスメソッド内から値の型を変更
    変異メソッド内で self に代入
    型メソッド
  88. サブスクリプト
  89. サブスクリプトの構文
    サブスクリプトの使用法
    サブスクリプトのオプション
  90. 継承
  91. 基本クラスの定義
    サブクラス化
  92. オーバーライド(上書き)
  93. スーパークラスメソッド、プロパティ、サブスクリプトへのアクセス
    オーバーライドするメソッド
  94. オーバーライドするプロパティ
  95. プロパティのゲッタとセッタのオーバーライド
    プロパティ監視者のオーバーライド
    オーバーライドの防止
  96. 初期化
  97. 格納されたプロパティの初期値を設定
  98. イニシャライザ
    デフォルトのプロパティ値
  99. 初期化のカスタマイズ
  100. 初期化パラメータ
    パラメータ名と引数ラベル
    引数ラベルのないイニシャライザのパラメータ
    Optional のプロパティ型
    初期化中に定数プロパティへの代入
  101. デフォルトのイニシャライザ
  102. 構造体型のためのメンバ化イニシャライザ
    値型のイニシャライザデリゲート
  103. クラスの継承と初期化
  104. 指定イニシャライザとコンビニエンスイニシャライザ
    指定とコンビニエンスイニシャライザの構文
    クラス型のイニシャライザデリゲート
    二相の初期化
    イニシャライザ継承とオーバーライド
    自動イニシャライザの継承
    実際の指定とコンビニエンスイニシャライザ
  105. 失敗可能イニシャライザ
  106. 生の値を持つ列挙型のための失敗可能イニシャライザ
    初期化失敗の伝播
    失敗可能イニシャライザのオーバーライド
    init! の失敗可能イニシャライザ
    必須イニシャライザ
    クロージャや関数でのデフォルトのプロパティ値設定
  107. デイニシャライザ
  108. デイニシャライザはどのように働くか
    作動中のデイニシャライザ
  109. Optional の連鎖
  110. 強制開封の代替としての Optional の連鎖
    Optional の連鎖のモデルクラスの定義
    Optional の連鎖を使用したプロパティへのアクセス
    Optional の連鎖を通じてメソッドを呼び出す
  111. Optional の連鎖を通じてサブスクリプトへのアクセス
  112. Optional 型のサブスクリプトにアクセス
    連鎖の複数レベルのリンク
    optional の戻り値を持つメソッドでの連鎖
  113. エラー処理
  114. エラーの表現と Throw
    エラーの処理
    throw 関数を使用したエラーの伝播
    Do-Catch を使用したエラー処理
    エラー をOptional の値に変換
    エラー伝播を無効に
    クリーンアップアクションの指定
  115. 型キャスト
  116. 型キャストのためのクラス階層の定義
    型のチェック
    ダウンキャスト
  117. Any と AnyObjecgt 用の型キャスティング
  118. ネストした型
  119. 実際のネストした型
    ネストした型への参照
  120. 拡張機能
  121. 拡張機能の構文
    計算されたプロパティ
    イニシャライザ
  122. メソッド
  123. 変異インスタンスメソッド
    サブスクリプト
    ネストした型
  124. プロトコル
  125. プロトコルの構文
    プロパティの要件
    メソッドの要件
    変異メソッドの要件
  126. イニシャライザの要件
  127. プロトコルイニシャライザ要件のクラス実装
    失敗可能イニシャライザの要件
    型としてのプロトコル
    デリゲート
  128. 拡張機能を持つプロトコル準拠の追加
  129. 拡張機能を持つプロトコルの採用を宣言
    プロトコル型のコレクション
    プロトコルの継承
    クラス専用プロトコル
    プロトコルの構成
    プロトコル準拠の確認
    Optional のプロトコル要件
  130. プロトコル拡張機能
  131. デフォルトの実装の提供
    プロトコル拡張機能に制約を追加
  132. ジェネリック(汎用)
  133. 汎用が解決する問題
    汎用関数
    型パラメータ
    型パラメータの命名
    汎用の型
    汎用型の拡張
  134. 型の制約
  135. 型制約の構文
    実際の型の制約
  136. 関連型
  137. 実際の関連型
    既存の型を拡張して関連型を指定
    型注釈を使用して関連型を制約
    汎用の Where 句
    汎用の Where 句を含む拡張機能
    関連する型と汎用の Where 句
    汎用のサブスクリプト
  138. 自動参照カウント
  139. どのように ARC は働くか
    実際の ARC
    クラスインスタンス間の強い循環参照
  140. クラスインスタンス間の強い循環参照の解決
  141. 弱い参照
    所有されていない参照
    所有されていない参照と暗黙に開封された Optional のプロパティ
    クロージャの strong な循環参照
  142. クロージャの strong な循環参照の解決
  143. キャプチャリストの定義
    弱い参照と所有されていない参照
  144. メモリの安全性
  145. メモリへのアクセス競合の理解
    メモリアクセスの特徴
    In-Out パラメータへのアクセスの競合
    メソッド内の Self へのアクセスの競合
    プロパティへのアクセスの競合
  146. アクセス制御
  147. モジュールとソースファイル
  148. アクセスレベル
  149. アクセスレベルの全体的指針
    デフォルトのアクセスレベル
    ターゲット一つのアプリのアクセスレベル
    フレームワークのアクセスレベル
    ユニットテストのターゲット用のアクセスレベル
    アクセス制御の構文
  150. カスタム型
  151. タプル型
    関数型
  152. 列挙型
  153. 生の値と関連する値
    ネストした型
    サブクラス化
  154. 定数、変数、プロパティ、およびサブスクリプト
  155. ゲッタとセッタ
  156. イニシャライザ
  157. デフォルトのイニシャライザ
    構造体型用のデフォルトメンバ化イニシャライザ
  158. プロトコル
  159. プロトコルの継承
    プロトコルの準拠
  160. 拡張機能
  161. 拡張機能の private メンバ
    汎用
    型エイリアス
  162. 高度な演算子
  163. ビット単位演算子
  164. ビット単位の NOT 演算子
    ビット単位の AND 演算子
    ビット単位の OR 演算子
    ビット単位の XOR 演算子
  165. ビット単位の左と右シフト演算子
  166. 符号なし整数のシフト動作
    符号付き整数のシフト動作
  167. オーバーフロー演算子
  168. 値オーバーフロー
    優先順位と結合性
  169. 演算子メソッド
  170. 接頭辞と接尾辞演算子
    複合代入演算子
    等価演算子
  171. カスタム演算子
  172. カスタム挿入辞演算子の優先順位
  173. 言語のガイド(Part III)
  174. 言語リファレンスについて
  175. 文法の読み方
  176. 語彙の構造
  177. 空白とコメント
    識別子
    キーワードと句読点
  178. リテラル
  179. 整数リテラル
    浮動小数点リテラル
    文字列のリテラル
    演算子

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

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

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



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












    トップへ(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)












    トップへ(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)












    トップへ(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)












    トップへ(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)