XCode 9.2 日本語化計画

式

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

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

式の文法

expression → try-operator _opt prefix-expression binary-expressions _opt
expression-list → expression | expression , expression-list

接頭辞式

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

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

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

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

接頭辞の式の文法

prefix-expression → prefix-operator _opt postfix-expression
prefix-expression → in-out-expression
in-out-expression → & identifier

Try 演算子

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

try

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

try?

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

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

try!

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

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

sum = try someThrowingFunction() + anotherThrowingFunction() // 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

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

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

TRY 式の文法

try-operator → try | try ? | try !

二項式

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

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

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

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

二項式の文法

binary-expression → binary-operator prefix-expression
binary-expression → assignment-operator try-operator _opt prefix-expression
binary-expression → conditional-operator try-operator _opt prefix-expression
binary-expression → type-casting-operator
binary-expressions → binary-expression binary-expressions _opt

代入演算子

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

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

(a, _, (b, c)) = ("test", 9.45, (12, 3))

// a is "test", b is 12, c is 3, and 9.45 is ignored

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

代入演算子の文法

assignment-operator → =

三項条件演算子

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

? :

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

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

条件演算子の文法

conditional-operator → ? expression :

型キャスト演算子

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

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

as?

as!

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

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"

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

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

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

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

型キャスト演算子の文法

type-casting-operator → is type
type-casting-operator → as type
type-casting-operator → as ? type
type-casting-operator → as ! type

一次式

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

一次式の文法

primary-expression → identifier generic-argument-clause _opt
primary-expression → literal-expression
primary-expression → self-expression
primary-expression → superclass-expression
primary-expression → closure-expression
primary-expression → parenthesized-expression
primary-expression → tuple-expression
primary-expression → implicit-member-expression
primary-expression → wildcard-expression
primary-expression → key-path-expression
primary-expression → selector-expression
primary-expression → key-path-string-expression

リテラル式

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

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

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

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

func logFunctionName(string: String = #function) {

print(string)

}

func myFunction() {

logFunctionName() // Prints "myFunction()".

}

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

[, , ]

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

var emptyArray: [Double] = []

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

[:,:,]

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

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

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

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

リテラル式の文法

literal-expression → literal
literal-expression → array-literal | dictionary-literal | playground-literal
literal-expression → #file | #line | #column | #function

array-literal → [ array-literal-items _opt ]
array-literal-items → array-literal-item , _opt | array-literal-item , array-literal-items
array-literal-item → expression

dictionary-literal → [ dictionary-literal-items ] | [:]
dictionary-literal-items → dictionary-literal-item , _opt | dictionary-literal-item , dictionary-literal-items
dictionary-literal-item → expression : expression

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

Self 式

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

self

self.

self[ ]

self( )

self. init( )

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

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

class SomeClass {

var greeting: String

init(greeting: String) {

self.greeting = greeting

}

値型の変異メソッドでは、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)

}

Self 式の文法

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

スーパークラス式

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

super.

super[]

super.init()

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

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

スーパークラス式の文法

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

クロージャ式

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

{ ) -> in

}

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

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

クロージャはそのパラメータの型、その戻り値の型、または両方を省略できます。パラメータ名と両方の型を省略した場合、文の前の in キーワードは省略します。省略した型が推測できない場合は、コンパイル時エラーが発生します。

クロージャは、そのパラメータの名前を省略できます。そのパラメータは、その後、暗黙的に、 $ にその位置が続く名前が付けられます。$0 , $1 , $2 というように。

一つの式だけで構成されるクロージャは、その式の値を返すと理解されます。周囲の式に型推論を実行するときにこの式の内容も考慮されます。

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

myFunction { (x: Int, y: Int) -> Int in

return x + y

}

myFunction { x, y in

return x + y

}

myFunction { return $0 + $1 }

myFunction { $0 + $1 }

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

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

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

キャプチャ・リスト

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

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

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

var a = 0

var b = 0

let closure = { [a] in

print(a, b)

}

a = 10

b = 10

closure()

// Prints "0 10"

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

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

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"

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

myFunction { print(self.title) } // strong capture

myFunction { [weak self] in print(self!.title) } // weak capture

myFunction { [unowned self] in print(self.title) } // unowned capture

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

// Weak capture of "self.parent" as "parent"

myFunction { [weak parent = self.parent] in print(parent!.title) }

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

クロージャ式の文法

closure-expression → { closure-signature _opt statements _opt }

closure-signature → capture-list _opt closure-parameter-clause throws _opt function-result _opt 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 _opt
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 _opt expression
capture-specifier → weak | unowned | unowned(safe) | unowned(unsafe)

暗黙のメンバ式

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

例えば：

var x = MyEnumeration.someValue

x = .anotherValue

暗黙のメンバ式の文法

implicit-member-expression → . identifier

括弧で囲まれた式

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

括弧で囲まれた式の文法

parenthesized-expression → ( expression )

タプル式

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

( : , : , )

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

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

タプル式の文法

tuple-expression → ( ) | ( tuple-element , tuple-element-list )
tuple-element-list → tuple-element | tuple-element , tuple-element-list
tuple-element → expression | identifier : expression

ワイルドカード式

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

(x, _) = ( 10, 20 )

// x is 10, and 20 is ignored

ワイルドカードの文法

wildcard-expression → _

キーパス式

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

\ .

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

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

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

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

struct SomeStructure {

var someValue: Int

}

let s = SomeStructure(someValue: 12)

let pathToProperty = \SomeStructure.someValue

let value = s[keyPath: pathToProperty]

// value is 12

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

class SomeClass: NSObject {

@objc var someProperty: Int

init(someProperty: Int) {

self.someProperty = someProperty

}

let c = SomeClass(someProperty: 10)

c.observe(\.someProperty) { object, change in

// ...

}

パス (path) には、プロパティー値のプロパティーを参照する複数のプロパティー名をピリオドで区切って指定することができます。以下のコードでは、キーパス式 \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

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

let greetings = ["hello", "hola", "bonjour", "안녕"]

let myGreeting = greetings[keyPath: \[String].[1]]

// myGreeting is 'hola'

サブスクリプトで使用される値は、名前付き値またはリテラルにすることができます。値は、値セマンティクスを使用してキーパスにキャプチャされます。以下のコードでは、key-path 式と closure の両方で変数 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 "안녕"

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

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)"

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

let interestingNumbers = ["prime": [2, 3, 5, 7, 11, 13, 15],

"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, 15])"

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"

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

キーパス式の文法

key-path-expression → \ type _opt . key-path-components
key-path-components → key-path-component | key-path-component. key-path-components
key-path-component → identifier key-path-postfixes _opt | key-path-postfixes

key-path-postfixes → key-path-postfix key-path-postfixes _opt
key-path-postfix → ? | ! | [ function-call-argument-list ]

セレクタ式

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

#selector()

#selector(getter : )

#selector(setter : )

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

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)

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

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

extension SomeClass {

@objc(doSomethingWithString:)

func doSomething(_ x: String) { }

}

let anotherSelector = #selector(SomeClass.doSomething(_:) as (SomeClass) -> (String) -> Void)

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

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

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

セレクタ式の文法

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

キーパス文字列式

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

#keyPath(

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

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"

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

extension SomeClass {

func getSomeKeyPath() -> String {

return #keyPath(someProperty)

}

print(keyPath == c.getSomeKeyPath())

// Prints "true"

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

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

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

キーパス文字列式の文法

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

接尾辞の式

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

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

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

接尾辞の式の文法

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

関数呼び出し式

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

(, )

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

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

(: , : )

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

// someFunction takes an integer and a closure as its arguments

someFunction(x: x, f: {$0 == 13})

someFunction(x: x) {$0 == 13}

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

// someFunction takes a closure as its only argument

myData.someMethod() {$0 == 13}

myData.someMethod {$0 == 13}

関数呼び出し式の文法

function-call-expression → postfix-expression function-call-argument-clause
function-call-expression → postfix-expression function-call-argument-clause _opt trailing-closure

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-closure → closure-expression

イニシャライザ式

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

.init()

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

class SomeSubClass: SomeSuperClass {

override init() {

// subclass initialization goes here

super.init()

}

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

// 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"

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

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

イニシャライザ式の文法

initializer-expression → postfix-expression. init
initializer-expression → postfix-expression. init ( argument-names )

明示的なメンバ式

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

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

class SomeClass {

var someProperty = 42

}

let c = SomeClass()

let y = c.someProperty // Member access

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

var t = (10, 20, 30)

t.0 = t.1

// Now t is (20, 20, 30)

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

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

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

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

let x = [10, 3, 20, 15, 4]

.sorted()

.filter { $0 > 5 }

.map { $0 * 100 }

明示的なメンバ式の文法

explicit-member-expression → postfix-expression . decimal-digits
explicit-member-expression → postfix-expression . identifier generic-argument-clause _opt
explicit-member-expression → postfix-expression . identifier ( argument-names )

argument-names → argument-name argument-names _opt
argument-name → identifier :

接尾辞の self 式

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

.self

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

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

self 式の文法

postfix-self-expression → postfix-expression . self

サブスクリプト式

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

[ ]

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

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

サブスクリプト式の文法

subscript-expression → postfix-expression [ expression-list ]

強制値の式

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

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

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

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 ["b": [10, 20], "a": [100, 2, 3]]

強制値の式の文法

forced-value-expression → postfix-expression !

Optional の連鎖式

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

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

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

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

var c: SomeClass?

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

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

var result: Bool? = nil

if let unwrappedC = c {

result = unwrappedC.property.performAction()

}

optional の連鎖式の開封された値は、値自体を変異させることによってか、あるいは値のメンバの一つに代入することによってかのいずれかによって、変更できます。optional の連鎖式の値が 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 is not evaluated

// someDictionary is still ["b": [10, 20], "a": [1, 2, 3]]

someDictionary["a"]?[0] = someFunctionWithSideEffects()

// someFunctionWithSideEffects is evaluated and returns 42

// someDictionary is now ["b": [10, 20], "a": [42, 2, 3]]

optional の連鎖式

optional-chaining-expression → postfix-expression ?

前：型次：文

Swift 4.0.3 日本語化計画 : Swift Language-Tour

式

接頭辞式

Try 演算子

二項式

代入演算子

三項条件演算子

型キャスト演算子

一次式

リテラル式

Self 式

スーパークラス式

クロージャ式

キャプチャ・リスト

暗黙のメンバ式

括弧で囲まれた式

タプル式

ワイルドカード式

キーパス式

セレクタ式

キーパス文字列式

接尾辞の式

関数呼び出し式

イニシャライザ式

明示的なメンバ式

接尾辞の self 式

サブスクリプト式

強制値の式

Optional の連鎖式