式
日本語を消す 英語を消す下記URLから引用し、日本語訳をつけてみました
https://docs.swift.org/swift-book/documentation/the-swift-programming-language/expressions
Access, modify, and assign values.
値にアクセス、変更、割り当てます。
In Swift, there are four kinds of expressions: prefix expressions, infix expressions, primary expressions, and postfix expressions. Evaluating an expression returns a value, causes a side effect, or both.
Swift には、前置式、中置式、主式、後置式の 4 種類の式があります。 式を評価すると、値が返されるか、副作用が発生するか、あるいはその両方が発生します。
Prefix and infix expressions let you apply operators to smaller expressions. Primary expressions are conceptually the simplest kind of expression, and they provide a way to access values. Postfix expressions, like prefix and infix expressions, let you build up more complex expressions using postfixes such as function calls and member access. Each kind of expression is described in detail in the sections below.
前置式と中置式を使用すると、より小さな式に演算子を適用できます。 主式は概念的に最も単純な種類の式であり、値にアクセスする方法を提供します。 前置式や中置式と同様に、後置式を使用すると、関数呼び出しやメンバー アクセスなどの後置式を使用して、より複雑な式を構築できます。 それぞれの種類の式については、以下のセクションで詳しく説明します。
Grammar of an expression
expression → try-operator? await-operator? prefix-expression infix-expressions?
expression-list → expression | expression ,
expression-list
Prefix Expressions
前置式
Prefix expressions combine an optional prefix operator with an expression. Prefix operators take one argument, the expression that follows them.
前置式は、オプションの前置演算子と式を組み合わせます。 前置演算子は引数を 1 つ取り、その後に式が続きます。
For information about the behavior of these operators, see Basic Operators and Advanced Operators.
これらの演算子の動作については、「基本演算子」と「高度な演算子」を参照してください。
For information about the operators provided by the Swift standard library, see Operator Declarations(Link:developer.apple.com).
Swift 標準ライブラリで提供される演算子については、「演算子の宣言(Link:developer.apple.com)(英語)」を参照してください。
Grammar of a prefix expression
prefix-expression → prefix-operator? postfix-expression
prefix-expression → in-out-expression
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 式は、関数呼び出し式に in-out 引数として渡される変数をマークします。
&<#expression#>
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 式は、「ポインター型への暗黙的な変換」で説明されているように、ポインターが必要なコンテキストで非ポインター引数を指定する場合にも使用されます。
Grammar of an in-out expression
in-out-expression → &
primary-expression
Try Operator
試行演算子
A try expression consists of the try
operator followed by an expression that can throw an error. It has the following form:
試行式は、try 演算子の後に、エラーをスローする可能性のある式が続いて構成されます。 次のような形式になります。
try <#expression#>
The value of a try
expression is the value of the expression.
試行式の値は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? <#expression#>
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
.
式がエラーをスローしない場合、optional-try 式の値は expressionの値を含むオプションです。 それ以外の場合、optional-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! <#expression#>
The value of a forced-try expression is the value of the expression. If the expression throws an error, a runtime error is produced.
強制試行式の値は、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! でマークされている場合、その演算子は中置演算子全体に適用されます。 ただし、括弧を使用すると、演算子のアプリケーションの範囲を明示的に示すことができます。
// try applies to both function calls
sum = try someThrowingFunction() + anotherThrowingFunction()
// try applies to both function calls
sum = try (someThrowingFunction() + anotherThrowingFunction())
// Error: try applies only to the first function call
sum = (try someThrowingFunction()) + anotherThrowingFunction()
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!
の詳細と 使用例については、「エラー処理」を参照してください。
Grammar of a try expression
try-operator → try
| try
?
| try
!
Await Operator
待機式
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 <#expression#>
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
演算子でマークされている場合、その演算子は中置演算子全体に適用されます。 ただし、括弧を使用すると、演算子のアプリケーションの範囲を明示的に示すことができます。
// await applies to both function calls
sum = await someAsyncFunction() + anotherAsyncFunction()
// await applies to both function calls
sum = await (someAsyncFunction() + anotherAsyncFunction())
// Error: await applies only to the first function call
sum = (await someAsyncFunction()) + anotherAsyncFunction()
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
演算子を最初に指定する必要があります。
Grammar of an await expression
await-operator → await
Infix Expressions
中置式
Infix expressions combine an infix binary operator with the expression that it takes as its left- and right-hand arguments. It has the following form:
中置式は、中置二項演算子と、その左側と右側の引数として受け取る式を組み合わせます。 次のような形式になります。
<#left-hand argument#> <#operator#> <#right-hand argument#>
For information about the behavior of these operators, see Basic Operators and Advanced Operators.
これらの演算子の動作については、「基本演算子」と「高度な演算子」を参照してください。
For information about the operators provided by the Swift standard library, see Operator Declarations(Link:developer.apple.com).
Swift 標準ライブラリで提供される演算子については、「演算子の宣言(Link:developer.apple.com)(英語)」を参照してください。
Note
注釈
At parse time, an expression made up of infix operators is represented as a flat list. This list is transformed into a tree by applying operator precedence. For example, the expression 2 + 3 * 5
is initially understood as a flat list of five items, 2
, +
, 3
, *
, and 5
. This process transforms it into the tree (2 + (3 * 5)).
解析時には、中置演算子で構成される式はフラット リストとして表されます。 このリストは、演算子の優先順位を適用することによってツリーに変換されます。 たとえば、式 2 + 3 * 5
は、最初は 2
、+
、3
、*
、5
の 5 つの項目のフラット リストとして理解されます。このプロセスにより、式がツリー (2 + (3 * 5))
に変換されます。
Grammar of an infix expression
infix-expression → infix-operator prefix-expression
infix-expression → assignment-operator try-operator? await-operator? prefix-expression
infix-expression → conditional-operator try-operator? await-operator? prefix-expression
infix-expression → type-casting-operator
infix-expressions → infix-expression infix-expressions?
Assignment Operator
代入演算子
The assignment operator sets a new value for a given expression. It has the following form:
代入演算子は、指定された式に新しい値を設定します。 次のような形式になります。
<#expression#> = <#value#>
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:
式の値は、値を評価して得られた値に設定されます。 式がタプルの場合、値は同じ数の要素を持つタプルである必要があります。 (ネストされたタプルは許可されます。)値の各部分から式の対応する部分への代入が実行されます。 例えば:
(a, _, (b, c)) = ("test", 9.45, (12, 3))
// a is "test", b is 12, c is 3, and 9.45 is ignored
The assignment operator doesn’t return any value.
代入演算子は値を返しません。
Grammar of an assignment operator
assignment-operator → =
Ternary Conditional Operator
3項条件演算子
The ternary conditional operator evaluates to one of two given values based on the value of a condition. It has the following form:
3 項条件演算子は、条件の値に基づいて、指定された 2 つの値のいずれかに評価します。 次のような形式になります。
<#condition#> ? <#expression used if true#> : <#expression used if false#>
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
と評価された場合、条件演算子は最初の式を評価し、その値を返します。 それ以外の場合は、2 番目の式を評価し、その値を返します。 未使用の式は評価されません。
For an example that uses the ternary conditional operator, see Ternary Conditional Operator.
三項条件演算子を使用する例については、「三項条件演算子」を参照してください。
Grammar of a conditional operator
conditional-operator → ?
expression :
Type-Casting Operators
型キャスト演算子
There are four type-casting operators: the is
operator, the as
operator, the as?
operator, and the as!
operator.
型キャスト演算子は 4 つあります: is
演算子、as
演算子、as?
演算子、および as!
演算子。
They have the following form:
それらの形式は次のとおりです。
<#expression#> is <#type#>
<#expression#> as <#type#>
<#expression#> as? <#type#>
<#expression#> as! <#type#>
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
演算子は、expression を指定された型にキャストできるかどうかを実行時にチェックします。 expression を指定された型にキャストできる場合は 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
演算子は、アップキャストやブリッジなど、キャストが常に成功することがコンパイル時にわかっている場合にキャストを実行します。 アップキャストを使用すると、中間変数を使用せずに、式をその型のスーパータイプのインスタンスとして使用できます。 次のアプローチは同等です。
func f(_ any: Any) { print("Function for Any") }
func f(_ int: Int) { print("Function for Int") }
let x = 10
f(x)
// Prints "Function for Int"
let y: Any = x
f(y)
// Prints "Function for Any"
f(x as Any)
// Prints "Function for Any"
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(Link:developer.apple.com).
ブリッジングを使用すると、新しいインスタンスを作成することなく、String
などの Swift 標準ライブラリ 型の式を、NSString
などの対応する 基礎型として使用できます。 ブリッジングの詳細については、「基礎型の使用(Link:developer.apple.com)(英語)」を参照してください。
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?
演算子は、指定された型へのexpression の条件付きキャストを実行します。 as?
演算子は、指定された型のオプションを返します。 実行時にキャストが成功すると、expression の値がオプションでラップされて返されます。 それ以外の場合、返される値は 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!
演算子は、指定された型へのexpression の強制キャストを実行します。 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.
型キャストの詳細と型キャスト演算子の使用例については、「型キャスト」を参照してください。
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
一次式
Primary expressions are the most basic kind of expression. They can be used as expressions on their own, and they can be combined with other tokens to make prefix expressions, infix expressions, and postfix expressions.
一次式は、最も基本的な種類の式です。 これらは単独で式として使用でき、他のトークンと組み合わせて前置式、中置式、および後置式を作成できます。
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 → macro-expansion-expression
primary-expression → key-path-expression
primary-expression → selector-expression
primary-expression → key-path-string-expression
Literal Expression
リテラル式
A literal expression consists of either an ordinary literal (such as a string or a number), an array or dictionary literal, or a playground literal.
リテラル式は、通常のリテラル(文字列や数値など)、配列リテラル、辞書リテラル、またはプレイグラウンド リテラルのいずれかで構成されます。
Note
注釈
Prior to Swift 5.9, the following special literals were recognized: #column
, #dsohandle
, #fileID
, #filePath
, #file
, #function
, and #line
. These are now implemented as macros in the Swift standard library: column()
(Link:developer.apple.com), dsohandle()
(Link:developer.apple.com), fileID()
(Link:developer.apple.com), filePath()
(Link:developer.apple.com), file()
(Link:developer.apple.com), function()
(Link:developer.apple.com), and line()
(Link:developer.apple.com).
Swift 5.9 より前では、#column、#dsohandle、#fileID、#filePath、#file、#function、#line
の特殊なリテラルが認識されていました。 これらは現在、Swift 標準ライブラリのマクロとして実装されています: column()
(Link:developer.apple.com), dsohandle()
(Link:developer.apple.com), fileID()
(Link:developer.apple.com)(英語), filePath()
(Link:developer.apple.com)(英語), file()
(Link:developer.apple.com)(英語), function()
(Link:developer.apple.com)(英語), and line()
(Link:developer.apple.com)(英語)。
An array literal is an ordered collection of values. It has the following form:
配列リテラルは、順序付けられた値のコレクションです。 次のような形式になります。
[<#value 1#>, <#value 2#>, <#...#>]
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
はそれらに最も近い共通のスーパータイプです。 空の配列リテラルは、空の角括弧のペアを使用して記述され、指定された型の空の配列を作成するために使用できます。
var emptyArray: [Double] = []
A dictionary literal is an unordered collection of key-value pairs. It has the following form:
辞書リテラルは、キーと値のペアの順序付けされていないコレクションです。 次のような形式になります。
[<#key 1#>: <#value 1#>, <#key 2#>: <#value 2#>, <#...#>]
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
は、それぞれの値に最も近い共通のスーパータイプになります。 空の辞書リテラルは、空の配列リテラルと区別するために、一対のかっこ ([:]
) 内のコロンとして記述されます。 空の辞書リテラルを使用して、指定したキーと値の型の空の辞書リテラルを作成できます。
var emptyDictionary: [String: Double] = [:]
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(Link:developer.apple.com) in Xcode Help.
Xcode でのプレイグラウンド リテラルの使用については、Xcode ヘルプの「色、ファイル、または画像リテラルを追加する(Link:developer.apple.com)(英語)」を参照してください。
Grammar of a literal expression
literal-expression → literal
literal-expression → array-literal | dictionary-literal | playground-literal
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 → #color
(
red
:
expression ,
green
:
expression ,
blue
:
expression ,
alpha
:
expression )
playground-literal → #file
(
resource
:
expression )
playground-literal → #image
(
resource
:
expression )
Self Expression
自己式
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
式は、現在の型またはそれが発生する型のインスタンスへの明示的な参照です。 次のような形式があります。
self
self.<#member name#>
self[<#subscript index#>]
self(<#initializer arguments#>)
self.init(<#initializer arguments#>)
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
式は、メンバーにアクセスするときにスコープを指定するために使用され、関数パラメーターなど、スコープ内に同じ名前の別の変数がある場合に曖昧さを解消します。 例えば:
class SomeClass {
var greeting: String
init(greeting: String) {
self.greeting = greeting
}
}
In a mutating method of a value type, you can assign a new instance of that value type to self
. For example:
値の型の変更メソッドでは、その値の型の新しいインスタンスをself
に割り当てることができます。 例えば:
struct Point {
var x = 0.0, y = 0.0
mutating func moveBy(x deltaX: Double, y deltaY: Double) {
self = Point(x: x + deltaX, y: y + deltaY)
}
}
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
スーパークラス式
A superclass expression lets a class interact with its superclass. It has one of the following forms:
スーパークラス式を使用すると、クラスがそのスーパークラスと対話できるようになります。 次のいずれかの形式になります。
super.<#member name#>
super[<#subscript index#>]
super.init(<#initializer arguments#>)
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.
最初の形式は、スーパークラスのメンバーにアクセスするために使用されます。 2 番目の形式は、スーパークラスの添字実装にアクセスするために使用されます。 3 番目の形式は、スーパークラスの初期化子にアクセスするために使用されます。
Subclasses can use a superclass expression in their implementation of members, subscripting, and initializers to make use of the implementation in their superclass.
サブクラスは、メンバー、添字、イニシャライザの実装でスーパークラス式を使用して、スーパークラスの実装を利用できます。
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
条件式
A conditional expression evaluates to one of several given values based on the value of a condition. It has one the following forms:
条件式は、条件の値に基づいて、いくつかの指定された値のいずれかに評価されます。 次のいずれかの形式があります。
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#>
}
A conditional expression has the same behavior and syntax as an if
statement or a switch
statement, except for the differences that the paragraphs below describe.
条件式は、以下の段落で説明する相違点を除き、if
ステートメントまたは switch
ステートメントと同じ動作および構文を持ちます。
A conditional expression appears only in the following contexts:
条件式は、次のコンテキストでのみ使用されます。
- As the value assigned to a variable.
- 変数に代入される値として。
- As the initial value in a variable or constant declaration.
- 変数または定数宣言の初期値として。
- As the error thrown by a
throw
expression. throw
式によってスローされるエラーとして。- As the value returned by a function, closure, or property getter.
- 関数、クロージャ、またはプロパティ ゲッターによって返される値として。
- As the value inside a branch of a conditional expression.
- 条件式の分岐内の値として。
The branches of a conditional expression are exhaustive, ensuring that the expression always produces a value regardless of the condition. This means each if
branch needs a corresponding else
branch.
条件式の分岐は網羅的であり、条件に関係なく式が常に値を生成するようにします。 これは、各 if
ブランチに対応する else
ブランチが必要であることを意味します。
Each branch contains either a single expression, which is used as the value for the conditional expression when that branch’s conditional is true, a throw
statement, or a call to a function that never returns.
各ブランチには、ブランチの条件が true の場合に条件式の値として使用される単一の式、throw
ステートメント、または返されない関数の呼び出しのいずれかが含まれます。
Each branch must produce a value of the same type. Because type checking of each branch is independent, you sometimes need to specify the value’s type explicitly, like when branches include different kinds of literals, or when a branch’s value is nil
. When you need to provide this information, add a type annotation to the variable that the result is assigned to, or add an as
cast to the branches’ values.
各ブランチは同じ型の値を生成する必要があります。 各ブランチの型チェックは独立しているため、ブランチに異なる種類のリテラルが含まれている場合や、ブランチの値が nil
である場合など、値の型を明示的に指定する必要がある場合があります。 この情報を提供する必要がある場合は、結果が割り当てられる変数に型アノテーションを追加するか、ブランチの値に as
キャストを追加します。
let number: Double = if someCondition { 10 } else { 12.34 }
let number = if someCondition { 10 as Double } else { 12.34 }
Inside a result builder, conditional expressions can appear only as the initial value of a variable or constant. This behavior means when you write if
or switch
in a result builder — outside of a variable or constant declaration — that code is understood as a branch statement and one of the result builder’s methods transforms that code.
結果ビルダー内では、条件式は変数または定数の初期値としてのみ使用できます。 この動作は、変数や定数の宣言の外で、結果ビルダーに if
または switch
を記述すると、そのコードが分岐ステートメントとして理解され、結果ビルダーのメソッドの 1 つがそのコードを変換することを意味します。
Don’t put a conditional expression in a try
expression, even if one of the branches of a conditional expression is throwing.
条件式の分岐の 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 }
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
クロージャ式
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:
クロージャ式は、他のプログラミング言語ではラムダまたは匿名関数としても知られるクロージャを作成します。 関数宣言と同様に、クロージャにはステートメントが含まれており、それを囲んでいるスコープから定数と変数をキャプチャします。 次のような形式になります。
{ (<#parameters#>) -> <#return type#> in
<#statements#>
}
The parameters have the same form as the parameters in a function declaration, as described in Function Declaration.
「関数宣言」で説明されているように、パラメータは関数宣言のパラメータと同じ形式です。
Writing throws
or async
in a closure expression explicitly marks a closure as throwing or asynchronous.
クロージャ式に throw
または async
を記述すると、クロージャがスローまたは非同期として明示的にマークされます。
{ (<#parameters#>) async throws -> <#return type#> in
<#statements#>
}
If the body of a closure includes a try expression, the closure is understood to be throwing. Likewise, if it includes an await expression, it’s understood to be asynchronous.
クロージャの本体に try
式が含まれている場合、クロージャはスローであると理解されます。 同様に、await
式が含まれている場合は、非同期であると見なされます。
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:
次のクロージャー式は同等です。
myFunction { (x: Int, y: Int) -> Int in
return x + y
}
myFunction { x, y in
return x + y
}
myFunction { return $0 + $1 }
myFunction { $0 + $1 }
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.
クロージャのエスケープの詳細については、「クロージャのエスケープ」を参照してください。
Capture Lists
キャプチャリスト
By default, a closure expression captures constants and variables from its surrounding scope with strong references to those values. You can use a capture list to explicitly control how values are captured in a closure.
デフォルトでは、クロージャ式は、それらの値への強参照を使用して周囲のスコープから定数と変数をキャプチャします。 キャプチャ リストを使用して、クロージャで値をキャプチャする方法を明示的に制御できます。
A capture list is written as a comma-separated list of expressions surrounded by square brackets, before the list of parameters. If you use a capture list, you must also use the in
keyword, even if you omit the parameter names, parameter types, and return type.
キャプチャ リストは、パラメータのリストの前に、角括弧で囲まれた式のカンマ区切りリストとして記述されます。 キャプチャ リストを使用する場合は、パラメータ名、パラメータの型、戻り値の型を省略した場合でも、in
キーワードも使用する必要があります。
The entries in the capture list are initialized when the closure is created. For each entry in the capture list, a constant is initialized to the value of the constant or variable that has the same name in the surrounding scope. For example in the code below, a
is included in the capture list but b
is not, which gives them different behavior.
キャプチャ リスト内のエントリは、クロージャの作成時に初期化されます。 キャプチャ リストの各エントリについて、定数は周囲のスコープ内で同じ名前を持つ定数または変数の値に初期化されます。 たとえば、以下のコードでは、a
はキャプチャ リストに含まれていますが、b
は含まれていないため、動作が異なります。
var a = 0
var b = 0
let closure = { [a] in
print(a, b)
}
a = 10
b = 10
closure()
// Prints "0 10"
There are two different things named a
, the variable in the surrounding scope and the constant in the closure’s scope, but only one variable named b
. The a
in the inner scope is initialized with the value of the a
in the outer scope when the closure is created, but their values aren’t connected in any special way. This means that a change to the value of a
in the outer scope doesn’t affect the value of a
in the inner scope, nor does a change to a
inside the closure affect the value of a
outside the closure. In contrast, there’s only one variable named b
— the b
in the outer scope — so changes from inside or outside the closure are visible in both places.
a
という名前の 2 つの異なるもの、周囲のスコープ内の変数とクロージャのスコープ内の定数がありますが、b
という名前の変数は 1 つだけです。 内側のスコープの a
は、クロージャの作成時に外側のスコープの a
の値で初期化されますが、それらの値は特別な方法で接続されません。 これは、外側のスコープ内の a
の値を変更しても、内側のスコープ内の a
の値に影響を与えず、クロージャ内の a
を変更しても、クロージャの外側の a
の値に影響を与えないことを意味します。 対照的に、b
という名前の変数は 1 つだけ (外側のスコープの b
) なので、クロージャの内側または外側からの変更は両方の場所で表示されます。
This distinction isn’t visible when the captured variable’s type has reference semantics. For example, there are two things named x
in the code below, a variable in the outer scope and a constant in the inner scope, but they both refer to the same object because of reference semantics.
キャプチャされた変数の型に参照セマンティクスがある場合、この区別は表示されません。 たとえば、以下のコードには x
という名前のものが 2 つあります。外側のスコープに変数、内側のスコープに定数がありますが、参照セマンティクスにより、両方とも同じオブジェクトを参照します。
class SimpleClass {
var value: Int = 0
}
var x = SimpleClass()
var y = SimpleClass()
let closure = { [x] in
print(x.value, y.value)
}
x.value = 10
y.value = 10
closure()
// Prints "10 10"
If the type of the expression’s value is a class, you can mark the expression in a capture list with weak
or unowned
to capture a weak or unowned reference to the expression’s value.
式の値のタイプがクラスの場合、キャプチャ リスト内の式をweak
またはunowned
とマークして、式の値へのweak 参照またはunowned 参照をキャプチャできます。
myFunction { print(self.title) } // implicit strong capture
myFunction { [self] in print(self.title) } // explicit strong capture
myFunction { [weak self] in print(self!.title) } // weak capture
myFunction { [unowned self] in print(self.title) } // unowned capture
You can also bind an arbitrary expression to a named value in a capture list. The expression is evaluated when the closure is created, and the value is captured with the specified strength. For example:
任意の式をキャプチャ リスト内の名前付き値にバインドすることもできます。 クロージャの作成時に式が評価され、指定された強度で値が取得されます。 例えば:
// Weak capture of "self.parent" as "parent"
myFunction { [weak parent = self.parent] in print(parent!.title) }
For more information and examples of closure expressions, see Closure Expressions. For more information and examples of capture lists, see Resolving Strong Reference Cycles for Closures.
クロージャ式の詳細と例については、「クロージャ式」を参照してください。 キャプチャ リストの詳細と例については、「クロージャの強参照サイクルの解決」を参照してください。
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
暗黙的なメンバー式
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:
暗黙的なメンバー式は、型推論によって暗黙的な型を決定できるコンテキストで、列挙型ケースや型メソッドなどの型のメンバーにアクセスするための短縮された方法です。 次のような形式になります。
.<#member name#>
For example:
例えば:
var x = MyEnumeration.someValue
x = .anotherValue
If the inferred type is an optional, you can also use a member of the non-optional type in an implicit member expression.
推論された型がオプションの場合、暗黙的なメンバー式で非オプション型のメンバーを使用することもできます。
var someOptional: MyEnumeration? = .someValue
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:
暗黙的なメンバー式の後には、「後置式」にリストされている後置演算子または他の後置構文を続けることができます。 これは、連鎖された暗黙的なメンバー式と呼ばれます。 すべての連鎖された後置式が同じ型を持つのが一般的ですが、唯一の要件は、連鎖された暗黙的なメンバー式全体が、そのコンテキストによって暗示される型に変換可能である必要があることです。 具体的には、暗黙の型がオプションの場合は非オプション型の値を使用でき、暗黙の型がクラス型の場合はそのサブクラスの 1 つの値を使用できます。 例えば:
class SomeClass {
static var shared = SomeClass()
static var sharedSubclass = SomeSubclass()
var a = AnotherClass()
}
class SomeSubclass: SomeClass { }
class AnotherClass {
static var s = SomeClass()
func f() -> SomeClass { return AnotherClass.s }
}
let x: SomeClass = .shared.a.f()
let y: SomeClass? = .shared
let z: SomeClass = .sharedSubclass
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
に変換可能です。
Grammar of an implicit member expression
implicit-member-expression → .
identifier
implicit-member-expression → .
identifier .
postfix-expression
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
です。
Grammar of a parenthesized expression
parenthesized-expression → (
expression )
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:
タプル式は、かっこで囲まれたカンマ区切りの式のリストで構成されます。 各式の前に、コロン (:
) で区切ってオプションの識別子を付けることができます。 次のような形式になります。
(<#identifier 1#>: <#expression 1#>, <#identifier 2#>: <#expression 2#>, <#...#>)
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
が同じレベルに 2 回出現するため無効です。 ただし、(a: 10, b: (a: 1, x: 2))
は有効です。a
は 2 回現れますが、外側のタプルに 1 回、内側のタプルに 1 回現れます。
A tuple expression can contain zero expressions, or it can contain two or more expressions. A single expression inside parentheses is a parenthesized expression.
タプル式には式をまったく含めないことも、2 つ以上の式を含めることもできます。 括弧内の単一の式は括弧で囲まれた式です。
Note
注釈
Both an empty tuple expression and an empty tuple type are written ()
in Swift. Because Void
is a type alias for ()
, you can use it to write an empty tuple type. However, like all type aliases, Void
is always a type — you can’t use it to write an empty tuple expression.
Swift では、空のタプル式と空のタプル型の両方が ()
で記述されます。 Void は ()
の型エイリアスであるため、これを使用して空のタプル型を記述することができます。 ただし、すべての型エイリアスと同様、Void は常に型です。これを使用して空のタプル式を記述することはできません。
Grammar of a tuple 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
ワイルドカード式
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
は無視されます。
(x, _) = (10, 20)
// x is 10, and 20 is ignored
Grammar of a wildcard expression
wildcard-expression → _
Macro-Expansion Expression
マクロ展開式
A macro-expansion expression consists of a macro name followed by a comma-separated list of the macro’s arguments in parentheses. The macro is expanded at compile time. Macro-expansion expressions have the following form:
マクロ展開式は、マクロ名と、それに続く括弧内のマクロの引数のカンマ区切りリストで構成されます。 マクロはコンパイル時に展開されます。 マクロ展開式の形式は次のとおりです。
<#macro name#>(<#macro argument 1#>, <#macro argument 2#>)
A macro-expansion expression omits the parentheses after the macro’s name if the macro doesn’t take any arguments.
マクロが引数を取らない場合、マクロ展開式ではマクロ名の後の括弧が省略されます。
A macro-expansion expression can’t appear as the default value for a parameter, except the file()
and line()
macros from the Swift standard library. When used as the default value of a function or method parameter, these macros are evaluated using the source code location of the call site, not the location where they appear in a function definition.
マクロ展開式は、Swift 標準ライブラリの file()
マクロと line()
マクロを除き、パラメータのデフォルト値として表示できません。 関数またはメソッドのパラメーターのデフォルト値として使用される場合、これらのマクロは、関数定義内で出現する場所ではなく、呼び出しサイトのソース コードの場所を使用して評価されます。
func f(a: Int = #line, b: Int = (#line), c: Int = 100 + #line) {
print(a, b, c)
}
f() // Prints "4 1 101"
In the function above, the default value for a
is a single macro expression, so that macro is evaluated using the source code location where f(a:
is called. In contrast, the values for b
and c
are expressions that contain a macro — the macros in those expressions are evaluated using the source code location where f(a:
is defined.
上記の関数では、a
のデフォルト値は単一のマクロ式であるため、マクロは f(a:b:c:)
が呼び出されるソースコードの場所を使用して評価されます。対照的に、b
と c
の値はマクロを含む式であり、これらの式内のマクロは f(a:b:c:)
が定義されているソースコードの場所を使用して評価されます。
When you use a macro as a default value, it’s type checked without expanding the macro, to check the following requirements:
マクロをデフォルト値として使用する場合、マクロを展開せずに型チェックが行われ、次の要件がチェックされます。
- The macro’s access level is the same as or less restrictive than the function that uses it.
- マクロのアクセス レベルは、それを使用する関数と同じか、それよりも制限が緩やかです。
- The macro either takes no arguments, or its arguments are literals without string interpolation.
- マクロは引数を取らないか、引数が文字列補間のないリテラルです。
- The macro’s return type matches the parameter’s type.
- マクロの戻り値の型はパラメータの型と一致します。
You use macro expressions to call freestanding macros. To call an attached macro, use the custom attribute syntax described in Attributes. Both freestanding and attached macros expand as follows:
独立したマクロを呼び出すには、マクロ式を使用します。 添付されたマクロを呼び出すには、「属性」で説明されているカスタム属性構文を使用します。 独立したマクロと接続されたマクロはどちらも次のように展開されます。
- Swift parses the source code to produce an abstract syntax tree (AST).
- Swift はソース コードを解析して抽象構文ツリー (AST) を生成します。
- The macro implementation receives AST nodes as its input and performs the transformations needed by that macro.
- マクロ実装は AST ノードを入力として受け取り、そのマクロに必要な変換を実行します。
- The transformed AST nodes that the macro implementation produced are added to the original AST.
- マクロ実装によって生成された変換された AST ノードは、元の AST に追加されます。
The expansion of each macro is independent and self-contained. However, as a performance optimization, Swift might start an external process that implements the macro and reuse the same process to expand multiple macros. When you implement a macro, that code must not depend on what macros your code previously expanded, or on any other external state like the current time.
各マクロの展開は独立しており、自己完結型です。 ただし、パフォーマンスの最適化として、Swift はマクロを実装する外部プロセスを開始し、同じプロセスを再利用して複数のマクロを展開する場合があります。 マクロを実装する場合、そのコードは、コードが以前に展開したマクロや、現在の時刻などの他の外部状態に依存してはなりません。
For nested macros and attached macros that have multiple roles, the expansion process repeats. Nested macro-expansion expressions expand from the outside in. For example, in the code below outerMacro(_:)
expands first and the unexpanded call to innerMacro(_:)
appears in the abstract syntax tree that outerMacro(_:)
receives as its input.
ネストされたマクロおよび複数の役割を持つ添付マクロの場合、展開プロセスが繰り返されます。 ネストされたマクロ展開式は外側から内側に展開します。たとえば、以下のコードでは、outerMacro(_:)
が最初に展開され、展開されていない innerMacro(_:)
の呼び出しが、outerMacro(_:)
がその入力として受け取る抽象構文ツリーに表示されます。
#outerMacro(12, #innerMacro(34), "some text")
An attached macro that has multiple roles expands once for each role. Each expansion receives the same, original, AST as its input. Swift forms the overall expansion by collecting all of the generated AST nodes and putting them in their corresponding places in the AST.
複数のロールを持つアタッチされたマクロは、ロールごとに 1 回展開されます。 各拡張は、同じオリジナルの AST を入力として受け取ります。 Swift は、生成された AST ノードをすべて収集し、それらを AST 内の対応する場所に配置することによって、全体的な拡張を形成します。
For an overview of macros in Swift, see Macros.
Swift のマクロの概要については、「マクロ」を参照してください。
Grammar of a macro-expansion expression
macro-expansion-expression → #
identifier generic-argument-clause? function-call-argument-clause? trailing-closures?
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:
キーパス式は、型のプロパティまたは添え字を参照します。 キーパス式は、キーと値の監視などの動的プログラミング タスクで使用します。 それらの形式は次のとおりです。
\<#type name#>.<#path#>
The type name is the name of a concrete type, including any generic parameters, such as String
, [Int]
, or Set<Int>
.
型名は具体的な型の名前で、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.
パスは、プロパティ名、添字、オプションの連鎖式、および強制アンラップ式で構成されます。 これらのキーパス コンポーネントはそれぞれ、任意の順序で必要に応じて何度でも繰り返すことができます。
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:)
サブスクリプトに渡します。 例えば:
struct SomeStructure {
var someValue: Int
}
let s = SomeStructure(someValue: 12)
let pathToProperty = \SomeStructure.someValue
let value = s[keyPath: pathToProperty]
// value is 12
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
:
型推論によって暗黙の型を決定できるコンテキストでは、型名を省略できます。 次のコードでは、\SomeClass.someProperty
の代わりに .someProperty
を使用します。
class SomeClass: NSObject {
@objc dynamic var someProperty: Int
init(someProperty: Int) {
self.someProperty = someProperty
}
}
let c = SomeClass(someProperty: 10)
c.observe(\.someProperty) { object, change in
// ...
}
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:
パスは self
を参照して ID キー パス (\.self
) を作成できます。 ID キー パスはインスタンス全体を参照するため、これを使用すると、変数に格納されているすべてのデータに 1 回の手順でアクセスして変更できます。 例えば:
var compoundValue = (a: 1, b: 2)
// Equivalent to compoundValue = (a: 10, b: 20)
compoundValue[keyPath: \.self] = (a: 10, b: 20)
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:
パスには、プロパティの値のプロパティを参照するために、ピリオドで区切られた複数のプロパティ名を含めることができます。 このコードは、キー パス式 \OuterStructure.outer.someValue
を使用して、OuterStructure
型のouter
プロパティの someValue
プロパティにアクセスします。
struct OuterStructure {
var outer: SomeStructure
init(someValue: Int) {
self.outer = SomeStructure(someValue: someValue)
}
}
let nested = OuterStructure(someValue: 24)
let nestedKeyPath = \OuterStructure.outer.someValue
let nestedValue = nested[keyPath: nestedKeyPath]
// nestedValue is 24
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:
添え字のパラメータ型がHashable
プロトコルに準拠している限り、パスには括弧を使用して添え字を含めることができます。 この例では、キー パスの添字を使用して、配列の 2 番目の要素にアクセスします。
let greetings = ["hello", "hola", "bonjour", "안녕"]
let myGreeting = greetings[keyPath: \[String].[1]]
// myGreeting is 'hola'
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
配列の 3 番目の要素にアクセスします。 index
が変更されると、キーパス式は依然として 3 番目の要素を参照しますが、クロージャは新しいインデックスを使用します。
var index = 2
let path = \[String].[index]
let fn: ([String]) -> String = { strings in strings[index] }
print(greetings[keyPath: path])
// Prints "bonjour"
print(fn(greetings))
// Prints "bonjour"
// Setting 'index' to a new value doesn't affect 'path'
index += 1
print(greetings[keyPath: path])
// Prints "bonjour"
// Because 'fn' closes over 'index', it uses the new value
print(fn(greetings))
// Prints "안녕"
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:
パスでは、オプションのチェーンと強制アンラップを使用できます。 このコードは、キー パスでオプションのチェーンを使用して、オプションの文字列のプロパティにアクセスします。
let firstGreeting: String? = greetings.first
print(firstGreeting?.count as Any)
// Prints "Optional(5)"
// Do the same thing using a key path.
let count = greetings[keyPath: \[String].first?.count]
print(count as Any)
// Prints "Optional(5)"
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.
キー パスのコンポーネントを組み合わせて一致させると、型内に深くネストされた値にアクセスできます。 次のコードは、これらのコンポーネントを組み合わせたキーパス式を使用して、配列のディクショナリのさまざまな値とプロパティにアクセスします。
let interestingNumbers = ["prime": [2, 3, 5, 7, 11, 13, 17],
"triangular": [1, 3, 6, 10, 15, 21, 28],
"hexagonal": [1, 6, 15, 28, 45, 66, 91]]
print(interestingNumbers[keyPath: \[String: [Int]].["prime"]] as Any)
// Prints "Optional([2, 3, 5, 7, 11, 13, 17])"
print(interestingNumbers[keyPath: \[String: [Int]].["prime"]![0]])
// Prints "2"
print(interestingNumbers[keyPath: \[String: [Int]].["hexagonal"]!.count])
// Prints "7"
print(interestingNumbers[keyPath: \[String: [Int]].["hexagonal"]!.count.bitWidth])
// Prints "64"
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 の値を生成するキーパス式を使用できます。
struct Task {
var description: String
var completed: Bool
}
var toDoList = [
Task(description: "Practice ping-pong.", completed: false),
Task(description: "Buy a pirate costume.", completed: true),
Task(description: "Visit Boston in the Fall.", completed: false),
]
// Both approaches below are equivalent.
let descriptions = toDoList.filter(\.completed).map(\.description)
let descriptions2 = toDoList.filter { $0.completed }.map { $0.description }
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.
キー パス式の副作用は、式が評価される時点でのみ評価されます。 たとえば、キー パス式の添字内で関数呼び出しを行った場合、その関数はキー パスが使用されるたびではなく、式の評価の一部として 1 回だけ呼び出されます。
func makeIndex() -> Int {
print("Made an index")
return 0
}
// The line below calls makeIndex().
let taskKeyPath = \[Task][makeIndex()]
// Prints "Made an index"
// Using taskKeyPath doesn't call makeIndex() again.
let someTask = toDoList[keyPath: taskKeyPath]
For more information about using key paths in code that interacts with Objective-C APIs, see Using Objective-C Runtime Features in Swift(Link:developer.apple.com). For information about key-value coding and key-value observing, see Key-Value Coding Programming Guide(Link:developer.apple.com) and Key-Value Observing Programming Guide(Link:developer.apple.com).
Objective-C API と対話するコードでキーパスを使用する方法の詳細については、「Swift での Objective-C ランタイム機能の使用(Link:developer.apple.com)(英語)」を参照してください。 Key-Value コーディングと Key-Value 観察の詳細については、「Key-Value コーディング プログラミング ガイド(Link:developer.apple.com)(英語)」および「Key-Value 観察プログラミング ガイド(Link:developer.apple.com)(英語)」を参照してください。
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 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 のメソッドまたはプロパティのゲッターまたはセッターを参照するために使用されるセレクターにアクセスできます。 次のような形式になります。
#selector(<#method name#>)
#selector(getter: <#property name#>)
#selector(setter: <#property name#>)
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:
メソッド名とプロパティ名は、Objective-C ランタイムで使用できるメソッドまたはプロパティへの参照である必要があります。 セレクター式の値は、セレクター 型のインスタンスです。 例えば:
class SomeClass: NSObject {
@objc let property: String
@objc(doSomethingWithInt:)
func doSomething(_ x: Int) { }
init(property: String) {
self.property = property
}
}
let selectorForMethod = #selector(SomeClass.doSomething(_:))
let selectorForPropertyGetter = #selector(getter: SomeClass.property)
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.
プロパティのゲッターのセレクターを作成する場合、プロパティ名は変数または定数プロパティへの参照にすることができます。 対照的に、プロパティのセッターのセレクターを作成する場合、プロパティ名は変数プロパティのみへの参照である必要があります。
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:
メソッド名には、グループ化のためのかっこを含めることができます。また、名前は同じだが型シグネチャが異なるメソッド間を明確にするための as
演算子を含めることもできます。 例えば:
extension SomeClass {
@objc(doSomethingWithString:)
func doSomething(_ x: String) { }
}
let anotherSelector = #selector(SomeClass.doSomething(_:) as (SomeClass) -> (String) -> Void)
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 ランタイムに公開されていることを確認できます。
Note
注釈
Although the method name and the property name are expressions, they’re never evaluated.
メソッド名とプロパティ名は式ですが、評価されることはありません。
For more information about using selectors in Swift code that interacts with Objective-C APIs, see Using Objective-C Runtime Features in Swift(Link:developer.apple.com).
Objective-C API と対話する Swift コードでセレクターを使用する方法の詳細については、「Swift での Objective-C ランタイム機能の使用(Link:developer.apple.com)(英語)」を参照してください。
Grammar of a selector expression
selector-expression → #selector
(
expression )
selector-expression → #selector
(
getter:
expression )
selector-expression → #selector
(
setter:
expression )
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:
キーパス文字列式を使用すると、キー値コーディングおよびキー値監視 API で使用するために、Objective-C のプロパティを参照するために使用される文字列にアクセスできます。 次のような形式になります。
#keyPath(<#property name#>)
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:
プロパティ名は、Objective-C ランタイムで使用できるプロパティへの参照である必要があります。 コンパイル時に、キーパス文字列式は文字列リテラルに置き換えられます。 例えば:
class SomeClass: NSObject {
@objc var someProperty: Int
init(someProperty: Int) {
self.someProperty = someProperty
}
}
let c = SomeClass(someProperty: 12)
let keyPath = #keyPath(SomeClass.someProperty)
if let value = c.value(forKey: keyPath) {
print(value)
}
// Prints "12"
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.
クラス内でキーパス文字列式を使用する場合、クラス名を省略してプロパティ名だけを記述することで、そのクラスのプロパティを参照できます。
extension SomeClass {
func getSomeKeyPath() -> String {
return #keyPath(someProperty)
}
}
print(keyPath == c.getSomeKeyPath())
// Prints "true"
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(Link:developer.apple.com). For information about key-value coding and key-value observing, see Key-Value Coding Programming Guide(Link:developer.apple.com) and Key-Value Observing Programming Guide(Link:developer.apple.com).
Objective-C API と対話する Swift コードでキーパスを使用する方法の詳細については、「Swift での Objective-C ランタイム機能の使用(Link:developer.apple.com)(英語)」を参照してください。 Key-Value コーディングと Key-Value 観察の詳細については、「Key-Value コーディング プログラミング ガイド(Link:developer.apple.com)(英語)」および「Key-Value 観察プログラミング ガイド(Link:developer.apple.com)(英語)」を参照してください。
Note
注釈
Although the property name is an expression, it’s never evaluated.
プロパティ名は式ですが、評価されることはありません。
Grammar of a key-path string expression
key-path-string-expression → #key
(
expression )
Postfix Expressions
後置式
Postfix expressions are formed by applying a postfix operator or other postfix syntax to an expression. Syntactically, every primary expression is also a postfix expression.
後置式は、後置演算子または他の後置構文を式に適用することによって形成されます。 構文的には、すべての主式は後置式でもあります。
For information about the behavior of these operators, see Basic Operators and Advanced Operators.
これらの演算子の動作については、「基本演算子」と「高度な演算子」を参照してください。
For information about the operators provided by the Swift standard library, see Operator Declarations(Link:developer.apple.com).
Swift 標準ライブラリで提供される演算子については、「演算子の宣言(Link:developer.apple.com)(英語)」を参照してください。
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
関数呼び出し式
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:
関数呼び出し式は、関数名と、それに続く括弧内の関数の引数のカンマ区切りリストで構成されます。 関数呼び出し式は次の形式になります。
<#function name#>(<#argument value 1#>, <#argument value 2#>)
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:
関数定義にパラメータの名前が含まれている場合、関数呼び出しでは引数の値の前にコロン (:) で区切って名前を含める必要があります。 この種の関数呼び出し式は次の形式になります。
<#function name#>(<#argument name 1#>: <#argument value 1#>, <#argument name 2#>: <#argument value 2#>)
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:
関数呼び出し式には、閉じ括弧の直後にクロージャ式の形式で末尾クロージャを含めることができます。 末尾のクロージャは関数の引数として認識され、括弧で囲まれた最後の引数の後に追加されます。 最初のクロージャー式にはラベルがありません。 追加のクロージャ式の前には引数ラベルが付きます。 以下の例は、後続クロージャ構文を使用する関数呼び出しと使用しない関数呼び出しの同等のバージョンを示しています。
// someFunction takes an integer and a closure as its arguments
someFunction(x: x, f: { $0 == 13 })
someFunction(x: x) { $0 == 13 }
// anotherFunction takes an integer and two closures as its arguments
anotherFunction(x: x, f: { $0 == 13 }, g: { print(99) })
anotherFunction(x: x) { $0 == 13 } g: { print(99) }
If the trailing closure is the function’s only argument, you can omit the parentheses.
末尾のクロージャが関数の唯一の引数である場合は、括弧を省略できます。
// someMethod takes a closure as its only argument
myData.someMethod() { $0 == 13 }
myData.someMethod { $0 == 13 }
To include the trailing closures in the arguments, the compiler examines the function’s parameters from left to right as follows:
引数に末尾のクロージャを含めるために、コンパイラは次のように関数のパラメータを左から右に調べます。
Trailing Closure | Parameter | Action |
---|---|---|
Labeled | Labeled | If the labels are the same, the closure matches the parameter; otherwise, the parameter is skipped. |
Labeled | Unlabeled | The parameter is skipped. |
Unlabeled | Labeled or unlabeled | If the parameter structurally resembles a function type, as defined below, the closure matches the parameter; otherwise, the parameter is skipped. |
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:
パラメータが入出力パラメータではなく、パラメータが次のいずれかである場合、パラメータは構造的に関数タイプに似ています。
- A parameter whose type is a function type, like
(Bool) -> Int
- An autoclosure parameter whose wrapped expression’s type is a function type, like
@autoclosure () -> ((Bool) -> Int)
- A variadic parameter whose array element type is a function type, like
((Bool) -> Int)...
- A parameter whose type is wrapped in one or more layers of optional, like
Optional<(Bool) -> Int>
- A parameter whose type combines these allowed types, like
(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 より前のバージョンの Swift からのコードの移行を容易にするために、コンパイラは左から右と右から左の両方の順序をチェックします。 スキャン方向によって異なる結果が生成される場合、古い右から左の順序が使用され、コンパイラは警告を生成します。 Swift の将来のバージョンでは、常に左から右の順序が使用されます。
typealias Callback = (Int) -> Int
func someFunction(firstClosure: Callback? = nil,
secondClosure: Callback? = nil) {
let first = firstClosure?(10)
let second = secondClosure?(20)
print(first ?? "-", second ?? "-")
}
someFunction() // Prints "- -"
someFunction { return $0 + 100 } // Ambiguous
someFunction { return $0 } secondClosure: { return $0 } // Prints "10 20"
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 でコンパイラ警告を生成します。 Swift の将来のバージョンでは、「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.
「特別な名前を持つメソッド」で説明されているように、クラス、構造体、または列挙型では、いくつかのメソッドのいずれかを宣言することで、関数呼び出し構文の糖衣構文を有効にすることができます。
Implicit Conversion to a Pointer Type
ポインタ型への暗黙的な変換
In a function call expression, if the argument and parameter have a different type, the compiler tries to make their types match by applying one of the implicit conversions in the following list:
関数呼び出し式で、引数とパラメーターの型が異なる場合、コンパイラーは、次のリストにある暗黙的な変換のいずれかを適用して、それらの型を一致させようとします。
inout Some
can becomeType Unsafe
orPointer<Some Type> Unsafe
Mutable Pointer<Some Type> inout Array<Some
can becomeType> Unsafe
orPointer<Some Type> Unsafe
Mutable Pointer<Some Type> Array<Some
can becomeType> Unsafe
Pointer<Some Type> String
can becomeUnsafe
Pointer<CChar>
The following two function calls are equivalent:
次の 2 つの関数呼び出しは同等です。
func unsafeFunction(pointer: UnsafePointer<Int>) {
// ...
}
var myNumber = 1234
unsafeFunction(pointer: &myNumber)
withUnsafePointer(to: myNumber) { unsafeFunction(pointer: $0) }
A pointer that’s created by these implicit conversions is valid only for the duration of the function call. To avoid undefined behavior, ensure that your code never persists the pointer after the function call ends.
これらの暗黙的な変換によって作成されたポインターは、関数呼び出しの間のみ有効です。 未定義の動作を回避するには、関数呼び出しの終了後にコードがポインターを永続化しないようにしてください。
Note
注釈
When implicitly converting an array to an unsafe pointer, Swift ensures that the array’s storage is contiguous by converting or copying the array as needed. For example, you can use this syntax with an array that was bridged to Array
from an NSArray
subclass that makes no API contract about its storage. If you need to guarantee that the array’s storage is already contiguous, so the implicit conversion never needs to do this work, use ContiguousArray
instead of Array
.
配列を安全でないポインターに暗黙的に変換する場合、Swift は必要に応じて配列を変換またはコピーすることで、配列のストレージが連続していることを保証します。 たとえば、ストレージに関する API コントラクトを作成しない NSArray
サブクラスから Array
にブリッジされた配列でこの構文を使用できます。 配列のストレージがすでに連続していることを保証する必要があり、暗黙的な変換でこの作業を行う必要がない場合は、Array
の代わりに ContiguousArray
を使用します。
Using &
instead of an explicit function like withUnsafePointer(to:)
can help make calls to low-level C functions more readable, especially when the function takes several pointer arguments. However, when calling functions from other Swift code, avoid using &
instead of using the unsafe APIs explicitly.
withUnsafePointer(to:)
のような明示的な関数の代わりに &
を使用すると、特に関数が複数のポインター引数を取る場合に、低レベルの C 関数の呼び出しをより読みやすくすることができます。 ただし、他の Swift コードから関数を呼び出す場合は、安全でない API を明示的に使用するのではなく、&
の使用を避けてください。
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
イニシャライザ式
An initializer expression provides access to a type’s initializer. It has the following form:
イニシャライザ式は、型のイニシャライザへのアクセスを提供します。 次のような形式になります。
<#expression#>.init(<#initializer arguments#>)
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.
関数呼び出し式でイニシャライザ式を使用して、型の新しいインスタンスを初期化します。 また、イニシャライザ式を使用してスーパークラスのイニシャライザに委任することもできます。
class SomeSubClass: SomeSuperClass {
override init() {
// subclass initialization goes here
super.init()
}
}
Like a function, an initializer can be used as a value. For example:
関数と同様に、イニシャライザを値として使用できます。 例えば:
// Type annotation is required because String has multiple initializers.
let initializer: (Int) -> String = String.init
let oneTwoThree = [1, 2, 3].map(initializer).reduce("", +)
print(oneTwoThree)
// Prints "123"
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.
型を名前で指定すると、イニシャライザ式を使用せずに型のイニシャライザにアクセスできます。 それ以外の場合はすべて、イニシャライザ式を使用する必要があります。
let s1 = SomeType.init(data: 3) // Valid
let s2 = SomeType(data: 1) // Also valid
let s3 = type(of: someValue).init(data: 7) // Valid
let s4 = type(of: someValue)(data: 5) // Error
Grammar of an initializer expression
initializer-expression → postfix-expression .
init
initializer-expression → postfix-expression .
init
(
argument-names )
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.
明示的なメンバー式を使用すると、名前付き型、タプル、またはモジュールのメンバーにアクセスできます。 これは、項目とそのメンバーの識別子の間のピリオド (.
) で構成されます。
<#expression#>.<#member name#>
The members of a named type are named as part of the type’s declaration or extension. For example:
名前付き型のメンバーは、型の宣言または拡張の一部として名前が付けられます。 例えば:
class SomeClass {
var someProperty = 42
}
let c = SomeClass()
let y = c.someProperty // Member access
The members of a tuple are implicitly named using integers in the order they appear, starting from zero. For example:
タプルのメンバーには、整数を使用して、出現順に 0 から始まる暗黙的な名前が付けられます。 例えば:
var t = (10, 20, 30)
t.0 = t.1
// Now t is (20, 20, 30)
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:
引数の名前だけが異なるメソッドまたはイニシャライザを区別するには、引数名をかっこで囲み、各引数名の後にコロン (:
) を付けます。 名前のない引数にはアンダースコア (_
) を記述します。 オーバーロードされたメソッドを区別するには、型アノテーションを使用します。 例えば:
class SomeClass {
func someMethod(x: Int, y: Int) {}
func someMethod(x: Int, z: Int) {}
func overloadedMethod(x: Int, y: Int) {}
func overloadedMethod(x: Int, y: Bool) {}
}
let instance = SomeClass()
let a = instance.someMethod // Ambiguous
let b = instance.someMethod(x:y:) // Unambiguous
let d = instance.overloadedMethod // Ambiguous
let d = instance.overloadedMethod(x:y:) // Still ambiguous
let d: (Int, Bool) -> Void = instance.overloadedMethod(x:y:) // Unambiguous
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:
行の先頭にピリオドが現れる場合、それは暗黙的なメンバー式ではなく、明示的なメンバー式の一部として理解されます。 たとえば、次のリストは、複数の行に分割された連鎖メソッド呼び出しを示しています。
let x = [10, 3, 20, 15, 4]
.sorted()
.filter { $0 > 5 }
.map { $0 * 100 }
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 で別のフィルタリング ルールを使用します。
let numbers = [10, 20, 33, 43, 50]
#if os(iOS)
.filter { $0 < 40 }
#else
.filter { $0 > 25 }
#endif
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
、およびその他のコンパイル ディレクティブの間に、条件付きコンパイル ブロックに暗黙的なメンバー式とそれに続く 0 個以上の後置式を含めて、後置式を形成できます。 別の条件付きコンパイル ブロック、またはこれらの式とブロックの組み合わせを含めることもできます。
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
コンパイル ディレクティブの分岐に少なくとも 1 つの式が含まれている必要があります。 他のブランチは空でもかまいません。
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 :
Postfix Self Expression
後置自己表現
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
が続く形で構成されます。 次のような形式があります。
<#expression#>.self
<#type#>.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.
2 番目の形式は、タイプの値として評価されます。 このフォームを使用して、型に値としてアクセスします。 たとえば、SomeClass.self
は SomeClass
型自体に評価されるため、型レベルの引数を受け入れる関数またはメソッドにそれを渡すことができます。
Grammar of a postfix self expression
postfix-self-expression → postfix-expression .
self
Subscript Expression
添字式
A subscript expression provides subscript access using the getter and setter of the corresponding subscript declaration. It has the following form:
添字式は、対応する添字宣言のゲッターとセッターを使用して添字へのアクセスを提供します。 次のような形式になります。
<#expression#>[<#index expressions#>]
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.
添え字宣言の詳細については、「プロトコルの添え字宣言」を参照してください。
Grammar of a subscript expression
subscript-expression → postfix-expression [
function-call-argument-list ]
Forced-Value Expression
強制値の式
A forced-value expression unwraps an optional value that you are certain isn’t nil
. It has the following form:
強制値式は、nil
ではないことが確実なオプションの値をアンラップします。 次のような形式になります。
<#expression#>!
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:
強制値式のラップされていない値は、値自体を変更するか、値のメンバーの 1 つに代入することによって変更できます。 例えば:
var x: Int? = 0
x! += 1
// x is now 1
var someDictionary = ["a": [1, 2, 3], "b": [10, 20]]
someDictionary["a"]![0] = 100
// someDictionary is now ["a": [100, 2, 3], "b": [10, 20]]
Grammar of a forced-value expression
forced-value-expression → postfix-expression !
Optional-Chaining Expression
オプションの連鎖式
An optional-chaining expression provides a simplified syntax for using optional values in postfix expressions. It has the following form:
オプションの連鎖式は、後置式でオプションの値を使用するための簡略化された構文を提供します。 次のような形式になります。
<#expression#>?
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()
にはオプションの型の値があります。
var c: SomeClass?
var result: Bool? = c?.property.performAction()
The following example shows the behavior of the example above without using optional chaining.
次の例は、オプションのチェーンを使用しない場合の上記の例の動作を示しています。
var result: Bool?
if let unwrappedC = c {
result = unwrappedC.property.performAction()
}
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:
オプション連鎖式のラップされていない値は、値自体を変更するか、値のメンバーの 1 つに代入することによって変更できます。 オプションの連鎖式の値が nil
の場合、代入演算子の右側の式は評価されません。 例えば:
func someFunctionWithSideEffects() -> Int {
return 42 // No actual side effects.
}
var someDictionary = ["a": [1, 2, 3], "b": [10, 20]]
someDictionary["not here"]?[0] = someFunctionWithSideEffects()
// someFunctionWithSideEffects isn't evaluated
// someDictionary is still ["a": [1, 2, 3], "b": [10, 20]]
someDictionary["a"]?[0] = someFunctionWithSideEffects()
// someFunctionWithSideEffects is evaluated and returns 42
// someDictionary is now ["a": [42, 2, 3], "b": [10, 20]]
Grammar of an optional-chaining expression
optional-chaining-expression → postfix-expression ?