Expressions¶ 式¶

In-Out Expression¶ in-out式¶

An in-out expression marks a variable that’s being passed as an in-out argument to a function call expression. in-out expressionは、in-out引数として関数呼び出し式に渡されている変数を印します。

For more information about in-out parameters and to see an example, see In-Out Parameters. In-Outパラメータについてのより多くの情報のために、そして例を見るために、In-Outパラメータを見てください。

In-out expressions are also used when providing a non-pointer argument in a context where a pointer is needed, as described in Implicit Conversion to a Pointer Type. in-out式はまた、ポインタが必要とされる文脈において非ポインタ引数を提供する時に使われます、ポインタ型への暗黙的変換で記述されるように。

Try Operator¶ try演算子¶

A try expression consists of the try operator followed by an expression that can throw an error. It has the following form: try式は、try演算子と後につづくエラーをスローできる１つの式から成ります。それは、以下の形式を持ちます：

The value of a try expression is the value of the expression. try式の値は、expressionの値です。

An optional-try expression consists of the try? operator followed by an expression that can throw an error. It has the following form: オプショナルtry式は、try?演算子と後につづくエラーをスローできる１つの式から成ります。それは、以下の形式を持ちます：

If the expression doesn’t throw an error, the value of the optional-try expression is an optional containing the value of the expression. Otherwise, the value of the optional-try expression is nil. このexpression（式）がエラーをスローしないならば、オプショナルtry式の値はひとつのオプショナルになり、そのexpression（式）の値を含んでいます。そうでなければ、オプショナルtry式の値はnilです。

A forced-try expression consists of the try! operator followed by an expression that can throw an error. It has the following form: 強制try式は、try!演算子と後につづくエラーをスローできる１つの式から成ります。それは、以下の形式を持ちます：

The value of a forced-try expression is the value of the expression. If the expression throws an error, a runtime error is produced. 強制try式の値は、expressionの値です。このexpressionがエラーをスローするならば、実行時エラーが生み出されます。

When the expression on the left-hand side of an infix operator is marked with try, try?, or try!, that operator applies to the whole infix expression. That said, you can use parentheses to be explicit about the scope of the operator’s application. ある接中辞演算子の左手側での式がtry、try?、またはtry!で印される場合、その演算子は接中辞式全体に適用されます。とは言うものの、あなたは丸括弧を使って演算子の作用域について明確にすることができます。

A try expression can’t appear on the right-hand side of an infix operator, unless the infix operator is the assignment operator or the try expression is enclosed in parentheses. try式が接中辞演算子の右手側に現れることは、その接中辞演算子が代入演算子であるかtry式が丸括弧の中に入れられるかしない限りはできません。

If an expression includes both the try and await operator, the try operator must appear first. ある式がtryとawait演算子の両方を含むならば、try演算子は最初に現れなければなりません。

For more information and to see examples of how to use try, try?, and try!, see Error Handling. より多くの情報のために、そしてtry、try?、そしてtry!文を使う方法の例を見るために、エラーを処理するを見てください。

Await Operator¶ await演算子¶

An await expression consists of the await operator followed by an expression that uses the result of an asynchronous operation. It has the following form: await式は、await演算子と、非同期演算の結果を使うある式が続くものから成ります。それは、以下の形式を持ちます：

The value of an await expression is the value of the expression. await式の値は、expressionの値です。

An expression marked with await is called a potential suspension point. Execution of an asynchronous function can be suspended at each expression that’s marked with await. In addition, execution of concurrent code is never suspended at any other point. This means code between potential suspension points can safely update state that requires temporarily breaking invariants, provided that it completes the update before the next potential suspension point. awaitで印された式は、潜在的中断地点と呼ばれます。非同期関数の遂行は、awaitで印される式それぞれで中断されることが可能です。加えて、並行性コードの遂行は、他のどんな地点でも決して中断されません。これが意味するのは、潜在的中断地点の間のコードは、安全に状態を更新可能であるということです、それがその更新を次の潜在的中断地点の前に完了するという条件で。

An await expression can appear only within an asynchronous context, such as the trailing closure passed to the async(priority:operation:) function. It can’t appear in the body of a defer statement, or in an autoclosure of synchronous function type. await式は、非同期の文脈、たとえばasync(priority:operation:)関数に渡される後付クロージャなど、の内部でのみ現れることが可能です。それは、defer文の本体の中で、または同期関数型の自動クロージャの中で現れることができません。

When the expression on the left-hand side of an infix operator is marked with the await operator, that operator applies to the whole infix expression. That said, you can use parentheses to be explicit about the scope of the operator’s application. ある接中辞演算子の左手側での式がawait演算子で印される場合、その演算子は接中辞式全体に適用されます。とは言うものの、あなたは丸括弧を使って演算子の作用域について明確にすることができます。

An await expression can’t appear on the right-hand side of an infix operator, unless the infix operator is the assignment operator or the await expression is enclosed in parentheses. await式が接中辞演算子の右手側に現れることは、その接中辞演算子が代入演算子であるかawait式が丸括弧の中に入れられるかしない限りはできません。

If an expression includes both the await and try operator, the try operator must appear first. ある式がawaitとtry演算子の両方を含むならば、try演算子は最初に現れなければなりません。

Assignment Operator¶ 代入演算子¶

The assignment operator sets a new value for a given expression. It has the following form: 代入演算子は、指定された式に対してある新しい値を設定します。それは、以下の形式を持ちます：

The value of the expression is set to the value obtained by evaluating the value. If the expression is a tuple, the value must be a tuple with the same number of elements. (Nested tuples are allowed.) Assignment is performed from each part of the value to the corresponding part of the expression. For example: 式の値は、値を評価することによって得られる値に設定されます。式がタプルであるならば、値は同じ数の要素をもつタプルでなければなりません。（入れ子にされたタプルは、認められます）。代入は、値の各部分から式の対応する部分へと実行されます。例えば：

The assignment operator doesn’t return any value. 代入演算子は、少しの値も返しません。

Ternary Conditional Operator¶ 三項条件演算子¶

The ternary conditional operator evaluates to one of two given values based on the value of a condition. It has the following form: 三項条件演算子は、ある条件の値に基づいて、２つの与えられた値のうちの１つへと評価されます。それは、以下の形式を持ちます：

If the condition evaluates to true, the conditional operator evaluates the first expression and returns its value. Otherwise, it evaluates the second expression and returns its value. The unused expression isn’t evaluated. 条件がtrueに評価されるならば、条件演算子は最初の式を評価して、その値を返します。そうでなければ、それは第二の式を評価して、その値を返します。使っていない式は、評価されません。

For an example that uses the ternary conditional operator, see Ternary Conditional Operator. 三項条件演算子を使用する例のために、三項条件演算子を見てください。

Type-Casting Operators¶ 型キャスト演算子¶

There are four type-casting operators: the is operator, the as operator, the as? operator, and the as! operator. ４つの型キャスト演算子、is演算子、as演算子、as?演算子、そしてas!演算子があります。

They have the following form: これらは以下の形式を持ちます：

The is operator checks at runtime whether the expression can be cast to the specified type. It returns true if the expression can be cast to the specified type; otherwise, it returns false. is演算子は実行時に式が指定された型へとキャスト可能かどうかを調べます。それは、式が指定された型へキャストできるならばtrueを返します；そうでなければfalseを返します。

The as operator performs a cast when it’s known at compile time that the cast always succeeds, such as upcasting or bridging. Upcasting lets you use an expression as an instance of its type’s supertype, without using an intermediate variable. The following approaches are equivalent: as演算子は、コンパイル時にそのキャストが常に成功することを知られているキャストを実行します、例えばアップキャストやブリッジなど。アップキャストは、あなたにある式をそれのスーパータイプのインスタンスとして使用させます、中間生成物の変数の使用なしに。以下の各取り組みは同等です：

Bridging lets you use an expression of a Swift standard library type such as String as its corresponding Foundation type such as NSString without needing to create a new instance. For more information on bridging, see Working with Foundation Types. ブリッジは、あなたにStringのようなスウィフト標準ライブラリ型の式を、NSStringのようなそれの対応しているFoundation型として使用させます、新しいインスタンスを作成する必要なしに。ブリッジに関するより多くの情報のために、Foundation型を扱うを見てください。

The as? operator performs a conditional cast of the expression to the specified type. The as? operator returns an optional of the specified type. At runtime, if the cast succeeds, the value of expression is wrapped in an optional and returned; otherwise, the value returned is nil. If casting to the specified type is guaranteed to fail or is guaranteed to succeed, a compile-time error is raised. as?演算子は式の指定された型への条件付きキャストを実行します。as?演算子は、指定された型のオプショナルを返します。実行時に、キャストが成功したならば、式の値がひとつのオプショナルの中にラップされて返されます；そうでなければ返される値はnilです。指定された型へのキャストが失敗すると保証されるまたは成功すると保証される場合には、コンパイル時エラーが引き起こされます。

The as! operator performs a forced cast of the expression to the specified type. The as! operator returns a value of the specified type, not an optional type. If the cast fails, a runtime error is raised. The behavior of x as! T is the same as the behavior of (x as? T)!. as!演算子は式の指定された型への強制的なキャストを実行します。as!演算子は指定された型の値を返します、オプショナル型ではなく。キャストが失敗したならば、実行時エラーが引き起こされます。x as! Tの挙動は、(x as? T)!の挙動と同じです。

For more information about type casting and to see examples that use the type-casting operators, see Type Casting. 型キャストに関するより多くの情報のために、そして、型キャスト演算子を使用する例をより多く見るために、型キャストを見てください。

Literal Expression¶ リテラル式¶

A literal expression consists of either an ordinary literal (such as a string or a number), an array or dictionary literal, a playground literal, or one of the following special literals: リテラル式は、普通のリテラル（例えば、ある文字列または数）、配列または辞書リテラル、プレイグラウンドリテラル、または以下の特別なリテラルのうちの１つから成ります：

The string value of #file depends on the language version, to enable migration from the old #filePath behavior to the new #fileID behavior. Currently, #file has the same value as #filePath. In a future version of Swift, #file will have the same value as #fileID instead. To adopt the future behavior, replace #file with #fileID or #filePath as appropriate. #fileの文字列値は、言語バージョンに依存して、古い#filePath挙動から新しい#fileID挙動への移行が可能になります。現在は、#fileは#filePathと同じ値を持ちます。将来のバージョンのスウィフトでは、#fileは代わりに#fileIDと同じ値を持つでしょう。将来の挙動を採用するには、#fileを#fileIDまたは#filePathで適切に置き換えてください。

The string value of a #fileID expression has the form module/file, where file is the name of the file in which the expression appears and module is the name of the module that this file is part of. The string value of a #filePath expression is the full file-system path to the file in which the expression appears. Both of these values can be changed by #sourceLocation, as described in Line Control Statement. Because #fileID doesn’t embed the full path to the source file, unlike #filePath, it gives you better privacy and reduces the size of the compiled binary. Avoid using #filePath outside of tests, build scripts, or other code that doesn’t become part of the shipping program. #fileID式の文字列値は、形式module/fileを持ちます、そこでfileはそれにおいて拡張が現れるファイルの名前です、そしてmoduleはこのファイルがそれの一部であるところのモジュールの名前です。#filePath式の文字列値は、それにおいて式が現れるファイルへの完全なファイルシステムパスです。これらの値の両方とも、#sourceLocationによって変更されることが、行制御文で記述されるように可能です。#fileIDは、#filePathとは違い、ソースファイルへの完全パスを埋め込みません、それはあなたにより良いプライバシーを与えます、そしてコンパイル済みバイナリの大きさを減らします。#filePathを、テスト、スクリプトのビルド、または出荷プログラムの一部とはならないその他のコード以外で使うのを避けてください。

Inside a function, the value of #function is the name of that function, inside a method it’s the name of that method, inside a property getter or setter it’s the name of that property, inside special members like init or subscript it’s the name of that keyword, and at the top level of a file it’s the name of the current module. 関数の内側では、#functionの値は、その関数の名前であり、メソッドの内側ではそれはそのメソッドの名前であり、プロパティゲッターやセッターの内側ではそれはそのプロパティの名前であり、initまたはsubscriptのような特別なメンバーの内側ではそれはそのキーワードの名前であり、そしてあるファイルのトップレベルではそれは現在のモジュールの名前です。

When used as the default value of a function or method parameter, the special literal’s value is determined when the default value expression is evaluated at the call site. 関数およびメソッドのパラメータの省略時の値として使われる時、特殊リテラルの値は、省略時値式が呼び出し現場で評価される場合は決定されます。

An array literal is an ordered collection of values. It has the following form: 配列リテラルは、順序付けられた値のコレクションです。それは、以下の形式を持ちます：

The last expression in the array can be followed by an optional comma. The value of an array literal has type [T], where T is the type of the expressions inside it. If there are expressions of multiple types, T is their closest common supertype. Empty array literals are written using an empty pair of square brackets and can be used to create an empty array of a specified type. 配列の最後の式の後に、１つの任意のコンマが続くことができます。配列リテラルの値は型[T]を持ちます、そこで、Tはそれの内部の式の型です。複数の型の式があるならば、Tはそれらの最も近い共通のスーパー型です。空の配列リテラルは、空の角括弧の対を使って書かれて、指定された型の空の配列をつくるために使われることができます。

A dictionary literal is an unordered collection of key-value pairs. It has the following form: 辞書リテラルは、「キーと値」の対の順序付けされないコレクションです。それは、以下の形式を持ちます：

The last expression in the dictionary can be followed by an optional comma. The value of a dictionary literal has type [Key: Value], where Key is the type of its key expressions and Value is the type of its value expressions. If there are expressions of multiple types, Key and Value are the closest common supertype for their respective values. An empty dictionary literal is written as a colon inside a pair of brackets ([:]) to distinguish it from an empty array literal. You can use an empty dictionary literal to create an empty dictionary literal of specified key and value types. 辞書の最後の式の後に、１つの任意のコンマが続くことができます。辞書リテラルの値は、型[Key: Value]を持ちます、そこで、Keyはそのキーの式の型です、そして、Valueはその値の式の型です。複数の型の式があるならば、KeyとValueはそれらめいめいの値に対して最も近い共通のスーパー型です。空の辞書リテラルは、一対の角括弧の中のコロン（[:]）として書かれることで、空の配列リテラルからそれを区別します。あなたは、空の辞書リテラルを使って、指定されたキーと値型の空の辞書リテラルを作成できます。

A playground literal is used by Xcode to create an interactive representation of a color, file, or image within the program editor. Playground literals in plain text outside of Xcode are represented using a special literal syntax. プレイグラウンドリテラルは、Xcodeによって使われて、プログラムエディタ内でいろ、ファイル、または画像の双方向の表現を作成します。Xcodeの外部のプレーンテキストの中のプレイグラウンドリテラルは、特別なリテラル構文を使って表されます。

For information on using playground literals in Xcode, see Add a color, file, or image literal in Xcode Help. Xcodeにおけるプレイグラウンドリテラルの使用に関するさらなる情報として、Add a color, file, or image literalをXcodeヘルプで見てください。

Self Expression¶ self式¶

The self expression is an explicit reference to the current type or instance of the type in which it occurs. It has the following forms: self式は、それがその中に現れているところの現在の型や型のインスタンスへの明確な参照です。それは、以下の各形式を持ちます：

In an initializer, subscript, or instance method, self refers to the current instance of the type in which it occurs. In a type method, self refers to the current type in which it occurs. イニシャライザ、添え字、またはインスタンスメソッドでは、selfはそれが現れているところの型の現在のインスタンスに言及します。型メソッドでは、selfはそれが現れているところの現在の型に言及します。

The self expression is used to specify scope when accessing members, providing disambiguation when there’s another variable of the same name in scope, such as a function parameter. For example: self式は、メンバーにアクセスする時にスコープを指定するために使われて、関数パラメータなど、同じ名前の別の変数がスコープ内にある場合に一義化を提供します。例えば：

In a mutating method of a value type, you can assign a new instance of that value type to self. For example: 値型の変更メソッドでは、あなたはselfにその値型の新しいインスタンスを代入することができます。例えば：

Superclass Expression¶ スーパークラス式¶

A superclass expression lets a class interact with its superclass. It has one of the following forms: スーパークラス式は、あるクラスをそのスーパークラスと相互に作用させます。それは、以下の書式のうちの１つを持ちます：

The first form is used to access a member of the superclass. The second form is used to access the superclass’s subscript implementation. The third form is used to access an initializer of the superclass. 最初の形式は、スーパークラスのメンバーにアクセスするために使われます。第２の形式は、スーパークラスの添え字実装にアクセスするために使われます。第３の形式は、スーパークラスのイニシャライザにアクセスするために使われます。

Subclasses can use a superclass expression in their implementation of members, subscripting, and initializers to make use of the implementation in their superclass. サブクラスは、そのメンバー、添え字、そしてイニシャライザの実装においてスーパークラス式を使うことで、それらのスーバークラス内の実装を活用することができます。

Closure Expression¶ クロージャ式¶

A closure expression creates a closure, also known as a lambda or an anonymous function in other programming languages. Like a function declaration, a closure contains statements, and it captures constants and variables from its enclosing scope. It has the following form: クロージャ式はクロージャ、他のプログラミング言語ではまたlambdaまたは匿名関数として知られるものをつくります。関数宣言の様に、クロージャはいくつかの文を含みます、そしてそれは、定数と変数をそれの取り囲むスコープからキャプチャします。それは、以下の形式を持ちます：

The parameters have the same form as the parameters in a function declaration, as described in Function Declaration. パラメータは、関数宣言で記述されるように、関数宣言でのパラメータと同じ形式を持ちます。

There are several special forms that allow closures to be written more concisely: クロージャをより簡潔に書かれるようにする特別ないくつかの形式があります：

• A closure can omit the types of its parameters, its return type, or both. If you omit the parameter names and both types, omit the in keyword before the statements. If the omitted types can’t be inferred, a compile-time error is raised. クロージャは、そのパラメータの型、その戻り型、または両方を省略することができます。あなたがパラメータ名と両方の型を省略するならば、文の前のinキーワードを省略します。省略された型が推論されることができないならば、コンパイル時エラーが引き起こされます。
• A closure may omit names for its parameters. Its parameters are then implicitly named $ followed by their position: $0, $1, $2, and so on. クロージャは、そのパラメータの名前を省略することができます。そのパラメータは、それから暗黙のうちに$の後にそれらの位置が続く名前：$0、$1、$2、などをつけられます。
• A closure that consists of only a single expression is understood to return the value of that expression. The contents of this expression are also considered when performing type inference on the surrounding expression. １つの式だけから成るクロージャは、その式の値を返すと理解されます。この式の内容はまた、型推論を実行する時に周囲の式上にあると見なされます。

The following closure expressions are equivalent: 以下のクロージャ式は、等しいです：

For information about passing a closure as an argument to a function, see Function Call Expression. クロージャを引数として関数に渡すことに関する情報については、関数呼び出し式を見てください。

Closure expressions can be used without being stored in a variable or constant, such as when you immediately use a closure as part of a function call. The closure expressions passed to myFunction in code above are examples of this kind of immediate use. As a result, whether a closure expression is escaping or nonescaping depends on the surrounding context of the expression. A closure expression is nonescaping if it’s called immediately or passed as a nonescaping function argument. Otherwise, the closure expression is escaping. クロージャ式は、変数や定数の中に格納されることなく利用できます、例えばあなたが直接にクロージャを関数呼び出しの一部として使う場合など。上のコードにおいてmyFunctionに渡されるクロージャ式は、この種の直接的な利用の例です。結果として、あるクロージャ式が脱出または非脱出であるかどうかは、その式を取り囲んでいる前後関係に依存します。クロージャ式は、もしそれが直接に呼び出されるか、または非脱出関数引数として渡されるならば非脱出です。それ以外では、クロージャ式は脱出です。

For more information about escaping closures, see Escaping Closures. 脱出クロージャについてのさらなる情報として、脱出クロージャを見てください。

Implicit Member Expression¶ 暗黙的メンバー式¶

An implicit member expression is an abbreviated way to access a member of a type, such as an enumeration case or a type method, in a context where type inference can determine the implied type. It has the following form: 暗黙的メンバー式は、型推論が暗黙の型を決定することができる文脈においてある型のメンバー、たとえば列挙ケース節や型メソッド、にアクセスするための簡略された方法です。それは、以下の形式を持ちます：

For example: 例えば：

If the inferred type is an optional, you can also use a member of the non-optional type in an implicit member expression. 推論された型がオプショナルならば、あなたはまた非オプショナル型のメンバーを暗黙的メンバー式において使用できます。

Implicit member expressions can be followed by a postfix operator or other postfix syntax listed in Postfix Expressions. This is called a chained implicit member expression. Although it’s common for all of the chained postfix expressions to have the same type, the only requirement is that the whole chained implicit member expression needs to be convertible to the type implied by its context. Specifically, if the implied type is an optional you can use a value of the non-optional type, and if the implied type is a class type you can use a value of one of its subclasses. For example: 暗黙的メンバー式は、接尾辞式において一覧にされる接尾辞演算子または他の接尾辞構文を後に続けることが可能です。これは、連鎖暗黙的メンバー式と呼ばれます。連鎖にされた接尾辞式の全てが同じ型を持つのが普通であるとはいえ、唯一の要件は、連鎖暗黙的メンバー式の全体がそれの文脈によってほのめかされた型へと変換可能でなければならないことです。具体的には、その暗黙的型がオプショナルであるとしてもあなたは非オプショナル型の値を使用できます、そしてその暗黙的型がクラス型であるならばあなたはそれのサブクラスの１つの値を使用できます。例えば：

In the code above, the type of x matches the type implied by its context exactly, the type of y is convertible from SomeClass to SomeClass?, and the type of z is convertible from SomeSubclass to SomeClass. 上のコードにおいて、xの型はそれの文脈によってほのめかされる型とぴったり合致します、yの型はSomeClassからSomeClass?へと変換可能です、そしてzの型はSomeSubclassからSomeClassへと変換可能です。

Parenthesized Expression¶ 括弧に入れられた式¶

A parenthesized expression consists of an expression surrounded by parentheses. You can use parentheses to specify the precedence of operations by explicitly grouping expressions. Grouping parentheses don’t change an expression’s type—for example, the type of (1) is simply Int. 括弧に入れられた式は、丸括弧で囲まれたある式から成ります。あなたは丸括弧を使って、明示的にいくらかの式をグループにまとめることによって演算の優先順位を指定することができます。グループ化括弧はある式のもつ型を変えません — 例えば、(1)の型は単にIntです。

Tuple Expression¶ タプル式¶

A tuple expression consists of a comma-separated list of expressions surrounded by parentheses. Each expression can have an optional identifier before it, separated by a colon (:). It has the following form: タプル式は、丸括弧に囲まれているコンマ区切りの式のリストから成ります。各式はそれの前に、コロン（:）で区切られる任意の識別子を持つことができます。それは、以下の形式を持ちます：

Each identifier in a tuple expression must be unique within the scope of the tuple expression. In a nested tuple expression, identifiers at the same level of nesting must be unique. For example, (a: 10, a: 20) is invalid because the label a appears twice at the same level. However, (a: 10, b: (a: 1, x: 2)) is valid—although a appears twice, it appears once in the outer tuple and once in the inner tuple. あるタプル式の中の各識別子は、そのタプル式のスコープ内で特有でなければなりません。入れ子にされたタプル式において、同じ水準の入れ子での識別子それらは特有でなければなりません。例えば、(a: 10, a: 20)は無効です、なぜならラベルaが同じ水準で二度現れるからです。しかしながら、(a: 10, b: (a: 1, x: 2))は有効です — もっともaが二度現れますが、それは一度だけ外側タプルに、そして一度だけ内側タプルに現れます。

A tuple expression can contain zero expressions, or it can contain two or more expressions. A single expression inside parentheses is a parenthesized expression. タプル式はゼロ個の式を含むことができます、またはそれは２つまたはそれ以上の式を含むことができます。丸括弧で囲まれたただ１つだけの式は、括弧で囲まれた式です。

Wildcard Expression¶ ワイルドカード式¶

A wildcard expression is used to explicitly ignore a value during an assignment. For example, in the following assignment 10 is assigned to x and 20 is ignored: ワイルドカード式は、代入の間に明示的に値を無視するために使われます。例えば、以下の代入において、10はxに代入されて20は無視されます：

Key-Path Expression¶ キーパス式¶

A key-path expression refers to a property or subscript of a type. You use key-path expressions in dynamic programming tasks, such as key-value observing. They have the following form: キーパス式は、ある型のプロパティまたは添え字を参照します。あなたはキーパス式を動的なプログラミング作業、例えばキー値監視などにおいて使用します。これらは以下の形式を持ちます：

The type name is the name of a concrete type, including any generic parameters, such as String, [Int], or Set<Int>. type nameは、ある具象型の名前で、何らかの総称体パラメータを含みます、例えばString、[Int]、またはSet<Int>など。

The path consists of property names, subscripts, optional-chaining expressions, and forced unwrapping expressions. Each of these key-path components can be repeated as many times as needed, in any order. pathは、プロパティ名、添え字、「オプショナル連鎖」式、そして強制アンラップ式からなります。これらキーパス構成要素のそれぞれは、必要なだけ、任意の順序で、何度も繰り返されることができます。

At compile time, a key-path expression is replaced by an instance of the KeyPath class. コンパイル時に、キーパス式はKeyPathクラスのインスタンスによって置き換えられます。

To access a value using a key path, pass the key path to the subscript(keyPath:) subscript, which is available on all types. For example: キーパスを使ってある値にアクセスするには、そのキーパスをsubscript(keyPath:)添え字に渡してください、それは全ての型で利用可能です。例えば：

The type name can be omitted in contexts where type inference can determine the implied type. The following code uses \.someProperty instead of \SomeClass.someProperty: type nameは、型推論が暗黙の型を判定できるところの文脈では省略できます。以下のコードは、\.somePropertyを\SomeClass.somePropertyの代わりに使います：

The path can refer to self to create the identity key path (\.self). The identity key path refers to a whole instance, so you can use it to access and change all of the data stored in a variable in a single step. For example: pathは、selfを参照することで、同一性キーパス（\.self）を作成できます。同一性キーパスはインスタンス全体を参照します、それであなたはそれを使って、ただ一段階で変数の中に格納されたデータの全てにアクセスおよび変更できます。例えば：

The path can contain multiple property names, separated by periods, to refer to a property of a property’s value. This code uses the key path expression \OuterStructure.outer.someValue to access the someValue property of the OuterStructure type’s outer property: pathは、ピリオドで区切った複数のプロパティ名を含むことで、あるプロパティの持つ値に属するプロパティを参照できます。このコードは、キーパス式\OuterStructure.outer.someValueを使って、someValueプロパティにアクセスします、そのプロパティはOuterStructure型の持つouterプロパティに属しています：

The path can include subscripts using brackets, as long as the subscript’s parameter type conforms to the Hashable protocol. This example uses a subscript in a key path to access the second element of an array: pathは角括弧を使う添え字を含むことができます、その添え字の持つパラメータ型がHashableプロトコルに準拠する限りは。この例は、キーパス式において添え字を使って、配列の２番目の要素にアクセスします。

The value used in a subscript can be a named value or a literal. Values are captured in key paths using value semantics. The following code uses the variable index in both a key-path expression and in a closure to access the third element of the greetings array. When index is modified, the key-path expression still references the third element, while the closure uses the new index. 添え字の中で使われる値は、名前付きの値またはあるリテラルであることが可能です。様々な値は、キーパスの中に値意味論を使ってキャプチャされます。以下のコードは、変数indexをキーパス式の中でそしてクロージャの中での両方で使うことで、greetings配列の３番目の要素にアクセスします。indexが修正される時、キーパス式は依然として３番目の要素に参照を付けます、一方でクロージャは新しいインデックスを使用します。

The path can use optional chaining and forced unwrapping. This code uses optional chaining in a key path to access a property of an optional string: pathは、オプショナル連鎖と強制アンラップを使うことができます。このコードは、オプショナル連鎖をキーパスの中で使うことで、あるオプショナル文字列に属するプロパティにアクセスします：

You can mix and match components of key paths to access values that are deeply nested within a type. The following code accesses different values and properties of a dictionary of arrays by using key-path expressions that combine these components. あなたは、キーパスの構成要素をうまく組み合わせることで、ある型の内部に深く入れ子にされた値にアクセスできます。以下のコードは、いくつかの配列からなる辞書に属する異なる値およびプロパティに、それらの構成要素を組み合わせるキーパス式を使うことでアクセスします。

You can use a key path expression in contexts where you would normally provide a function or closure. Specifically, you can use a key path expression whose root type is SomeType and whose path produces a value of type Value, instead of a function or closure of type (SomeType) -> Value. あなたはキーパス式を、あなたが通常は関数またはクロージャを提供するところの文脈において使用できます。とりわけ、あなたはそれのルート型がSomeTypeでそれのパスが型Valueの値を生み出すキーパス式を、型(SomeType) -> Valueの関数またはクロージャの代わりに使用できます。

Any side effects of a key path expression are evaluated only at the point where the expression is evaluated. For example, if you make a function call inside a subscript in a key path expression, the function is called only once as part of evaluating the expression, not every time the key path is used. キーパス式のあらゆる副作用は、式が評価されるところの時点でのみ評価されます。例えば、あなたがキーパス式の中の添え字内で関数呼び出しを作るならば、関数は式の評価の一部としてただ一度だけ呼び出されます、キーパス式が使われるたびごとではなく。

For more information about using key paths in code that interacts with Objective-C APIs, see Using Objective-C Runtime Features in Swift. For information about key-value coding and key-value observing, see Key-Value Coding Programming Guide and Key-Value Observing Programming Guide. Objective-C APIと相互作用するコードにおけるキーパスの使用についてのさらなる情報として、Objective-Cランタイム機能をSwiftで使用するを見てください。キー値コーディングとキー値監視についての情報として、キー値コーディングプログラミングガイドとキー値監視プログラミングガイドを見てください。

Selector Expression¶ セレクタ式¶

A selector expression lets you access the selector used to refer to a method or to a property’s getter or setter in Objective-C. It has the following form: セレクタ式は、あなたに、Objective-Cにおけるあるメソッドをまたはあるプロパティの持つゲッターやセッターを参照するために使われるセレクタにアクセスをさせます。それは、以下の形式を持ちます：

The method name and property name must be a reference to a method or a property that’s available in the Objective-C runtime. The value of a selector expression is an instance of the Selector type. For example: method nameとproperty nameは、あるメソッドおよびプロパティへの参照で、それはObjective-Cランタイムにおいて利用可能なものでなければなりません。セレクタ式の値は、Selector型のインスタンスです。例えば：

When creating a selector for a property’s getter, the property name can be a reference to a variable or constant property. In contrast, when creating a selector for a property’s setter, the property name must be a reference to a variable property only. プロパティのゲッターのためのセレクタを作成するとき、property nameは変数または定数プロパティへの参照であることができます。対照的に、プロパティのセッターのためのセレクタを作成するとき、property nameは必ず変数プロパティへの参照でなければなりません。

The method name can contain parentheses for grouping, as well the as operator to disambiguate between methods that share a name but have different type signatures. For example: method nameは、グループにまとめるための丸括弧、その上に、名前を共有するが異なる型シグネチャを持つメソッド間の違いを明確にするためにas演算子を含むことができます。例えば：

Because a selector is created at compile time, not at runtime, the compiler can check that a method or property exists and that they’re exposed to the Objective-C runtime. あるセレクタが作成されるのはコンパイル時であり、実行時でないので、コンパイラはそのメソッドまたはプロパティが存在すること、そしてそれらがObjective-Cランタイムに露出されていることを確かめることができます。

For more information about using selectors in Swift code that interacts with Objective-C APIs, see Using Objective-C Runtime Features in Swift. Objective-C APIと相互作用するSwiftコードにおけるセレクタの使用についてのさらなる情報として、Objective-Cランタイム機能をSwiftで使用するを見てください。

Key-Path String Expression¶ キーパス文字列式¶

A key-path string expression lets you access the string used to refer to a property in Objective-C, for use in key-value coding and key-value observing APIs. It has the following form: キーパス文字列式は、あなたにObjective-Cでのプロパティを参照するために使われる文字列にアクセスさせます、キー値コーディングとキー値監視APIで使用するために。それは、以下の形式を持ちます：

The property name must be a reference to a property that’s available in the Objective-C runtime. At compile time, the key-path string expression is replaced by a string literal. For example: property nameは、Objective-Cランタイムにおいて利用可能であるプロパティへの参照でなければなりません。コンパイル時で、キーパス文字列式は文字列リテラルによって置き換えられます。例えば：

When you use a key-path string expression within a class, you can refer to a property of that class by writing just the property name, without the class name. あなたがキーパス文字列式をあるクラス内で使う時、あなたはそのクラスのプロパティを参照することが、クラス名なしで単にそのプロパティ名を書くことによって可能です。

Because the key path string is created at compile time, not at runtime, the compiler can check that the property exists and that the property is exposed to the Objective-C runtime. キーパス文字列は実行時ではなく、コンパイル時に作成されるため、コンパイラはプロパティが存在することおよびプロパティがObjective-Cランタイムへと露出されることを確認できます。

For more information about using key paths in Swift code that interacts with Objective-C APIs, see Using Objective-C Runtime Features in Swift. For information about key-value coding and key-value observing, see Key-Value Coding Programming Guide and Key-Value Observing Programming Guide. Objective-C APIと相互作用するSwiftコードにおけるキーパスの使用についてのさらなる情報として、Objective-Cランタイム機能をSwiftで使用するを見てください。キー値コーディングとキー値監視についての情報として、キー値コーディングプログラミングガイドとキー値監視プログラミングガイドを見てください。

Function Call Expression¶ 関数呼び出し式¶

A function call expression consists of a function name followed by a comma-separated list of the function’s arguments in parentheses. Function call expressions have the following form: 関数呼び出し式は、関数名の後にその関数の引数のコンマ区切りのリストを丸括弧の中に続けることから成ります。関数呼び出し式は、以下の形式を持ちます：

The function name can be any expression whose value is of a function type. 関数名は、それの値が関数型のものであるどんな式でも可能です。

If the function definition includes names for its parameters, the function call must include names before its argument values, separated by a colon (:). This kind of function call expression has the following form: 関数定義がそれのパラメータそれらの名前を含むならば、関数呼び出しはそれの引数値の前に名前を、コロン（:）で区切って含まなければなりません。この種類の関数呼び出し式は、以下の形式を持ちます：

A function call expression can include trailing closures in the form of closure expressions immediately after the closing parenthesis. The trailing closures are understood as arguments to the function, added after the last parenthesized argument. The first closure expression is unlabeled; any additional closure expressions are preceded by their argument labels. The example below shows the equivalent version of function calls that do and don’t use trailing closure syntax: 関数呼び出し式は、閉じ丸括弧の直後にクロージャ式の形で後付クロージャいくつかを含むことができます。後付クロージャそれらは、関数に対する引数それらとして理解されます、そして、丸括弧に入れられた最後の引数の後に加えられます。最初のクロージャ式は、ラベルをつけられません；あらゆる追加的なクロージャ式は、それらの引数ラベルを前に置かれます。下の例は、後付クロージャ構文を使用および使用しない同等版の関数呼び出しを示します：

If the trailing closure is the function’s only argument, you can omit the parentheses. 後付クロージャがその関数のもつただ１つの引数であるならば、あなたは丸括弧を省略できます。

To include the trailing closures in the arguments, the compiler examines the function’s parameters from left to right as follows: 後付クロージャを引数それらの中に含めるために、コンパイラは関数のもつパラメータを左から右へと調査します、次のように：

The trailing closure is passed as the argument for the parameter that it matches. Parameters that were skipped during the scanning process don’t have an argument passed to them—for example, they can use a default parameter. After finding a match, scanning continues with the next trailing closure and the next parameter. At the end of the matching process, all trailing closures must have a match. 後付クロージャは、それが合致するパラメータに対して引数として渡されます。走査処理の間に飛ばされたパラメータそれらは、それらに渡される引数を持ちません — 例えば、それらはある省略時パラメータを使用できます。ある合致を見つけた後、走査は、次の後付クロージャと次のパラメータで継続します。合致処理の終わりで、全ての後付クロージャはある合致を持たなければなりません。

A parameter structurally resembles a function type if the parameter isn’t an in-out parameter, and the parameter is one of the following: パラメータは、そのパラメータがin-outパラメータでないならば関数型と構造的に似ています、そしてそのパラメータは以下の１つです：

• A parameter whose type is a function type, like (Bool) -> Int それの型が関数型であるパラメータ、たとえば(Bool) -> Int
• An autoclosure parameter whose wrapped expression’s type is a function type, like @autoclosure () -> ((Bool) -> Int) それのラップした式のもつ型が関数型である自動クロージャパラメータ、たとえば@autoclosure () -> ((Bool) -> Int)
• A variadic parameter whose array element type is a function type, like ((Bool) -> Int)... それの配列要素型が関数型である可変長パラメータ、たとえば((Bool) -> Int)...
• A parameter whose type is wrapped in one or more layers of optional, like Optional<(Bool) -> Int> それの型が１つ以上のオプショナルのレイヤーの中にラップされるパラメータ、たとえばOptional<(Bool) -> Int>
• A parameter whose type combines these allowed types, like (Optional<(Bool) -> Int>)... それの型は許可される型それらを組み合わせるものであるパラメータ、たとえば(Optional<(Bool) -> Int>)...

When a trailing closure is matched to a parameter whose type structurally resembles a function type, but isn’t a function, the closure is wrapped as needed. For example, if the parameter’s type is an optional type, the closure is wrapped in Optional automatically. 後付クロージャが、それの型が構造的に関数型と似ている、しかし関数でないパラメータと組み合わされる場合、クロージャは必要に応じてラップされます。例えば、パラメータのもつ型がオプショナル型であるならば、クロージャは自動的にOptionalにラップされます。

To ease migration of code from versions of Swift prior to 5.3—which performed this matching from right to left—the compiler checks both the left-to-right and right-to-left orderings. If the scan directions produce different results, the old right-to-left ordering is used and the compiler generates a warning. A future version of Swift will always use the left-to-right ordering. 5.3より前のスウィフトのバージョンからのコードの移行を簡単にするために — それはこの合致を右から左に実行しました — コンパイラは左から右と右から左順の両方を調べます。走査方向が異なる結果を生じるならば、古い右から左順が使われます、そしてコンパイラは警告を生成します。スウィフトの将来のバージョンは、常に左から右順を使うでしょう。

In the example above, the function call marked “Ambiguous” prints “- 120” and produces a compiler warning on Swift 5.3. A future version of Swift will print “110 -”. 上の例において、“あいまい（Ambiguous）” と印される関数呼び出しは “- 120” を出力します、そしてコンパイラ警告をSwift 5.3で生成します。スウィフトの将来のバージョンは、“110 -” を出力するでしょう。

A class, structure, or enumeration type can enable syntactic sugar for function call syntax by declaring one of several methods, as described in Methods with Special Names. クラス、構造体、または列挙型は、構文糖を関数呼び出し構文に対して可能にすることが、幾つかのメソッドの１つを宣言することによって可能です、特殊名を持つメソッドで記述されるように。

Initializer Expression¶ イニシャライザ式¶

An initializer expression provides access to a type’s initializer. It has the following form: あなたはまた、スーパークラスのイニシャライザに委任するために、イニシャライザ式を使います。それは、以下の形式を持ちます：

You use the initializer expression in a function call expression to initialize a new instance of a type. You also use an initializer expression to delegate to the initializer of a superclass. あなたは、イニシャライザ式を関数呼び出し式において使うことで、ある型の新しいインスタンスを初期化します。あなたはまた、スーパークラスのイニシャライザに委任するために、イニシャライザ式を使います。

Like a function, an initializer can be used as a value. For example: 関数のように、イニシャライザは値として使われることができます。例えば：

If you specify a type by name, you can access the type’s initializer without using an initializer expression. In all other cases, you must use an initializer expression. あなたがある型を名前で指定するならば、あなたはその型のイニシャライザにイニシャライザ式を使うことなくアクセスすることができます。すべての他の場合では、あなたはイニシャライザ式を使う必要があります。

Explicit Member Expression¶ 明示的メンバー式¶

An explicit member expression allows access to the members of a named type, a tuple, or a module. It consists of a period (.) between the item and the identifier of its member. 明示的メンバー式は、名前付き型、タプル、またはモジュールに属するそれらメンバーへのアクセスを可能にします。それは、その項目とそれのメンバーの識別子の間のピリオド（.）から成ります。

The members of a named type are named as part of the type’s declaration or extension. For example: ある名前付きの型に属するメンバーそれらは、その型のもつ宣言や拡張の一部として指名されます。例えば：

The members of a tuple are implicitly named using integers in the order they appear, starting from zero. For example: タプルのメンバーそれらは、暗黙的に、整数を使って、それらが現れる順序で、ゼロから開始して、指名されます。例えば：

The members of a module access the top-level declarations of that module. モジュールのメンバーそれらは、そのモジュールのトップレベル宣言それらにアクセスします。

Types declared with the dynamicMemberLookup attribute include members that are looked up at runtime, as described in Attributes. dynamicMemberLookup属性とともに宣言される型は、実行時に捜されるメンバーを含みます、属性で記述されるように。

To distinguish between methods or initializers whose names differ only by the names of their arguments, include the argument names in parentheses, with each argument name followed by a colon (:). Write an underscore (_) for an argument with no name. To distinguish between overloaded methods, use a type annotation. For example: それらの名前がそれらのもつ引数の名前によってのみ異なるメソッドやイニシャライザ間の区別をするには、丸括弧の中に引数名を、各引数名にコロン（:）を続けることで、含めて下さい。名前のない引数に対しては１つのアンダースコア（_）を書いてください。オーバーロードされたメソッド間で識別を行うには、型注釈を使ってください。例えば：

If a period appears at the beginning of a line, it’s understood as part of an explicit member expression, not as an implicit member expression. For example, the following listing shows chained method calls split over several lines: ピリオドがある行の初めに現れたならば、それはある明示的メンバー式の一部分として理解されます、ある暗黙的メンバー式としてではなく。例えば、以下のコード出力は、いくつかの行に分かれた、連結されたメソッド呼び出しいくつかを示します：

You can combine this multiline chained syntax with compiler control statements to control when each method is called. For example, the following code uses a different filtering rule on iOS: あなたは、この複数行連鎖構文をコンパイラ制御文いくらかと結合することで、いつ各メソッドが呼び出されるかを制御できます。例えば、以下のコードはiOS上では異なるフィルタ規則を使います：

Between #if, #endif, and other compilation directives, the conditional compilation block can contain an implicit member expression followed by zero or more postfixes, to form a postfix expression. It can also contain another conditional compilation block, or a combination of these expressions and blocks. #if、#endif、そしてその他のコンパイル指令の間で、条件コンパイルブロックは、ある接尾辞式を形成するため、０個以上の接尾辞をその後に続ける、ある暗黙的メンバー式を含むことができます。それはまた、別の条件コンパイルブロックを、またはこれらの式とブロックからなるある組み合わせを含むことができます。

You can use this syntax anywhere that you can write an explicit member expression, not just in top-level code. あなたはこの構文を、あなたが明示的メンバー式を記述可能なあらゆるところに使用できます、単にトップレベルコードにだけでなく。

In the conditional compilation block, the branch for the #if compilation directive must contain at least one expression. The other branches can be empty. 条件コンパイルブロックにおいて、#ifコンパイル指令に対する分岐は少なくとも１つの式を含まなければなりません。他の分岐は、空であることができます。

Postfix Self Expression¶ 接尾辞self式¶

A postfix self expression consists of an expression or the name of a type, immediately followed by .self. It has the following forms: 接尾辞self式は、ある式または型の名前と、それに直ちに続く.selfから成ります。それは、以下の各形式を持ちます：

The first form evaluates to the value of the expression. For example, x.self evaluates to x. 最初の形式は、式の値に評価されます。例えば、x.selfはxに評価されます。

The second form evaluates to the value of the type. Use this form to access a type as a value. For example, because SomeClass.self evaluates to the SomeClass type itself, you can pass it to a function or method that accepts a type-level argument. 第二の形式は、型の値に評価されます。値として型にアクセスするために、この形式を使ってください。例えば、SomeClass.selfはSomeClass型それ自体に評価されるので、あなたはそれを型レベルの引数を受け入れる関数またはメソッドへ渡すことができます。

Subscript Expression¶ 添え字式¶

A subscript expression provides subscript access using the getter and setter of the corresponding subscript declaration. It has the following form: 添え字式は、対応する添え字宣言のゲッターとセッターを使用して、添え字アクセスを提供します。それは、以下の形式を持ちます：

To evaluate the value of a subscript expression, the subscript getter for the expression’s type is called with the index expressions passed as the subscript parameters. To set its value, the subscript setter is called in the same way. 添え字式の値を評価するために、この式のもつ型のための添え字ゲッターが、添え字パラメータとして渡されるインデックス式を使って呼び出されます。その値を設定するために、添え字セッターが同様に呼ばれます。

For information about subscript declarations, see Protocol Subscript Declaration. 添え字宣言に関して詳しくは、プロトコル添え字宣言を見てください。

Forced-Value Expression¶ 強制された値式¶

A forced-value expression unwraps an optional value that you are certain isn’t nil. It has the following form: 強制された値式は、あなたがnilでないことを確信しているオプショナルの値をアンラップします。それは、以下の形式を持ちます：

If the value of the expression isn’t nil, the optional value is unwrapped and returned with the corresponding non-optional type. Otherwise, a runtime error is raised. 式の値がnilでないならば、オプショナルの値は包装を取られて（アンラップされて）、対応する非オプショナル型で返されます。そうでなければ、実行時エラーが引き起こされます。

The unwrapped value of a forced-value expression can be modified, either by mutating the value itself, or by assigning to one of the value’s members. For example: 強制された値式のアンラップされた値は、値それ自体を変化させることによって、またはその値のメンバーの１つに代入することによってのどちらでも、修正されることができます。例えば：

Optional-Chaining Expression¶ オプショナル連鎖式¶

An optional-chaining expression provides a simplified syntax for using optional values in postfix expressions. It has the following form: オプショナル連鎖式は、オプショナルの値を使うために単純化された構文を接尾辞式において提供します。それは、以下の形式を持ちます：

The postfix ? operator makes an optional-chaining expression from an expression without changing the expression’s value. 接尾辞?演算子は、オプショナル連鎖式をある式から、その式の値を変更することなく作ります。

Optional-chaining expressions must appear within a postfix expression, and they cause the postfix expression to be evaluated in a special way. If the value of the optional-chaining expression is nil, all of the other operations in the postfix expression are ignored and the entire postfix expression evaluates to nil. If the value of the optional-chaining expression isn’t nil, the value of the optional-chaining expression is unwrapped and used to evaluate the rest of the postfix expression. In either case, the value of the postfix expression is still of an optional type. オプショナル連鎖式は、接尾辞式の中に現れなければなりません、そしてそれはその接尾辞式を特別なやり方で評価されるようにします。オプショナル連鎖式の値がnilならば、接尾辞式での他の演算の全ては無視されます、そして接尾辞式の全体はnilに評価されます。オプショナル連鎖式の値がnilでないならば、オプショナル連鎖式の値はアンラップされて、接尾辞式の残りを評価するために使われます。いずれにせよ、接尾辞式の値は、依然としてオプショナル型です。

If a postfix expression that contains an optional-chaining expression is nested inside other postfix expressions, only the outermost expression returns an optional type. In the example below, when c isn’t nil, its value is unwrapped and used to evaluate .property, the value of which is used to evaluate .performAction(). The entire expression c?.property.performAction() has a value of an optional type. オプショナル連鎖式を含む接尾辞式が、他の接尾辞式の内部に入れ子にされるならば、最も外部の式だけがオプショナル型を返します。下記の例で、cがnilでないとき、その値はアンラップされて.propertyを評価するために使われ、その値が.performAction()を評価するために使われます。式c?.property.performAction()の全体がオプショナル型の値を持ちます。

The following example shows the behavior of the example above without using optional chaining. 以下の例は、オプショナル連鎖を使うことなく上の例の挙動を示します。

The unwrapped value of an optional-chaining expression can be modified, either by mutating the value itself, or by assigning to one of the value’s members. If the value of the optional-chaining expression is nil, the expression on the right-hand side of the assignment operator isn’t evaluated. For example: オプショナル連鎖のアンラップされた値は、その値自体を変化させることによって、またはその値のメンバーの１つに値に代入することによってのどちらでも修正されることができます。オプショナル連鎖式の値がnilならば、代入演算子の右手側での式は評価されません。例えば：