From 502256e37beac2dbcffe35366dc7fb9b0a35d1c8 Mon Sep 17 00:00:00 2001 From: stzn Date: Sat, 27 May 2023 13:30:18 +0900 Subject: [PATCH 1/2] =?UTF-8?q?if=E5=BC=8F=E3=81=A8switch=E5=BC=8F?= =?UTF-8?q?=E3=82=92=E8=BF=BD=E5=8A=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- language-guide/control-flow.md | 98 +++++++++++++++++++- language-reference/expressions.md | 75 ++++++++++++++- language-reference/summary-of-the-grammar.md | 25 ++++- welcome-to-swift/a-swift-tour.md | 14 ++- 4 files changed, 208 insertions(+), 4 deletions(-) diff --git a/language-guide/control-flow.md b/language-guide/control-flow.md index b2f3f797..cbe05b20 100644 --- a/language-guide/control-flow.md +++ b/language-guide/control-flow.md @@ -1,6 +1,6 @@ # 制御フロー\(Control Flow\) -最終更新日: 2022/12/3 +最終更新日: 2023/5/27 原文: https://docs.swift.org/swift-book/LanguageGuide/ControlFlow.html 分岐、ループ、および早期終了を使ってコードを構造化する。 @@ -281,6 +281,81 @@ if temperatureInFahrenheit <= 32 { この温度は、暑すぎず寒すぎない温度なので、`if` も `else if` も実行されず、何も出力しません。 +Swift は、値を設定するときに使用できる `if` の省略記法のスペルを提供します。例えば、以下のコードを考えてみましょう: + +```swift +let temperatureInCelsius = 25 +let weatherAdvice: String + +if temperatureInCelsius <= 0 { + weatherAdvice = "とても寒いですね。マフラーを巻いたほうがいいでしょう。" +} else if temperatureInCelsius >= 30 { + weatherAdvice = "とても暖かいですね。日焼け止めを忘れずにしましょう。" +} else { + weatherAdvice = "そんなに寒くありません。Tシャツを着ましょう。" +} + +print(weatherAdvice) +// "そんなに寒くありません。Tシャツを着ましょう。" +``` + +ここでは、それぞれの分岐が `weatherAdvice` 定数の値を設定し、`if` 文の後で出力しています。 + +`if` 式と呼ばれる別の構文を使えば、このコードをより簡潔に書くことができます: + +```swift +let weatherAdvice = if temperatureInCelsius <= 0 { + "とても寒いですね。マフラーを巻いたほうがいいでしょう。" +} else if temperatureInCelsius >= 30 { + "とても暖かいですね。日焼け止めを忘れずにしましょう。" +} else { + "そんなに寒くありません。Tシャツを着ましょう。" +} + +print(weatherAdvice) +// "そんなに寒くありません。Tシャツを着ましょう。" +``` + +この `if` 式のバージョンでは、各分岐に 1 つの値が含まれています。ある分岐の条件が真であれば、その分岐の値が `weatherAdvice` の割り当てられ、 `if` 式全体の値として使用されます。すべての `if` の分岐には対応する `else if` 分岐または `else` 分岐があり、どの条件が真であっても、必ずいずれかの分岐が一致し、`if` 式が常に値を生成します。 + +代入の構文は `if` 式の外側から始まるので、各分岐の中で `weatherAdvice =` を繰り返す必要はありません。その代わり、`if` 式の各分岐は `weatherAdvice` の 3 つの可能性のある値のうちの 1 つを生成し、代入後はその値を使用します。 + +`if` 式のすべての分岐には、同じ型の値を含む必要があります。Swift は各分岐の型を別々にチェックするので、複数の型で使用できる `nil` のような値は、Swift が `if` 式の型を自動的に決定することを妨げます。代わりに、あなたは明示的に型を指定する必要があります---例えば: + +```swift +let freezeWarning: String? = if temperatureInCelsius <= 0 { + "氷点下です。氷に注意しましょう!" +} else { + nil +} +``` + +上のコードでは、`if` 式の一方の分岐に `String` 値が、もう一方の分岐に `nil` 値が設定されています。`nil` 値は任意のオプショナル型の値として使用できるため、doc:TheBasics#Type-Annotations [型注釈\(Type Annotations\)](../language-guide/the-basics.md#type-annotations)にあるように、`freezeWarning` がオプショナルの文字列であることを明示的に記述する必要があります。 +この型情報を提供する別の方法として、`freezeWarning` に明示的な型を提供する代わりに、`nil` に明示的な型を提供することができます： + + +```swift +let freezeWarning = if temperatureInCelsius <= 0 { + "氷点下です。氷に注意しましょう！" +} else { + nil as String? +} +``` + +`if` 式は、予期せぬ失敗に対して、エラーを投げたり、`fatalError(_:file:line:)` のように、戻り値を返さない関数を呼び出して対応することができます。例えば、次のようなものです: + +```swift +let weatherAdvice = if temperatureInCelsius > 100 { + throw TemperatureError.boiling +} else { + "適度な気温ですね。" +} +``` + +この例では、`if` 式は予報気温が 100°C(水の沸点)より高いかどうかをチェックします。これほど高温になると、`if` 式はテキストの要約を返す代わりに、`.boiling` エラーを投げることになります。この `if` 式がエラーを投げる可能性があるにもかかわらず、その前に `try` を書いていません。エラーの扱いについては、[エラー処理\(Error Handling\)](../language-guide/error-handling.md)を参照してください。 + +上の例のように、`if` 式を代入の右辺で使うだけでなく、関数やクロージャが返す値として使うこともできます。 + ### Switch `switch` 文は、複数の可能性に対してパターンマッチを使用して比較を行い、値を検討します。そして、一致した最初のパターンのコードのブロックを実行します。`switch` 文は、複数の可能性がある状態に対して `if` 文の代わりに使用することができます。 @@ -312,6 +387,27 @@ default: `switch` 文の最初のケースは、英語アルファベットの最初の文字 `a` に合致し、2 番目のケースは最後の文字 `z` に合致します。全ての可能性がある文字をカバーしなければならないため、`a` と `z` 以外の全ての文字に対して `default` ケースを使用しています。こうすることで全てのケースを網羅できています。 +`if` 文と同様に、`switch` 文にも式があります: + +```swift +let anotherCharacter: Character = "a" +let message = switch anotherCharacter { +case "a": + "アルファベットの最初の文字" +case "z": + "アルファベットの最後の文字" +default: + "その他の文字" +} + +print(message) +// "アルファベットの最初の文字" +``` + +この例では、`switch` 式の各ケースには、そのケースが `anotherCharacter` にマッチしたときに使用される `message` の値が含まれています。`switch` は常に網羅的であるため、代入する値は必ず存在します。 + +`if` 式と同様に、与えられたケースに値を与える代わりに、エラーを投げたり、`fatalError(_:file:line:)` のように戻り値を返さない関数を呼び出すことができます。`switch` 式は、上の例のように代入の右辺で使ったり、関数やクロージャが返す値として使うことができます。 + #### 暗黙的にfallthroughしない\(No Implicit Fallthrough\) C 言語や Objective-C と異なり、Swift の `switch` 文は、デフォルトでは、それぞれのケースの下から次のケースに行くことはありません。その代わりに、最初に合致した `switch` ケースの実行が完了すると、明示的に `break` しなくても、全体の `switch` 文も完了します。こうすることで、C 言語の `switch` 文よりも、より安全に簡単に使えるようにしています。間違って 1 つ以上のケースを実行してしまうリスクを防ぎます。 diff --git a/language-reference/expressions.md b/language-reference/expressions.md index e2cd0239..47ff5680 100644 --- a/language-reference/expressions.md +++ b/language-reference/expressions.md @@ -1,6 +1,6 @@ # 式\(Expressions\) -最終更新日: 2022/12/31 +最終更新日: 2023/5/27 原文: https://docs.swift.org/swift-book/ReferenceManual/Expressions.html 型、演算子、変数、およびその他の名前と構造を紹介する。 @@ -213,6 +213,7 @@ f(x as Any) > primary-expression → [literal-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_literal-expression) > primary-expression → [self-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_self-expression) > primary-expression → [superclass-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_superclass-expression) +> *primary-expression* → *conditional-expression* > primary-expression → [closure-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_closure-expression) > primary-expression → [parenthesized-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_parenthesized-expression) > primary-expression → [tuple-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_tuple-expression) @@ -347,6 +348,78 @@ _スーパークラス式_は、クラスがスーパークラスとやり取り > superclass-subscript-expression → `super` `[` [function-call-argument-list](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_function-call-argument-list) `]` > superclass-initializer-expression → `super` `.` `init` +### 条件式\(Conditional Expression\) + +_条件式_は、条件の値に基づいて、与えられたいくつかの値のうちの 1 つに評価されます。 + +形式は次の通りです: + +```swift +if <#condition 1#> { + <#expression used if condition 1 is true#> +} else if <#condition 2#> { + <#expression used if condition 2 is true#> +} else { + <#expression used if both conditions are false#> +} +switch <#expression#> { +case <#pattern 1#>: + <#expression 1#> +case <#pattern 2#> where <#condition#>: + <#expression 2#> +default: + <#expression 3#> +} +``` + +条件式は、`if` 文や `switch` 文と同じ動作と構文ですが、以下の段落で説明する違いがあります。 + +条件式は、以下の状況でのみ使用できます: + +- 変数に代入される値として +- 変数または定数宣言の初期値として +- `throw` 式が投げるエラーとして +- 関数、クロージャ、プロパティの `get` が返す値として +- 条件式の分岐内の値として + +条件式の分岐は網羅的であり、条件に関係なく常に値を生成することを保証します。つまり、各 `if` 分岐には対応する `else` 分岐が必要です。 + +各分岐には、その分岐の条件が真である場合に条件式の値として使用される単一式、`throw` 文、または戻り値を返さない関数への呼び出しが含まれます。 + +各分岐は、同じ型の値を生成する必要があります。各分岐の型チェックは独立しているので、分岐に異なる種類のリテラルを含む場合や、分岐の値が `nil` である場合など、値の型を明示的に指定する必要がある場合があります。このような情報を提供する必要がある場合は、結果が代入される変数に型注釈を追加するか、分岐の値に `as` キャストを追加してください。 + +```swift +let number: Double = if someCondition { 10 } else { 12.34 } +let number = if someCondition { 10 as Double } else { 12.34 } +``` + +リザルトビルビルダの内部では、条件式は変数や定数の初期値としてのみ使用することができます。つまり、変数や定数の宣言のないリザルトビルダ内で `if` や `switch` を記述すると、そのコードは分岐文として理解され、リザルトビルダのメソッドの 1 つが、そのコードを変換することになります。 + +条件式の分岐の 1 つがエラーをスローする場合でも、条件式を `try` 式の中に入れてはいけません。 + + +> Grammar of a conditional expression: +> +> *conditional-expression* → *if-expression* | *switch-expression* +> +> +> +> *if-expression* → **`if`** *condition-list* **`{`** *statement* **`}`** *if-expression-tail* +> +> *if-expression-tail* → **`else`** *if-expression* +> +> *if-expression-tail* → **`else`** **`{`** *statement* **`}`** *if-expression-tail* +> +> +> +> *switch-expression* → **`switch`** *expression* **`{`** *switch-expression-cases* **`}`** +> +> *switch-expression-cases* → *switch-expression-case* *switch-expression-cases*_?_ +> +> *switch-expression-case* → *case-label* *statement* +> +> *switch-expression-case* → *default-label* *statement* + ### クロージャ式\(Closure Expression\) _クロージャ式_は、他のプログラミング言語では、_ラムダ_または_匿名関数_とも呼ばれているクロージャを作成します。関数宣言のように、クロージャには文が含まれており、その囲まれている範囲から定数と変数をキャプチャします。形式は次のとおりです: diff --git a/language-reference/summary-of-the-grammar.md b/language-reference/summary-of-the-grammar.md index 5f5bfd60..7223a719 100644 --- a/language-reference/summary-of-the-grammar.md +++ b/language-reference/summary-of-the-grammar.md @@ -1,6 +1,6 @@ # 文法のまとめ\(Summary of the Grammar\) -最終更新日: 2021/7/3 +最終更新日: 2023/5/27 原文: https://docs.swift.org/swift-book/ReferenceManual/zzSummaryOfTheGrammar.html ## Lexical Structure\(構文の構造\) @@ -271,6 +271,7 @@ > primary-expression → [literal-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_literal-expression) > primary-expression → [self-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_self-expression) > primary-expression → [superclass-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_superclass-expression) +> *primary-expression* → *conditional-expression* > primary-expression → [closure-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_closure-expression) > primary-expression → [parenthesized-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_parenthesized-expression) > primary-expression → [tuple-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_tuple-expression) @@ -307,6 +308,28 @@ > superclass-subscript-expression → `super` `[` [function-call-argument-list](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_function-call-argument-list) `]` > superclass-initializer-expression → `super` `.` `init` +> Grammar of a conditional expression: +> +> *conditional-expression* → *if-expression* | *switch-expression* +> +> +> +> *if-expression* → **`if`** *condition-list* **`{`** *statement* **`}`** *if-expression-tail* +> +> *if-expression-tail* → **`else`** *if-expression* +> +> *if-expression-tail* → **`else`** **`{`** *statement* **`}`** *if-expression-tail* +> +> +> +> *switch-expression* → **`switch`** *expression* **`{`** *switch-expression-cases* **`}`** +> +> *switch-expression-cases* → *switch-expression-case* *switch-expression-cases*_?_ +> +> *switch-expression-case* → *case-label* *statement* +> +> *switch-expression-case* → *default-label* *statement* + > GRAMMAR OF A CLOSURE EXPRESSION > closure-expression → `{` [closure-signature](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_closure-signature)opt [statements](https://docs.swift.org/swift-book/ReferenceManual/Statements.html#grammar_statements)opt `}` > closure-signature → [capture-list](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_capture-list)opt [closure-parameter-clause](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_closure-parameter-clause) `throws`opt [function-result](https://docs.swift.org/swift-book/ReferenceManual/Declarations.html#grammar_function-result)opt `in` diff --git a/welcome-to-swift/a-swift-tour.md b/welcome-to-swift/a-swift-tour.md index 75c804ba..56c75c62 100644 --- a/welcome-to-swift/a-swift-tour.md +++ b/welcome-to-swift/a-swift-tour.md @@ -1,6 +1,6 @@ # Swiftツアー\(A Swift Tour\) -最終更新日: 2022/12/3 +最終更新日: 2023/5/27 原文: https://docs.swift.org/swift-book/GuidedTour/GuidedTour.html Swift の特徴とシンタックスを探る。 @@ -134,6 +134,18 @@ print(teamScore) `if` 文の中で、条件はブール式でなければなりません。つまり、`if score { ... }` などのコードはエラーで、暗黙的な 0 との比較は行われません。 +条件に基づいた値を選ぶために、代入時の等号(`=`)の後ろや `return` の後に、`if` または `switch` を書くことができます。 + +```swift +let scoreDecoration = if teamScore > 10 { + "🎉" +} else { + "" +} +print("Score:", teamScore, scoreDecoration) +// "Score: 11 🎉"を出力 +``` + `if` と `let` を一緒に使用して、存在しないかもしれない値を扱うことができます。これらの値はオプショナルで表現されます。オプショナルは値が含まれているか、値が存在しないことを示す `nil` を含んでいます。値をオプショナルにするには、値の型の後ろにクエスチョンマーク\(`?`\)を書きましょう。 ```swift From 081c152f62e400d39c0fbfc66aeab42cc3c839c5 Mon Sep 17 00:00:00 2001 From: stzn Date: Sat, 27 May 2023 16:56:09 +0900 Subject: [PATCH 2/2] =?UTF-8?q?[Expressions]=E5=8E=9F=E6=96=87=E3=81=AB?= =?UTF-8?q?=E5=90=88=E3=82=8F=E3=81=9B=E3=81=A6=E8=A1=A8=E7=A4=BA=E6=96=B9?= =?UTF-8?q?=E6=B3=95=E3=81=AE=E6=9B=B4=E6=96=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- language-reference/expressions.md | 546 +++++++++++++++++++++--------- 1 file changed, 378 insertions(+), 168 deletions(-) diff --git a/language-reference/expressions.md b/language-reference/expressions.md index 47ff5680..b59ebbab 100644 --- a/language-reference/expressions.md +++ b/language-reference/expressions.md @@ -9,9 +9,11 @@ Swift では、前置式、バイナリ式、基本式、後置式の 4 種類 前置式とバイナリ式を使用すると、演算子をより小さな式に適用できます。基本式は概念的には最もシンプルな種類の式で、値にアクセスする方法を提供します。後置式は、前置式やバイナリ式と同様に、関数呼び出しやメンバアクセスなど、後置式を使用してより複雑な式を構築できます。各式は、下記のセクションで詳しく説明されています。 -> GRAMMAR OF AN EXPRESSION -> expression → [try-operator](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_try-operator)opt [prefix-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_prefix-expression) [binary-expressions](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_binary-expressions)opt -> expression-list → [expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) \| [expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) `,` [expression-list](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression-list) +> Grammar of an expression: +> +> *expression* → *try-operator*_?_ *await-operator*_?_ *prefix-expression* *infix-expressions*_?_ +> +> *expression-list* → *expression* | *expression* **`,`** *expression-list* ## 前置式\(Prefix Expressions\) @@ -21,40 +23,52 @@ Swift では、前置式、バイナリ式、基本式、後置式の 4 種類 Swift 標準ライブラリによって提供されている演算子については、[Operator Declarations\(演算子宣言\)](https://developer.apple.com/documentation/swift/swift_standard_library/operator_declarations)を参照ください。 -> GRAMMAR OF A PREFIX EXPRESSION -> prefix-expression → [prefix-operator](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_prefix-operator)opt [postfix-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_postfix-expression) -> prefix-expression → [in-out-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_in-out-expression) +> Grammar of a prefix expression: +> +> *prefix-expression* → *prefix-operator*_?_ *postfix-expression* +> +> *prefix-expression* → *in-out-expression* + ### In-Out 式\(In-Out Expression\) in-out 式は、関数呼び出し式に in-out パラメータとして渡された変数にマークをします。 -![in-out式](../assets/inout_expression.png) +```swift +&<#expression#> +``` in-out パラメータの詳細については、[In-Out Parameters\(In-Out パラメータ\)](../language-reference/declarations.md#declarations-in-out-parameters)を参照ください。 in-out 式は、[Implicit Conversion to a Pointer Type\(ポインタ型への暗黙変換\)](expressions.md#implicit-conversion-to-a-pointer-type)で説明されているように、ポインタが必要なコンテキストに非ポインタ引数を指定するときにも使用されます。 -> GRAMMAR OF AN IN-OUT EXPRESSION -> in-out-expression → `&` [identifier](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_identifier) +> Grammar of an in-out expression: +> +> *in-out-expression* → **`&`** *identifier* ### Try 演算子\(Try Operator\) _Try 演算子_は、`try` 演算子の後にエラーをスローできる式が続く形で構成されます。形式は次のとおりです: -![try演算子](../assets/try_operator.png) +```swift +try <#expression#> +``` `try` 式の値は _expression_ の値です。 _オプショナル try 式_は `try?` 演算子の後にエラーをスローできる式が続く形で構成されます。形式は次のとおりです: -![try?演算子](../assets/try_hatena_operator.png) +```swift +try? <#expression#> +``` 式がエラーをスローしない場合、`try?` の値は式の値を含むオプショナルです。それ以外の場合、`try?` の値は `nil` です。 _強制 try 式_は `try!` 演算子の後にエラーをスローできる式が続く形で構成されます。形式は次のとおりです: -![try!演算子](../assets/try!_operator.png) +```swift +try! <#expression#> +``` `try!` の値は _experssion_ の値です。式がエラーをスローすると、実行時エラーが発生します。 @@ -77,14 +91,17 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() `try`、`try?` と `try!` の使用方法についての詳細は[Error Handling\(エラーハンドリング\)](../language-guide/error-handling.md)を参照ください。 -> GRAMMAR OF A TRY EXPRESSION -> try-operator → `try` \| `try` `?` \| `try` `!` +> Grammar of a try expression: +> +> *try-operator* → **`try`** | **`try`** **`?`** | **`try`** **`!`** ### Await 演算子\(Await Operator\) _await 式_は、`await` 演算子の後に非同期関数の結果を返す式が続けて構成されます。形式は次のとおりです: -![await 演算子](../assets/await_operator.png) +```swift +await <#expression#> +``` `await` 式の値は _experssion_ の値です。 @@ -109,14 +126,17 @@ sum = (await someAsyncFunction()) + anotherAsyncFunction() 式が `await` と `try` 演算子の両方を含む場合、最初に `try` 演算子が来なければなりません。 -> GRAMMAR OF AN AWAIT EXPRESSION -> _await-operator_ → `await` +> Grammar of an await expression: +> +> *await-operator* → **`await`** ## 中置式\(Infix Expressions\) _中置式_は、左右の引数を受け取る式と中置バイナリ演算子を組み合わせます。形式は次のとおりです: -![バイナリ式](../assets/binary_expression.png) +```swift +<#left-hand argument#> <#operator#> <#right-hand argument#> +``` これらの演算子の動作については、[Basic Operators\(基本演算子\)](../language-guide/basic-operators.md) と [Advanced Operators\(高度な演算子\)](../language-guide/advanced-operators.md)を参照ください。 @@ -125,18 +145,25 @@ _中置式_は、左右の引数を受け取る式と中置バイナリ演算子 > NOTE > 構文解析時には、式はバイナリ演算子のフラットなリストを構成します。このリストは、演算子の優先順位を適用することによってツリーに変換されます。例えば、式 `2 + 3 * 5` は、最初は5つの項目、`2`、`+`、`3`、`*`、および `5` として解釈され、その後 `(2 + (3 * 5))` のツリーに変換します -> GRAMMAR OF A INFIX EXPRESSION -> infix-expression → [infix-operator](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_infix-operator) [prefix-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_prefix-expression) -> infix-expression → [assignment-operator](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_assignment-operator)opt [prefix-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_prefix-expression) -> infix-expression → [conditional-operator](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_conditional-operator)opt [prefix-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_prefix-expression) -> infix-expression → [type-casting-operator](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_type-casting-operator) -> infix-expressions → [infix-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_infix-expression) [infix-expressions](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_infix-expressions)opt +> Grammar of an infix expression: +> +> *infix-expression* → *infix-operator* *prefix-expression* +> +> *infix-expression* → *assignment-operator* *try-operator*_?_ *prefix-expression* +> +> *infix-expression* → *conditional-operator* *try-operator*_?_ *prefix-expression* +> +> *infix-expression* → *type-casting-operator* +> +> *infix-expressions* → *infix-expression* *infix-expressions*_?_ ### 代入演算子\(Assignment Operator\) 代入演算子は特定の式に新しい値を設定します。形式は次のとおりです: -![代入演算子](../assets/assignment_operator.png) +```swift +<#expression#> = <#value#> +``` value を評価した結果得られた値が expression に設定されます。式がタプルの場合、値は同じ数の要素を持つタプルでなければなりません。\(タプルはネストすることもできます\)。代入は、値の各部分から expression の中の対応する部分に対して行われます。例えば: @@ -147,21 +174,25 @@ value を評価した結果得られた値が expression に設定されます 代入演算子は任意の値を返しません。 -> GRAMMAR OF AN asSIGNMENT OPERATOR -> assignment-operator → `=` +> Grammar of an assignment operator: +> +> *assignment-operator* → **`=`** ### 三項条件演算子\(Ternary Conditional Operator\) 三項条件演算子は、条件の値に基づいて、2 つの値のうちの 1 つに評価されます。形式は次のとおりです: -![三項条件演算子](../assets/ternary_conditional_operator.png) +```swift +<#condition#> ? <#expression used if true#> : <#expression used if false#> +``` 条件が `true` と評価された場合、条件演算子は最初の式を評価し、その値を返します。それ以外の場合は、2 番目の式を評価してその値を返します。未使用の式は評価されません。 三項条件演算子を使用する例については、[Ternary Conditional Operator\(三項条件演算子\)](../language-guide/basic-operators.md#basic-operator-ternary-conditional-operator)を参照ください。 -> GRAMMAR OF A CONDITIONAL OPERATOR -> conditional-operator → `?` [expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) `:` +> Grammar of a conditional operator: +> +> *conditional-operator* → **`?`** *expression* **`:`** ### Type-Casting Operators\(型キャスト演算子\) @@ -169,7 +200,12 @@ value を評価した結果得られた値が expression に設定されます それらは次の形式を持っています: -![型キャスト演算子](../assets/type_casting_operator.png) +```swift +<#expression#> is <#type#> +<#expression#> as <#type#> +<#expression#> as? <#type#> +<#expression#> as! <#type#> +``` `is` 演算子は実行時に式が指定された型にキャストできるかどうかを確認します。キャストできる場合は `true` を返します。それ以外の場合は、`false` を返します。 @@ -198,30 +234,47 @@ f(x as Any) 型キャストの詳細や型キャスト演算子を使用する例については、[Type Casting\(型キャスト\)](../language-guide/type-casting.md)を参照ください。 -> GRAMMAR OF A TYPE-CASTING OPERATOR -> type-casting-operator → `is` [type](https://docs.swift.org/swift-book/ReferenceManual/Types.html#grammar_type) -> type-casting-operator → `as` [type](https://docs.swift.org/swift-book/ReferenceManual/Types.html#grammar_type) -> type-casting-operator → `as` `?` [type](https://docs.swift.org/swift-book/ReferenceManual/Types.html#grammar_type) -> type-casting-operator → `as` `!` [type](https://docs.swift.org/swift-book/ReferenceManual/Types.html#grammar_type) +> Grammar of a type-casting operator: +> +> *type-casting-operator* → **`is`** *type* +> +> *type-casting-operator* → **`as`** *type* +> +> *type-casting-operator* → **`as`** **`?`** *type* +> +> *type-casting-operator* → **`as`** **`!`** *type* ## 基本式\(Primary Expressions\) 基本式は最も基本的な種類の式です。それらは自身を式として使用したり、他のトークンと組み合わせたり、前置式、バイナリ式、および後置式を作成することができます。 -> GRAMMAR OF A PRIMARY EXPRESSION -> primary-expression → [identifier](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_identifier) [generic-argument-clause](https://docs.swift.org/swift-book/ReferenceManual/GenericParametersAndArguments.html#grammar_generic-argument-clause)opt -> primary-expression → [literal-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_literal-expression) -> primary-expression → [self-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_self-expression) -> primary-expression → [superclass-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_superclass-expression) -> *primary-expression* → *conditional-expression* -> primary-expression → [closure-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_closure-expression) -> primary-expression → [parenthesized-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_parenthesized-expression) -> primary-expression → [tuple-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_tuple-expression) -> primary-expression → [implicit-member-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_implicit-member-expression) -> primary-expression → [wildcard-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_wildcard-expression) -> primary-expression → [key-path-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_key-path-expression) -> primary-expression → [selector-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_selector-expression) -> primary-expression → [key-path-string-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_key-path-string-expression) +> Grammar of a primary expression: +> +> *primary-expression* → *identifier* *generic-argument-clause*_?_ +> +> *primary-expression* → *literal-expression* +> +> *primary-expression* → *self-expression* +> +> *primary-expression* → *superclass-expression* +> +> *primary-expression* → *conditional-expression* +> +> *primary-expression* → *closure-expression* +> +> *primary-expression* → *parenthesized-expression* +> +> *primary-expression* → *tuple-expression* +> +> *primary-expression* → *implicit-member-expression* +> +> *primary-expression* → *wildcard-expression* +> +> *primary-expression* → *key-path-expression* +> +> *primary-expression* → *selector-expression* +> +> *primary-expression* → *key-path-string-expression* ### リテラル式\(Literal Expression\) @@ -259,7 +312,9 @@ func myFunction() { _配列リテラル_は、順序付けられた値の集合です。形式は次のとおりです: -![配列リテラル](../assets/array_expression.png) +```swift +[<#value 1#>, <#value 2#>, <#...#>] +``` 配列内の最後の式の後にカンマ\(`,`\)を続けることもできます。配列リテラルの値は `[T]` 型で、`T` はその内部の式の型です。複数の型の式がある場合、`T` はそれらに最も近い共通のスーパー型になります。空の配列リテラルは、空の角括弧\(`[]`\)を使用し、指定された型の空の配列を作成するためにも使用できます。 @@ -269,7 +324,9 @@ var emptyArray: [Double] = [] _辞書リテラル_は、順序のないキーバリューペアのコレクションです。形式は次のとおりです: -![辞書リテラル](../assets/dictionary_expression.png) +```swift +[<#key 1#>: <#value 1#>, <#key 2#>: <#value 2#>, <#...#>] +``` 辞書内の最後の式の後にカンマ\(`,`\)を続けることができます。辞書リテラルの値は `[Key：Value]` 型で、`Key` はそのキー式の型、`Value` はその値式の型です。複数の型の式がある場合、キーとバリューはそれぞれの値に最も近い共通のスーパー型になります。空の辞書リテラルは、空の配列リテラルと区別するために、一対の括弧内にコロンを書きます\(`[:]`\)。空の辞書リテラルを使用して、指定されたキーとバリュー型の空の辞書リテラルを作成できます。 @@ -281,26 +338,51 @@ _playground リテラル_は、プログラムエディタ内の色、ファイ Xcode の playground リテラルの使用方法については、Xcode ヘルプ内の[Add a color, file, or image literal](https://help.apple.com/xcode/mac/current/#/dev4c60242fc)を参照ください。 -> GRAMMAR OF A LITERAL EXPRESSION -> literal-expression → [literal](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_literal) -> literal-expression → [array-literal](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_array-literal) \| [dictionary-literal](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_dictionary-literal) \| [playground-literal](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_playground-literal) -> literal-expression → `#file` \| `#fileID` \| `#filePath` -> literal-expression → `#line` \| `#column` \| `#function` \| `#dsohandle` -> array-literal → `[` [array-literal-items](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_array-literal-items)opt `]` -> array-literal-items → [array-literal-item](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_array-literal-item) `,`opt \| [array-literal-item](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_array-literal-item) `,` [array-literal-items](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_array-literal-items) -> array-literal-item → [expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) -> dictionary-literal → `[` [dictionary-literal-items](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_dictionary-literal-items) `]` \| `[` `:` `]` -> dictionary-literal-items → [dictionary-literal-item](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_dictionary-literal-item) `,`opt \| [dictionary-literal-item](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_dictionary-literal-item) `,` [dictionary-literal-items](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_dictionary-literal-items) -> dictionary-literal-item → [expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) `:` [expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) -> playground-literal → `#colorLiteral` `(` `red` `:` [expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) `,` `green` `:` [expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) `,` `blue` `:`[expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) `,` `alpha` `:` [expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) `)` -> playground-literal → `#fileLiteral` `(` `resourceName` `:` [expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) `)` -> playground-literal → `#imageLiteral` `(` `resourceName` `:` [expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) `)` +> Grammar of a literal expression: +> +> *literal-expression* → *literal* +> +> *literal-expression* → *array-literal* | *dictionary-literal* | *playground-literal* +> +> *literal-expression* → **`#file`** | **`#fileID`** | **`#filePath`** +> +> *literal-expression* → **`#line`** | **`#column`** | **`#function`** | **`#dsohandle`** +> +> +> +> *array-literal* → **`[`** *array-literal-items*_?_ **`]`** +> +> *array-literal-items* → *array-literal-item* **`,`**_?_ | *array-literal-item* **`,`** *array-literal-items* +> +> *array-literal-item* → *expression* +> +> +> +> *dictionary-literal* → **`[`** *dictionary-literal-items* **`]`** | **`[`** **`:`** **`]`** +> +> *dictionary-literal-items* → *dictionary-literal-item* **`,`**_?_ | *dictionary-literal-item* **`,`** *dictionary-literal-items* +> +> *dictionary-literal-item* → *expression* **`:`** *expression* +> +> +> +> *playground-literal* → **`#colorLiteral`** **`(`** **`red`** **`:`** *expression* **`,`** **`green`** **`:`** *expression* **`,`** **`blue`** **`:`** *expression* **`,`** **`alpha`** **`:`** *expression* **`)`** +> +> *playground-literal* → **`#fileLiteral`** **`(`** **`resourceName`** **`:`** *expression* **`)`** +> +> *playground-literal* → **`#imageLiteral`** **`(`** **`resourceName`** **`:`** *expression* **`)`** ### self 式\(Self Expression\) `self` 式は、それが使用さえている現在の型またはインスタンスへの明示的な参照です。形式は次のとおりです: -![Self式](../assets/self_expression.png) +```swift +self +self.<#member name#> +self[<#subscript index#>] +self(<#initializer arguments#>) +self.init(<#initializer arguments#>) +``` イニシャライザ、サブスクリプト、またはインスタンスメソッドでは、`self` は、それが出現する現在の型のインスタンスを表します。型メソッドでは、`self` はそれが登場する現在の型を表します。 @@ -326,27 +408,43 @@ struct Point { } ``` -> GRAMMAR OF A SELF EXPRESSION -> self-expression → `self` \| [self-method-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_self-method-expression) \| [self-subscript-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_self-subscript-expression) \| [self-initializer-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_self-initializer-expression) -> self-method-expression → `self` `.` [identifier](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_identifier) -> self-subscript-expression → `self` `[` [function-call-argument-list](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_function-call-argument-list) `]` -> self-initializer-expression → `self` `.` `init` +> Grammar of a self expression: +> +> *self-expression* → **`self`** | *self-method-expression* | *self-subscript-expression* | *self-initializer-expression* +> +> +> +> *self-method-expression* → **`self`** **`.`** *identifier* +> +> *self-subscript-expression* → **`self`** **`[`** *function-call-argument-list* **`]`** +> +> *self-initializer-expression* → **`self`** **`.`** **`init`** ### スーパークラス式\(Superclass Expression\) _スーパークラス式_は、クラスがスーパークラスとやり取りすることを可能にします。次のいずれかの形式があります: -![スーパークラス式](../assets/superclass_expression.png) +```swift +super.<#member name#> +super[<#subscript index#>] +super.init(<#initializer arguments#>) +``` 最初の形式はスーパークラスのメンバにアクセスするために使用されます。2 番目の形式は、スーパークラスのサブスクリプトの実装にアクセスするために使用されます。3 番目の形式は、スーパークラスのイニシャライザにアクセスするために使用されます。 サブクラスは、スーパークラスの実装を利用するために、メンバ、サブスクリプト、およびイニシャライザの実装でスーパークラス式を使用できます。 -> GRAMMAR OF A SUPERCLASS EXPRESSION -> superclass-expression → [superclass-method-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_superclass-method-expression) \| [superclass-subscript-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_superclass-subscript-expression) \| [superclass-initializer-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_superclass-initializer-expression) -> superclass-method-expression → `super` `.` [identifier](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_identifier) -> superclass-subscript-expression → `super` `[` [function-call-argument-list](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_function-call-argument-list) `]` -> superclass-initializer-expression → `super` `.` `init` +> Grammar of a superclass expression: +> +> *superclass-expression* → *superclass-method-expression* | *superclass-subscript-expression* | *superclass-initializer-expression* +> +> +> +> *superclass-method-expression* → **`super`** **`.`** *identifier* +> +> *superclass-subscript-expression* → **`super`** **`[`** *function-call-argument-list* **`]`** +> +> *superclass-initializer-expression* → **`super`** **`.`** **`init`** ### 条件式\(Conditional Expression\) @@ -424,13 +522,21 @@ let number = if someCondition { 10 as Double } else { 12.34 } _クロージャ式_は、他のプログラミング言語では、_ラムダ_または_匿名関数_とも呼ばれているクロージャを作成します。関数宣言のように、クロージャには文が含まれており、その囲まれている範囲から定数と変数をキャプチャします。形式は次のとおりです: -![クロージャ式](../assets/closure_expression.png) +```swift +{ (<#parameters#>) -> <#return type#> in + <#statements#> +} +``` [Function Declaration\(関数宣言\)](../language-reference/declarations.md#function-declaration)で説明されているように、_parameters_は関数宣言内のパラメータと同じ形式です。 クロージャ式で `throw` または `async` を記述すると、クロージャはエラーをスローする、または非同期であることを明示します。 -![throwやawaitがマークしたクロージャ式](../assets/await_throw_closure_expression.png) +```swift +{ (<#parameters#>) async throws -> <#return type#> in + <#statements#> +} +``` クロージャの本文に `try` 式が含まれている場合、クロージャはエラーをスローすると見なします。同様に、`await` 式が含まれている場合は、非同期であると見なします。 @@ -522,27 +628,49 @@ myFunction { [weak parent = self.parent] in print(parent!.title) } クロージャ式の詳細と例については、[Closure Expressions\(クロージャ式\)](../language-guide/closures.md#closure-expressions)を参照ください。キャプチャリストの詳細および例については、[Resolving Strong Reference Cycles for Closures\(クロージャの強循環参照の解消\)](../language-guide/automatic-reference-counting.md#resolving-strong-reference-cycles-for-closures)を参照ください。 -> GRAMMAR OF A CLOSURE EXPRESSION -> closure-expression → `{` [closure-signature](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_closure-signature)opt [statements](https://docs.swift.org/swift-book/ReferenceManual/Statements.html#grammar_statements)opt `}` -> closure-signature → [capture-list](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_capture-list)opt [closure-parameter-clause](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_closure-parameter-clause) `throws`opt [function-result](https://docs.swift.org/swift-book/ReferenceManual/Declarations.html#grammar_function-result)opt `in` -> closure-signature → [capture-list](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_capture-list) `in` -> closure-parameter-clause → `(` `)` \| `(` [closure-parameter-list](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_closure-parameter-list) `)` \| [identifier-list](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_identifier-list) -> closure-parameter-list → [closure-parameter](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_closure-parameter) \| [closure-parameter](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_closure-parameter) `,` [closure-parameter-list](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_closure-parameter-list) -> closure-parameter → [closure-parameter-name](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_closure-parameter-name) [type-annotation](https://docs.swift.org/swift-book/ReferenceManual/Types.html#grammar_type-annotation)opt -> closure-parameter → [closure-parameter-name](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_closure-parameter-name) [type-annotation](https://docs.swift.org/swift-book/ReferenceManual/Types.html#grammar_type-annotation) `...` -> closure-parameter-name → [identifier](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_identifier) -> capture-list → `[` [capture-list-items](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_capture-list-items) `]` -> capture-list-items → [capture-list-item](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_capture-list-item) \| [capture-list-item](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_capture-list-item) `,` [capture-list-items](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_capture-list-items) -> capture-list-item → [capture-specifier](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_capture-specifier)opt [identifier](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_identifier) -> capture-list-item → [capture-specifier](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_capture-specifier)opt [identifier](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_identifier) `=` [expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) -> capture-list-item → [capture-specifier](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_capture-specifier)opt [self-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_self-expression) -> capture-specifier → `weak` \| `unowned` \| `unowned(safe)` \| `unowned(unsafe)` +> Grammar of a closure expression: +> +> *closure-expression* → **`{`** *attributes*_?_ *closure-signature*_?_ *statements*_?_ **`}`** +> +> +> +> *closure-signature* → *capture-list*_?_ *closure-parameter-clause* **`async`**_?_ **`throws`**_?_ *function-result*_?_ **`in`** +> +> *closure-signature* → *capture-list* **`in`** +> +> +> +> *closure-parameter-clause* → **`(`** **`)`** | **`(`** *closure-parameter-list* **`)`** | *identifier-list* +> +> *closure-parameter-list* → *closure-parameter* | *closure-parameter* **`,`** *closure-parameter-list* +> +> *closure-parameter* → *closure-parameter-name* *type-annotation*_?_ +> +> *closure-parameter* → *closure-parameter-name* *type-annotation* **`...`** +> +> *closure-parameter-name* → *identifier* +> +> +> +> *capture-list* → **`[`** *capture-list-items* **`]`** +> +> *capture-list-items* → *capture-list-item* | *capture-list-item* **`,`** *capture-list-items* +> +> *capture-list-item* → *capture-specifier*_?_ *identifier* +> +> *capture-list-item* → *capture-specifier*_?_ *identifier* **`=`** *expression* +> +> *capture-list-item* → *capture-specifier*_?_ *self-expression* +> +> *capture-specifier* → **`weak`** | **`unowned`** | **`unowned(safe)`** | **`unowned(unsafe)`** ### 暗黙メンバ式\(Implicit Member Expression\) _暗黙メンバ式_は、型推論によって暗黙的に型を決定できるコンテキストにおいて、列挙ケースや型メソッドなどの型のメンバにアクセスするための省略記法です。形式は次のとおりです: -![暗黙メンバ式](../assets/implicit_member_expression.png) +```swift +.<#member name#> +``` 例えば: @@ -577,21 +705,27 @@ let z: SomeClass = .sharedSubclass 上記のコードでは、`x` の型はそのコンテキストから暗黙的に推論された型と正確に一致し、`y` の型は `Someclass` から `SomeClass?` に変換され、`z` の型は `SomeSubclass` から `SomeClass` に変換されます。 -> GRAMMAR OF A IMPLICIT MEMBER EXPRESSION -> implicit-member-expression → `.` [identifier](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_identifier) +> Grammar of a implicit member expression: +> +> *implicit-member-expression* → **`.`** *identifier* +> +> *implicit-member-expression* → **`.`** *identifier* **`.`** *postfix-expression* ### 括弧で囲まれた式\(Parenthesized Expression\) _括弧で囲まれた式_は、括弧で囲まれた式で構成されます。式を明示的にグループ化することで、括弧を使用して操作の優先順位を指定できます。括弧のグループ化は式の型を変更しません\(例：`(1)` はただの `Int` です。 -> GRAMMAR OF A PARENTHESIZED EXPRESSION -> parenthesized-expression → `(` [expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) `)` +> Grammar of a parenthesized expression: +> +> *parenthesized-expression* → **`(`** *expression* **`)`** ### タプル式\(Tuple Expression\) タプル式は、括弧で囲まれた式のカンマ区切りのリストで構成されています。各式は、コロン\(`:`\)で区切られ、その前に識別子を指定することもできます。形式は次のとおりです: -![タプル式](../assets/tuple_expression.png) +```swift +(<#identifier 1#>: <#expression 1#>, <#identifier 2#>: <#expression 2#>, <#...#>) +``` _タプル式_の各識別子は、タプル式の範囲内で一意な必要があります。ネストしたタプル式では、同じレベルでネスト識別子を一意にする必要があります。例えば、`(a: 10, a: 20)` はラベル `a` が同じレベルで 2 回使用されているため無効です。ただし、`(a: 10, b: (a: 1, x: 2))` は有効です。`a` は 2 回使用されていますが、外側のタプルに 1 回、内側のタプルに 1 回使用されています。 @@ -599,11 +733,14 @@ _タプル式_の各識別子は、タプル式の範囲内で一意な必要が > NOTE > 空のタプル式と空のタプル型はいずれもSwiftでは `()` で書きます。`Void` は `()` のタイプエイリアスのため、空のタプル型を書くために使用できます。ただし、全てのタイプエイリアスと同様に、`Void` は常に型で、空のタプル式を書くためには使用できません。 + +> Grammar of a tuple expression: > -> GRAMMAR OF A TUPLE EXPRESSION -> tuple-expression → `(` `)` \| `(` [tuple-element](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_tuple-element) `,` [tuple-element-list](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_tuple-element-list) `)` -> tuple-element-list → [tuple-element](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_tuple-element) \| [tuple-element](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_tuple-element) `,` [tuple-element-list](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_tuple-element-list) -> tuple-element → [expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) \| [identifier](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_identifier) `:` [expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) +> *tuple-expression* → **`(`** **`)`** | **`(`** *tuple-element* **`,`** *tuple-element-list* **`)`** +> +> *tuple-element-list* → *tuple-element* | *tuple-element* **`,`** *tuple-element-list* +> +> *tuple-element* → *expression* | *identifier* **`:`** *expression* ### ワイルドカード式\(Wildcard Expression\) @@ -614,14 +751,17 @@ _タプル式_の各識別子は、タプル式の範囲内で一意な必要が // x は 10 で 20 は 無視されます ``` -> GRAMMAR OF A WILDCARD EXPRESSION -> wildcard-expression → `_` +> Grammar of a wildcard expression: +> +> *wildcard-expression* → **`_`** ### KeyPath 式\(Key-Path Expression\) _KeyPath 式_は、型のプロパティまたはサブスクリプトを参照します。key-value observing などのような、動的プログラミングのタスクで KeyPath 式を使用します。次の形式があります: -![Key-Path 式](../assets/key-path_expression.png) +```swift +\<#type name#>.<#path#> +``` _type name_ は、`String`、`[Int]`、や `Set` などのジェネリックなパラメータを含めた、具体的な型の名前です。 @@ -778,18 +918,29 @@ let someTask = toDoList[keyPath: taskKeyPath] Objective-C API とやり取りするコード内の KeyPath の使用方法の詳細については、[Using Objective-C Runtime Features in Swift](https://developer.apple.com/documentation/swift/using_objective_c_runtime_features_in_swift)を参照ください。Key-Value Coding や Key-Value Observing については、[Key-Value Coding Programming Guide](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/KeyValueCoding/index.html#//apple_ref/doc/uid/10000107i)と[Key-Value Observing Programming Guide](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/KeyValueObserving/KeyValueObserving.html#//apple_ref/doc/uid/10000177i)を参照ください。 -> GRAMMAR OF A KEY-PATH EXPRESSION -> key-path-expression → `\` [type](https://docs.swift.org/swift-book/ReferenceManual/Types.html#grammar_type)opt `.` [key-path-components](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_key-path-components) -> key-path-components → [key-path-component](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_key-path-component) \| [key-path-component](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_key-path-component) `.` [key-path-components](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_key-path-components) -> key-path-component → [identifier](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_identifier) [key-path-postfixes](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_key-path-postfixes)opt \| [key-path-postfixes](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_key-path-postfixes) -> key-path-postfixes → [key-path-postfix](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_key-path-postfix) [key-path-postfixes](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_key-path-postfixes)opt -> key-path-postfix → `?` \| `!` \| `self` \| `[` [function-call-argument-list](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_function-call-argument-list) `]` +> Grammar of a key-path expression: +> +> *key-path-expression* → **`\`** *type*_?_ **`.`** *key-path-components* +> +> *key-path-components* → *key-path-component* | *key-path-component* **`.`** *key-path-components* +> +> *key-path-component* → *identifier* *key-path-postfixes*_?_ | *key-path-postfixes* +> +> +> +> *key-path-postfixes* → *key-path-postfix* *key-path-postfixes*_?_ +> +> *key-path-postfix* → **`?`** | **`!`** | **`self`** | **`[`** *function-call-argument-list* **`]`** ### Selector 式\(Selector Expression\) セレクタ式を使用すると、Objective-C のメソッドまたはプロパティの get や set を参照するために使用されるセレクタにアクセスできます。形式は次のとおりです: -![Selector 式](../assets/selector_expression.png) +```swift +#selector(<#method name#>) +#selector(getter: <#property name#>) +#selector(setter: <#property name#>) +``` メソッド名とプロパティ名は、Objective-C ランタイムで使用可能なメソッドまたはプロパティを参照する必要があります。セレクタ式の値は `Selector` 型のインスタンスです。例えば: @@ -827,16 +978,21 @@ let anotherSelector = #selector(SomeClass.doSomething(_:) as (SomeClass) -> (Str Objective-C API とやり取りする Swift コードでセレクタを使用する方法の詳細については、[Using Objective-C Runtime Features in Swift](https://developer.apple.com/documentation/swift/using_objective_c_runtime_features_in_swift)を参照ください。 -> GRAMMAR OF A SELECTOR EXPRESSION -> selector-expression → `#selector` `(` [expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) `)` -> selector-expression → `#selector` `(` `getter:` [expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) `)` -> selector-expression → `#selector` `(` `setter:` [expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) `)` +> Grammar of a selector expression: +> +> *selector-expression* → **`#selector`** **`(`** *expression* **`)`** +> +> *selector-expression* → **`#selector`** **`(`** **`getter:`** *expression* **`)`** +> +> *selector-expression* → **`#selector`** **`(`** **`setter:`** *expression* **`)`** ### KeyPath 文字列式\(Key-Path String Expression\) KeyPath 文字列式を使用すると、Key-Value Coding や Key-Value Observing API で使用するために、Objective-C のプロパティを参照するための文字列にアクセスできます。形式は次のとおりです: -![Key-Path文字列式](../assets/key-path_string_expression.png) +```swift +#keyPath(<#property name#>) +``` _property name_ は、Objective-C ランタイムで使用可能なプロパティを参照する必要があります。コンパイル時には、KeyPath 文字列式は文字列リテラルに置き換えられます。例えば: @@ -875,9 +1031,10 @@ Objective-C API とやり取りする Swift コードで KeyPath を使用する > NOTE > プロパティ名は式ですが、それらは決して評価されません。 + +> Grammar of a key-path string expression: > -> GRAMMAR OF A KEY-PATH STRING EXPRESSION -> key-path-string-expression → `#keyPath` `(` [expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) `)` +> *key-path-string-expression* → **`#keyPath`** **`(`** *expression* **`)`** ## 後置式\(Postfix Expressions\) @@ -887,28 +1044,41 @@ _後置式_は、後置演算子またはその他の後置構文を式に適用 Swift 標準ライブラリによって提供されている演算子については、[Operator Declarations\(演算子宣言\)](https://developer.apple.com/documentation/swift/swift_standard_library/operator_declarations)を参照ください。 -> GRAMMAR OF A POSTFIX EXPRESSION -> postfix-expression → [primary-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_primary-expression) -> postfix-expression → [postfix-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_postfix-expression) [postfix-operator](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_postfix-operator) -> postfix-expression → [function-call-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_function-call-expression) -> postfix-expression → [initializer-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_initializer-expression) -> postfix-expression → [explicit-member-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_explicit-member-expression) -> postfix-expression → [postfix-self-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_postfix-self-expression) -> postfix-expression → [subscript-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_subscript-expression) -> postfix-expression → [forced-value-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_forced-value-expression) -> postfix-expression → [optional-chaining-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_optional-chaining-expression) +> Grammar of a postfix expression: +> +> *postfix-expression* → *primary-expression* +> +> *postfix-expression* → *postfix-expression* *postfix-operator* +> +> *postfix-expression* → *function-call-expression* +> +> *postfix-expression* → *initializer-expression* +> +> *postfix-expression* → *explicit-member-expression* +> +> *postfix-expression* → *postfix-self-expression* +> +> *postfix-expression* → *subscript-expression* +> +> *postfix-expression* → *forced-value-expression* +> +> *postfix-expression* → *optional-chaining-expression* ### 関数呼び出し式\(Function Call Expression\) _関数呼び出し式_は、関数名とそれに続く関数の引数のカンマ区切りのリストからなる関数名で構成されています。関数呼び出し式は形式は次のとおりです: -![関数呼び出し式1](../assets/function_call_expression1.png) +```swift +<#function name#>(<#argument value 1#>, <#argument value 2#>) +``` _function name_ は、関数型の任意の式です。 関数定義にパラメータ名が含まれている場合、関数呼び出しは、コロン\(`:`\)で区切られた引数値の前に名前を含める必要があります。この種の関数呼び出し式は形式は次のとおりです: -![パラメータ名を含んだ関数呼び出し式](../assets/function_call_expression2.png) +```swift +<#function name#>(<#argument name 1#>: <#argument value 1#>, <#argument name 2#>: <#argument value 2#>) +``` 関数呼び出し式は、閉じ括弧\(`}`\)の直後にクロージャ式の形で末尾クロージャを含めることができます。末尾クロージャは、最後の括弧内の引数の後の関数型の引数と解釈されます。最初のクロージャ式に引数ラベルは付けません。次のクロージャ式の前には引数ラベルを付けます。下記の例は、末尾クロージャの構文を使用して、 末尾クロージャを使用しない関数呼び出しバージョンと同等だということを示しています: @@ -998,22 +1168,37 @@ withUnsafePointer(to: myNumber) { unsafeFunction(pointer: $0) } `withUnsafePointer(to:)` のような明示的な機能の代わりに、`&` を使うことで、低レベルの C 言語の関数を呼び出しやすくするのに役立ちます。ただし、他の Swift コードから関数を呼び出すときは、安全でない API を明示的に使用する代わりとして `&` を使用しないでください。 -> GRAMMAR OF A FUNCTION CALL EXPRESSION -> function-call-expression → [postfix-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_postfix-expression) [function-call-argument-clause](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_function-call-argument-clause) -> function-call-expression → [postfix-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_postfix-expression) [function-call-argument-clause](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_function-call-argument-clause)opt [trailing-closures](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_trailing-closures) -> function-call-argument-clause → `(` `)` \| `(` [function-call-argument-list](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_function-call-argument-list) `)` -> function-call-argument-list → [function-call-argument](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_function-call-argument) \| [function-call-argument](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_function-call-argument) `,` [function-call-argument-list](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_function-call-argument-list) -> function-call-argument → [expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) \| [identifier](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_identifier) `:` [expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_expression) -> function-call-argument → [operator](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_operator) \| [identifier](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_identifier) `:` [operator](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_operator) -> trailing-closures → [closure-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_closure-expression) [labeled-trailing-closures](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_labeled-trailing-closures)opt -> labeled-trailing-closures → [labeled-trailing-closure](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_labeled-trailing-closure) [labeled-trailing-closures](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_labeled-trailing-closures)opt -> labeled-trailing-closure → [identifier](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_identifier) `:` [closure-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_closure-expression) +> Grammar of a function call expression: +> +> *function-call-expression* → *postfix-expression* *function-call-argument-clause* +> +> *function-call-expression* → *postfix-expression* *function-call-argument-clause*_?_ *trailing-closures* +> +> +> +> *function-call-argument-clause* → **`(`** **`)`** | **`(`** *function-call-argument-list* **`)`** +> +> *function-call-argument-list* → *function-call-argument* | *function-call-argument* **`,`** *function-call-argument-list* +> +> *function-call-argument* → *expression* | *identifier* **`:`** *expression* +> +> *function-call-argument* → *operator* | *identifier* **`:`** *operator* +> +> +> +> *trailing-closures* → *closure-expression* *labeled-trailing-closures*_?_ +> +> *labeled-trailing-closures* → *labeled-trailing-closure* *labeled-trailing-closures*_?_ +> +> *labeled-trailing-closure* → *identifier* **`:`** *closure-expression* ### イニシャライザ式\(Initializer Expression\) _イニシャライザ式_は型のイニシャライザへアクセスします。形式は次のとおりです: -![イニシャライザ式](../assets/initializer_expression.png) +```swift +<#expression#>.init(<#initializer arguments#>) +``` イニシャライザ式を使用して、型の新しいインスタンスを初期化します。スーパークラスのイニシャライザに委譲するイニシャライザ式を使用することもできます。 @@ -1046,15 +1231,19 @@ let s3 = type(of: someValue).init(data: 7) // 有効 let s4 = type(of: someValue)(data: 5) // エラー ``` -> GRAMMAR OF AN INITIALIZER EXPRESSION -> initializer-expression → [postfix-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_postfix-expression) `.` `init` -> initializer-expression → [postfix-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_postfix-expression) `.` `init` `(` [argument-names](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_argument-names) `)` +> Grammar of an initializer expression: +> +> *initializer-expression* → *postfix-expression* **`.`** **`init`** +> +> *initializer-expression* → *postfix-expression* **`.`** **`init`** **`(`** *argument-names* **`)`** ### 明示的メンバ式\(Explicit Member Expression\) _明示的メンバ式_では、名前付き型、タプル、またはモジュールのメンバへアクセスできます。アイテムとそのメンバの識別子の間のピリオド\(`.`\)で構成されています。 -![明示的メンバ式](../assets/explicit_member_expression.png) +```swift +<#expression#>.<#member name#> +``` 名前付き型のメンバは、型の宣言または extension の一部で指定されます。例えば: @@ -1123,45 +1312,62 @@ let numbers = [10, 20, 33, 43, 50] 条件付きコンパイルブロックの中では、`#if` コンパイルディレクティブの条件分岐は、少なくとも 1 つの式を含めなければなりません。その他の分岐は空でも構いません。 -> GRAMMAR OF AN EXPLICIT MEMBER EXPRESSION -> explicit-member-expression → [postfix-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_postfix-expression) `.` [decimal-digits](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_decimal-digits) -> explicit-member-expression → [postfix-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_postfix-expression) `.` [identifier](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_identifier) [generic-argument-clause](https://docs.swift.org/swift-book/ReferenceManual/GenericParametersAndArguments.html#grammar_generic-argument-clause)opt -> explicit-member-expression → [postfix-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_postfix-expression) `.` [identifier](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_identifier) `(` [argument-names](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_argument-names) `)` -> explicit-member-expression → [postfix-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_postfix-expression) [conditional-compilation-block](https://docs.swift.org/swift-book/ReferenceManual/Statements.html#grammar_conditional-compilation-block) -> argument-names → [argument-name](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_argument-name) [argument-names](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_argument-names)opt -> argument-name → [identifier](https://docs.swift.org/swift-book/ReferenceManual/LexicalStructure.html#grammar_identifier) `:` +> Grammar of an explicit member expression: +> +> *explicit-member-expression* → *postfix-expression* **`.`** *decimal-digits* +> +> *explicit-member-expression* → *postfix-expression* **`.`** *identifier* *generic-argument-clause*_?_ +> +> *explicit-member-expression* → *postfix-expression* **`.`** *identifier* **`(`** *argument-names* **`)`** +> +> *explicit-member-expression* → *postfix-expression* *conditional-compilation-block* +> +> +> +> *argument-names* → *argument-name* *argument-names*_?_ +> +> *argument-name* → *identifier* **`:`** ### 後置 self 式\(Postfix Self Expression\) 後置 `self` 式は、型や式の直後に `.self` を付けて構成します。次の形式があります: -![後置 self 式](../assets/postfix_self_expression.png) +```swift +<#expression#>.self +<#type#>.self +``` 最初の形式は _expression_ の値に評価されます。例えば、`x.self` は `x` と評価されます。 2 番目の形式は _type_ の値に評価されます。この形式を使用して、型に値としてアクセスできます。例えば、`SomeClass.self` は `SomeClass` 型自体に評価されるため、型レベルの引数を受け取る関数またはメソッドに渡すことができます。 -> GRAMMAR OF A POSTFIX SELF EXPRESSION -> postfix-self-expression → [postfix-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_postfix-expression) `.` `self` +> Grammar of a postfix self expression: +> +> *postfix-self-expression* → *postfix-expression* **`.`** **`self`** ### サブスクリプト式\(Subscript Expression\) _サブスクリプト式_は、対応するサブスクリプト宣言の get と set を使用してサブスクリプトへのアクセスすることができます。形式は次のとおりです: -![subscript式](../assets/subscript_expression.png) +```swift +<#expression#>[<#index expressions#>] +``` サブスクリプト式の値を評価するには、_expression_ 型のサブスクリプトの get をサブスクリプトのパラメータとして_インデックス式_を渡して呼び出します。値を設定するために、サブスクリプトの set を同じ方法で呼び出します。 サブスクリプト宣言については、[Protocol Subscript Declaration\(プロトコルサブスクリプト宣言\)](declarations.md#protocol-subscript-declaration)を参照ください。 -> GRAMMAR OF A SUBSCRIPT EXPRESSION -> subscript-expression → [postfix-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_postfix-expression) `[` [function-call-argument-list](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_function-call-argument-list) `]` +> Grammar of a subscript expression: +> +> *subscript-expression* → *postfix-expression* **`[`** *function-call-argument-list* **`]`** ### 強制アンラップ式\(Forced-Value Expression\) _強制アンラップ式_は、特定の値が `nil` ではないオプショナルの値を表します。形式は次のとおりです: -![強制アンラップ式](../assets/forced-Value_expression.png) +```swift +<#expression#>! +``` _expression_ の値が `nil` でない場合、オプショナルの値はアンラップされ、対応するオプショナルの非オプショナルの型で返されます。それ以外の場合は、実行時エラーが発生します。 @@ -1177,14 +1383,17 @@ someDictionary["a"]![0] = 100 // someDictionary は ["a": [100, 2, 3], "b": [10, 20]] ``` -> GRAMMAR OF A FORCED-VALUE EXPRESSION -> forced-value-expression → [postfix-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_postfix-expression) `!` +> Grammar of a forced-value expression: +> +> *forced-value-expression* → *postfix-expression* **`!`** ### オプショナルチェーン式\(Optional-Chaining Expression\) _オプショナルチェーン式_は後置式で、オプショナルの値を使用するための簡単な構文を提供します。形式は次のとおりです: -![オプショナルチェーン式](../assets/optional-chaining_expression.png) +```swift +<#expression#>? +``` 後置 `?` 演算子は式の値を変更せずに式からオプショナルチェーン式を作成します。 @@ -1223,6 +1432,7 @@ someDictionary["a"]?[0] = someFunctionWithSideEffects() // someDictionary は今 ["a": [42, 2, 3], "b": [10, 20]] ``` -> GRAMMAR OF AN OPTIONAL-CHAINING EXPRESSION -> optional-chaining-expression → [postfix-expression](https://docs.swift.org/swift-book/ReferenceManual/Expressions.html#grammar_postfix-expression) `?` +> Grammar of an optional-chaining expression: +> +> *optional-chaining-expression* → *postfix-expression* **`?`**