Swift 言語のガイド(Part II)


Swift の基本


Swift は iOS、macOS、 watchOS、及び tvOS アプリ開発のための新しいプログラミング言語です。それにもかかわらず、Swift の多くの部分は、C や Objective-C での開発の経験から、親しみやすいでしょう。


Swift は整数用の Int 型、浮動小数点値用の Double 型や Float 型、ブール値の Bool 型、およびテキストデータ用の String 型などを含む、すべての基本的な C 言語と Objective-C の型の独自のバージョンを提供します。Swift はまた、コレクション型 で説明したように、3つの主要なコレクション型、Array 型と Set 型、Dictionary 型の、強力なバージョンを提供します。


C と同様に、Swift は名前によって識別し、値を保存し参照するのに変数を使用します。Swift も値を変更できない変数を多用します。これらは定数として知られており、C の定数よりもはるかに強力です。定数は、変更する必要がない値をコードで処理するときの意図をより安全かつ明確にするために Swift 全体で使用されています。


おなじみの型に加えて、Swift は、タプル(tuples)のような、Objective-C では見られない高度な型を導入します。タプルにより、値のグループを作成し周りに渡すことができます。タプルを使用して、単一の化合値として関数から複数の値を返すようにできます。


Swift はまた、値が存在しない物を処理する optional の型を導入します。Optionals は、"ここに値 あり、それが X に等しい" かまたは"値が全く ありません" と告げます。Optionals を使用するのは Objective-C でポインタに nil を使用することに似ていますが、それらは任意の型に働きますが、クラスには働きません。Optionals は、より安全で Objective-C での nil ポインタよりも表現力が高いだけでなく、Swift の最も強力な機能の多くの中心になります。


Swift は"型安全" な言語であり、あなたのコードが操作できる値の型について明確にするのに役立ちます。あなたのコードの一部が String を必要とする場合は、型安全性は誤って Int をそれに渡すのを防ぐことができます。同様に、型安全性は、誤って optional でない String を必要とするコードの一部に optional の String を渡すのを防ぎます。型安全性は、あなたがエラーを catch して、できるだけ早期に開発プロセスのエラーを修正するのに役立ちます。


定数と変数


定数と変数は、(maximumNumberOfLoginAttempts または welcomeMessage のように) 特定の型の値(10 の数や "Hello" の文字列のように) に名前を関連付けます。それが一度設定されると、定数 の値は、変更できず、一方、変数 は、将来的に異なる値に設定できます。


定数と変数の宣言


定数と変数はそれらが使用される前に、宣言されなければなりません。let キーワードで定数を、var キーワードで変数を宣言します。定数および変数の、ユーザがログインしようとした回数を追跡するために使用する例をここに示します。


  1. let  maximumNumberOfLoginAttempts = 10
  2. var  currentLoginAttempt = 0


このコードは次のように読むことができます。


"maximumNumberOfLoginAttempts という新しい定数を宣言し、それに 10 の値を与える。そして、currentLoginAttempt という新しい変数を宣言し、それに初期値 0 を与える"


この例では、最大値は決して変化しないので、許可されたログイン試行の最大数は、定数として宣言されています。ログイン試行を失敗するたびに、この値を一つ増分する必要があるため、現在のログイン試行カウンタは、変数として宣言されています。


一行に複数の定数や複数の変数を、カンマで区切って宣言することができます。


var x = 0.0, y = 0.0, z = 0.0


注意: コード内の格納された値は変更するつもりがない場合は、常に let キーワードで定数として宣言します。変更できるようにする必要がある場合のみ、値を保存するために変数を使用してください。


型注釈


定数または変数を宣言するときには、定数または変数が保存できる値の種類について明確にするには、型注釈(Type Annotation) を提供できます。型注釈を書くには、定数や変数の名前の後にコロンを書き、スペースを続け、使用する型の名前を続けます。


以下の例では、変数は String 値を保存できることを示すために、welcomeMessage という変数の型注釈を提供します。


var welcomeMessage: String


宣言の中のコロンは "...of type...、"と言う意味であり、上記のコードは以下のように読むことができます:


"String 型である welcomeMessage という変数を宣言します。"


"String 型である" のフレーズは、"どんな String 値でも格納することができる。" を意味します。これを、格納できる "物の型" (あるいは "ものの種類")だと考えられます。


welcomeMessage 変数は、エラーなしでどんな文字列値にでも設定できます。


welcomeMessage = "Hello"


単一の行に、カンマで区切って、同じ型の複数の関連した変数を定義でき、最後の変数名の後に、単一の型注釈を加えます。


var red, green, blue: Double


注意: 実際に型注釈を書く必要があることは稀でしょう。それが定義された時に、定数または変数の初期値を指定すると、Swift は、 安全型と型推論 で説明したように、その定数または変数に使用される型をほとんど常に推論できます。上の welcomeMessage の例では、初期値が提供されておらず、welcomeMessage 変数の型は、初期値から推測されるのではなく、型注釈を使用して指定されています。


定数と変数の命名


定数と変数名は、Unicode 文字を含むほとんどの文字を含むことができます。


  1. let π = 3.14159
  2. let 你好 = "你好世界"
  3. let 🐶🐮 = "dogcow"


定数と変数名は空白文字、数学記号、矢印、個人的使用(または無効)の Unicode コードポイント、またはラインおよびボックス描画文字を含むことはできません。また、数字で始めることは出来ませんが名前の別の場所に含めることができます。


特定の型の定数または変数を一度宣言したら、同じ名前で再度宣言したり、別の型の値を保存するように、それを変更することはできません。また、定数を変数に、変数を定数に変更することはできません。


注意: Swift の予約語と同じ名前を付ける必要がある場合は、キーワードをバックチック(`)で囲み、それを名前として使います。しかし、絶対に選択肢がない場合を除き、キーワードを名前として使用しないでください。


既存の変数の値を互換性のある型の別の値に変更できます。以下の例では、friendlyWelcome の値を "Hello!" から "BonJour!" へと変更しています:


  1. var friendlyWelcome = "Hello!"
  2. friendlyWelcome = Bonjour!"
  3. // friendlyWelcome is now "Bonjour!"


変数とは違って、定数の値は一度設定されると、変更できません。これを実行しようとすると、コードがコンパイルされるときにエラーとして報告されます。


  1. let languageName = "Swift"
  2. languageName = "Swift++"
  3. // this is a compile-time error - languageName cannot be changed


定数と変数の印刷


print(_:separator:terminator:) 関数で、定数または変数の現在値を印刷できます。


  1. print(friendlyWelcome)
  2. // prints "Bonjour!"


print(_:separator:terminator:) 関数は、適切な出力先に、一つ以上の値を、印刷するグローバル関数です。Xcode では、例えば、print(_:separator:terminator:) 関数は Xcode の "コンソール" ペインにその出力を印刷します。separator 及び terminator パラメーターはデフォルト値を持っているので、この関数を呼び出すとき、それらを省略できます。デフォルトでは、関数は、改行を追加して、行の印刷を終了します。それの後で改行なしの値を印刷するには、terminator に空の文字列を渡しますー例えば、print(someValue, terminator: "")。デフォルト値を持つパラメータについては、デフォルトのパラメータ値 を参照してください。


Swift は、長い文字列内のプレースホルダとして定数または変数の名前を含むように、文字列の補間 を使用し、その定数または変数の現在値に置き換えることを Swift に促します。括弧内の名前を覆い、開き括弧の前にバックスラッシュしてエスケープします:


  1. print("The current value of friendlyWelcome is \(friendlyWelcome)")
  2. // Prints "The current value of friendlyWelcome is Bonjour!"


注意: 文字列の補間で使用できるすべてのオプションは 文字列補間 で説明されています。


コメント


自分自身へのメモや忘備録として、コード内の実行できないテキストを含むようにコメントを使用します。コードがコンパイルされる時にコメントは Swift コンパイラによって無視されます。


Swift内 のコメントは C のコメントに非常によく似ています。単一行のコメントは2つのスラッシュ(//)で始まります。


// this is a comment


複数行のコメントは、スラッシュで始まりアスタリスク(/*)が続き、スラッシュが続くアスタリスク(*/)で終わります:


  1. /* this is also a comment,
  2. but written over multiple lines */


C 言語での複数行のコメントとは異なり、Swift での複数行のコメントは、他の複数行コメント内に入れ子にすることができます。複数行のコメントブロックを開始してから最初のブロック内に第二の複数行コメントを開始することで、入れ子にされたコメントを書く事ができます。第二のブロックは、閉じられ、最初のブロックが続きます。


  1. /* this is the start of the first multiline comment
  2. /* this is the second, nested multiline comment */
  3. this is the end of the first multiline comment */


入れ子にされた複数行のコメントは、コードがすでに複数行のコメントを含んでいても、迅速かつ容易にコードの大きなブロックをコメントアウトすることを可能にします。



セミコロン


他の多くの言語と異なり、コード内の各文の後には Swift はセミコロン(;)を記述する必要はないですが、希望があればそれを行うことができます。しかし、単一の行に複数の独立した文を書きたい場合にはセミコロンが必要です。


  1. let cat = "🐱"; print(cat)
  2. // Prints "🐱"


整数


整数(integer)は、42-23 などのように、小数部分がない全ての数字です。整数は符号付き(signed)(正、ゼロ、または負) かまたは符号なし(unsigned)(正またはゼロ)のどちらかです。


Swift は 8、16、32、および 64 ビット形式で符号付きと符号なし整数を提供します。これらの整数は、8 ビット符号なし整数型は UInt8 であるというように、C と同様の命名規則に従い、32 ビット符号付き整数は、Int32 型のものになります。Swift のすべての型と同様に、これらの整数型は頭文字が大文字の名前を持っています。



整数の境界


その minmax プロパティで、各整数型の最小値と最大値にアクセスできます。


  1. let minValue = UInt8.min // minValue is equal to 0, and is of type UInt8
  2. let maxValue = UInt8.max // maxValue is equal to 255, and is of type UInt8


これらのプロパティの値は(上の例の UInt8 のように) 適切なサイズの数の型のものであり、したがって、同じ型の他の値と一緒に式で使用できます。


Int


ほとんどの場合、コード内で使用するのに、整数の特定のサイズを選択する必要はありません。Swift は、現在のプラットフォームの固有のワードサイズと同じサイズの追加の整数型、Int 型を提供します:


整数の特定のサイズで作業する必要がない限り、常にコード内の整数値には Int を使用して下さい。これは、コードの一貫性と相互運用性を支援します。32 ビットプラットフォームでも、Int-2,147,483,6482,147,483,647 の間のどんな値でも格納し、多くの整数の範囲について十分な大きさです。



UInt


Swift は、現在のプラットフォームの固有ワードサイズと同じサイズの符号なし整数型、UInt を提供します。


注意: UInt は、プラットフォームの固有ワードサイズと同じサイズの符号なし整数型が明確に必要な場合にのみ使用して下さい。そうでない場合、格納される値が負でないことが知られている場合でも、Int が望ましいです。整数値を Int に一貫して使用するのはコードの相互運用性を助け、異なる数の型の間での変換を避け、安全な型と型推論 で説明したように、整数型推論と一致します。


浮動小数点数


浮動小数点数 (Floating-point numbers) は小数部を持つ数字で、3.141590.1、および -273.15 などです。


浮動小数点型は、整数型よりはるかに広い値の範囲を表すことができ、Int 型に格納できるよりもはるかに大きく、または小さい数値を格納できます。Swift は、2つの符号付き浮動小数点数型を提供します。


注意: Double は、少なくとも 15 桁の精度を持っており、一方 Float の精度は 6 桁と少ないです。使用するべき適切な浮動小数点型は、コード内で作業する必要がある値の性質と範囲次第です。どちらの型でもよい状況では、Double が好ましいです。


安全な型と型推論


Swift は、安全型 (type safe) の言語です。安全型の言語は、コードが操作できる値の型を明確にすることを奨励します。コードの一部が String を想定している場合、間違ってそれに Int 型を渡すことはできません。


Swift は、安全型であるため、コードやフラグなどをコンパイルする時、型のチェック (type checks) を行い、あらゆる型の不一致をエラーとしてチェックします。これにより、エラーをキャッチし、できるだけ早期の開発プロセスでエラーを修正できます。


型チェックを使用すると、値の異なる型で作業しているときにエラーを回避できます。しかし、これは、宣言したすべての定数と変数の型を指定する必要があることを意味しません。必要とする値の型を指定しない場合は、Swift は適切な型に型推論 (type inference) を使用します。型推論は、単にあなたが提供する値を調べることによって、コードをコンパイルするときに自動的に特定の式の型を推測できるようコンパイラにさせます。


型推論があるので、Swift は、C や Objective-C のような言語よりはるかに少ない型宣言しか必要としません。定数と変数は、まだ明示的に型指定されていますが、それらの型を指定する作業の多くはもうすでにに行われています。


初期値で定数または変数を宣言するときに型推論は、特に便利です。これは多くの場合、それを宣言する点で定数または変数に リテラル値(またはリテラル:literal) を代入することによって行われます。(リテラル値は、下記の例の 423.14159 などのようにソースコード内に直接表示される値です。)


例えば、それがどの型であるか言わずに新しい定数に 42 のリテラル値を代入した場合、整数のように見える数でそれをあなたが初期化したので、Int 型の定数にしたいことを Swift は推論します。


  1. let meaningOfLife = 42
  2. // meaningOfLife is inferred to be of type Int


同じように、浮動小数点リテラルの型を指定しない場合は、Swift は Double を作成したがっていることを推論します:


  1. let pi = 3.14159
  2. // pi is inferred to be of type Double


浮動小数点数の型を推論するとき、Swift は、常に(Float というよりも) Double を選択します。


式の中で、整数と浮動小数点リテラルを結合する場合は、Double の型が文脈から推測されます。


  1. let  anotherPi = 3 + 0.14159
  2. // anotherPi is also inferred to be of type Double


3 のリテラル値は、それ自体は、明示的な型を持っておらず、Double の適切な出力型は、追加部分の浮動小数点のリテラルの存在から推測されます。


数値リテラル


整数リテラルは、以下のように書くことができます。


以下の整数リテラルはすべて、17 の十進数値を表します:


  1. let  decimalInteger = 17
  2. let  binaryInteger = 0b10001 // 17 in binary notation
  3. let  octalInteger = 0o21         // 17 in octal notation
  4. let  hexadecimalInteger = 0x11 // 17 in hexadecimal notation


浮動小数点リテラルは(接頭辞なしの)十進数、または(接頭辞 0x 付きの)十六進数です。それらはいつも、小数点の両側に数(または十六進数)を持っていなければなりません。十進小数点数はまた、オプションで累乗(exponent)があり、大文字または小文字の e が示し、十六進浮動小数点数では大文字または小文字の p が示します。


十進数の場合、累乗は exp の指数で示し、基本数は 10exp を乗じて示します。


十六進数の場合、累乗は exp の指数で示し、基本数は 2exp を乗じて示します。


以下の浮動小数点リテラルはすべて、12.1875 の十進小数値を示します。


  1. let decimalDouble = 12.1875
  2. let exponentDouble = 1.21875e1
  3. let hexadecimalDouble = 0xC.3p0


数値リテラルは読みやすいように余分の書式設定を含めることができます。整数および浮動小数点数の両方とも、余分なゼロでつめ込まれ、読みやすさを支援するため、アンダースコアを含めることができます。書式設定のどちらの型も、リテラルの基になる値に影響を与えません。


  1. let  paddedDouble =  000123.456
  2. let  oneMillion = 1_000_000
  3. let  justOverOneMillion = 1_000_000.000_000_1


数値型変換


コード内のすべての汎用整数の定数と変数の型に Int を、これらが負でないことが知られている場合でも使用して下さい。日常の状況で、デフォルトの整数型を使用する事は、整数の定数や変数は、コード内ですぐに相互運用可能になり、整数リテラル値について推論された型と一致することを意味します。


外部ソースからの、明示的にされたサイズのデータのため、それらが具体的に当面のタスクのために必要とされる時にだけ他の整数型を使用するか、または性能、メモリ使用量、またはその他の必要な最適化のため使用して下さい。このような状況で明示的にされたサイズの型を使用すると、偶発的な値のオーバフローをキャッチするのに役立ち、また使用されているデータの性質について暗黙的に説明します。



整数変換


整数の定数または変数に格納できる数値の範囲は、各数値の型ごとに異なります。Int8 の定数や変数は -128127 の間の数を格納できるのに対し、UInt8 の定数や変数は 0255 の間の数を格納できます。サイズの整数型の定数や変数に収まらない数は、コードがコンパイルされる時にエラーとして報告されます。


  1. let cannotBeNegative: UInt8 = -1
  2. // UInt8 cannot store negative numbers, and so this will report an error
  3. let tooBig: Int8 = Int8.max + 1
  4. // Int8 cannot store a number larger than its maximum value,
  5. // and so this will also report an error



各数値型は、値の異なる範囲を格納できるので、ケースバイケースで、数値型の変換を選択しなければなりません。この選択のアプローチは、隠れた変換エラーを防止し、コード内の型変換の意図を明示的にするのに役立ちます。


一つの特定の数値型を別のものに変換するには、既存の値を持つ所望の型の新しい数字で初期化して下さい。以下の例では、定数 twoThousandUInt16 型のものであり、一方定数 oneUInt8 型です。それらは同じ型ではないので、直接加算することはできません。代わりに、以下の例では、UInt16(one) を呼び出し、新しい UInt16one の値で初期化したものを作成し、元の値の代わりにこの値を使用します。


  1. let twoThousand: UInt16 = 2_000
  2. let one: UInt8 = 1
  3. let twoThousandAndOne = twoThousand + UInt16(one)


加算の両側の型が UInt16 型になったため、加算が許可されます。2つの UInt16 値の和であるため、出力された定数(twoThousandAndOne) は、UInt16 型であることが推測されます。


SomeType(ofInitialValue) は Swift の型のイニシャライザを呼び出し、初期値を渡すためのデフォルトの方法です。舞台裏では、UInt16 には UInt8 値を受け入れるイニシャライザがあるので、このイニシャライザは、既存の UInt8 から新しい UInt16 を作るために使用されます。ただし、それは UInt16 がイニシャライザを提供している型である必要があり、ここでは どの型でも(Any type) 渡すことはできません。既存の型を拡張して(自分の定義した型を含む) 新しい型を受け入れるイニシャライザを提供することについては、拡張機能 で説明します。


整数と浮動小数点間の変換


整数と浮動小数点数の数値型の間の変換は、明示的に行わなければなりません。


  1. let three = 3
  2. let pointOneFourOneFiveNine = 0.14159
  3. let pi = Double(three) + pointOneFourOneFiveNine
  4. // pi equals 3.14159, and is inferred to be of type Double


ここで、定数の値 three は、加算の両側が同じ型であるように、Double 型の新しい値を作成するために使用されます。この変換がなければ、加算は許可されません。


浮動小数点の整数への変換も明示的に行わなければなりません。整数型は、Double または Float 値で初期化することができます。


  1. let integerPi = Int(pi)
  2. // integerPi equals 3, and is inferred to be of type Int


このように、新しい整数値を初期化するために使用すると、浮動小数点値は、常に切り捨てられます。これは 4.754 になることを意味し、-3.9-3 になる事を意味します。


注意: 数値定数と変数を結合する規則は、数値リテラルの規則とは異なります。リテラル値 3 は、それ自体の明示的な型を持っていないため、リテラル値 0.14159 に直接加算することができます。それらの型は、それらがコンパイラによって評価される時にだけ推論されます。

型エイリアス


型エイリアス は、既存の型の別名を定義します。typealias キーワードで、型エイリアスを定義して下さい。


外部ソースから特定のサイズのデータ​​を扱う場合などのように、文脈的により適切な名前で、既存の型を参照したい場合に型エイリアスは便利です。


typealias AudioSample = UInt16


型エイリアスを一度定義すると、元の名前を使用する所どこでもエイリアスを使用できます。


  1. var maxAmplitudeFound = AudioSample.min
  2. // maxAmplitudeFound is now 0


ここで、AudioSampleUInt16 型のエイリアスとして定義されています。それはエイリアスのため、AudioSample.min への呼び出しは、実際には UInt16.min を呼び出し、maxAmplitudeFound 変数に初期値 0 を提供します。


ブール型


Swift には Bool と呼ばれる基本的なブール 型があります。ブール値はそれらが true または false としかならないため、論理型 と呼ばれます。Swift は、truefalse の2つのブール定数値を提供します。


  1. let orangesAreOrange = true
  2. let turnipsAreDelicious = false


orangesAreOrangeturnipsAreDelicious の型は、それらがブールリテラル値で初期化されたという事実から Bool 値として推測されています。上記の IntDouble と同様に、それらを作成するやいなや true または false にそれらを設定した場合、Bool として定数または変数を宣言する必要はありません。型推論は、型が既に知られている他の値で、定数または変数を初期化するとき Swift のコードは、より簡潔で読みやすくするのに役立ちます。


if 文などのような条件文を使用するときにブール値は、特に有用です。


  1. if turnipsAreDelicious {
  2.        print("Mmm, tasty turnips!")
  3. } else {
  4.        print("Eww, turnips are horrible.")
  5. }
  6. // prints "Eww, turnips are horrible."


if 文などのような条件文は フロー制御 で詳しく説明されています。


Swift の型の安全性は、Bool の代わりに、非ブール値を用いることを防ぎます。以下の例は、コンパイル時にエラーを報告します。


  1. let i = 1
  2. if i {
  3.        // this example will not compile, and will report an error
  4. }


しかし、以下に示した別の例は有効です。


  1. let i = 1
  2. if i == 1 {
  3.        // this example will compile successfully
  4. }


i == 1 を比較した結果は、Bool 型のものであり、従って、この第二の例は、型チェックに合格します。i == 1 のような比較は、基本演算子 で説明されています。


Swift での型の安全性の他の例と同様に、このアプローチは、偶発的なエラーを回避し、コードの特定のセクションの意図が常に明確であることを保証します。


タプル


tuples(タプル) は、複数の値を単一の複合値のグループにまとめます。タプル内の値は、任意の型とすることができ、互いに同じ型のものである必要はありません。


以下の例では、(404、"Not Found") は、HTTP ステータスコード を記述するタプルです。HTTP ステータスコードは、Web ページを要求するたびに、Web サーバから返される特別な値です。存在していない web ページを要求すると 404 Not Found のステータスコードが返されます。


  1. let http404Error = (404, "Not Found")
  2. // http404Error is of type (Int, String), and equals (404, "Not Found")


(404、"Not Found") を一緒にタプルのグループにして、HTTP ステータスコードに2つの別個の値を与える IntString にします:数字と人間が読める説明。これは、"タプル型 (Int,String)" として記述できます。


型の任意の並べ替えからタプルを作成することができ、好きなだけ多くの異なる型を含めることができます。(INT、INT、INT) 型のタプル、または(String、Bool)、または実際にあなたが必要とする他の組み合わせを作ることからあなたを止めるものは何もありません。


別々の定数や変数にタプルの内容を 分解 し、通常どおりにアクセスできます。


  1. let (statusCode, statusMessage) = http404Error
  2. print("The status code is \(statusCode)")
  3. // prints "The status code is 404"
  4. print("The status message is \(statusMessage)")
  5. // prints "The status message is Not Found"


タプルの値の一部だけが必要な場合は、タプルを分解する時に、アンダースコア(_) でタプルの部分を無視します。


  1. let (justTheStatusCode, _) = http404Error
  2. print("The status code is \(justTheStatusCode)")
  3. // prints "The status code is 404"


代わりに、ゼロから始まるインデックス番号を使用してタプルの個別の要素値にアクセスできます。


  1. print("The status code is \(http404Error.0)")
  2. // prints "The status code is 404"
  3. print("The status message is \(http404Error.1)")
  4. // prints "The status message is Not Found"


タプルを定義する時、タプルの個別の要素に名前を付けることができます。


let http200Status = (statusCode: 200, description: "OK")


タプルの要素に名前を付けた場合には、それらの要素の値にアクセスするのに要素の名前を使用できます。


  1. print("The status code is \(http200Status.statusCode)")
  2. // prints "The status code is 200"
  3. print("The status message is \(http200Status.description)")
  4. // prints "The status message is OK"


タプルは、関数の戻り値として特に有用です。Web ページを検索しようとする関数は、ページ検索の成功または失敗を記述するために (Int,String) のタプル型を返すことがあります。二つの異なる値を持つタプルを戻すことにより、異なる型のそれぞれは、関数が単一の型の単一の値を返すだけよりその結果に関する有用な情報を提供します。詳細については、複数の戻り値を持つ関数 を参照してください。


注意: タプルは、関連する値の一時的なグループのために有用です。それらは、複雑なデータ構造体の作成には適していません。データ構造体が一時的な範囲を超えて持続する可能性がある場合、タプルよりも、クラスや構造体として設計して下さい。詳細については、クラスと構造体 を参照してください。


Optionals


値が存在しなくてもよい状況では optionals を使用して下さい。Optional は、2つの可能性を表現します。値が あり、その値にアクセスするため optional を開封するか、値が全く ない かです。


注意: optionals の概念は、C や Objective-C には存在しません。Objective-C で最も近いものは、他の時はオブジェクトを返すメソッドから nil を返す機能で、nil は "有効なオブジェクトが存在しない" 事を意味します。しかし、これはオブジェクトでのみ動作し、構造体、基本的な C の型、または列挙値では動作しません。これらの型のために、Objective-C のメソッドは、値がないことを示すために、(例えば NSNotFound など) 特殊な値を通常返します。このアプローチは、メソッドの呼び出し元がそれをチェックするのを忘れず、テストするために特別な値があると知っていることを前提としています。Swift の optionals は、特別な定数を必要とせずに、まったくどの型の値も存在しない ことを示せます。


ここに、optionals が値の存在しない場合に対処するために使用できる方法の例を挙げます。Swift の Int 型には String 値を Int 値に変換しようとするイニシャライザーがあります。しかし、必ずしもすべての文字列が整数に変換できるわけではありません。文字列 "123" は、数値 123 に変換することができますが、文字列 "hello, world" には変換すべき明白な数値がありません。


以下の例では、StringInt 型に変換しようとするイニシャライザーを使用します。


  1. let possibleNumber = "123"
  2. let convertedNumber = Int(possibleNumber)
  3. // convertedNumber is inferred to be of type "Int?", or "optional Int"


イニシャライザーは失敗する可能性があるので、それは Intではなく optionalInt を返します。optional の IntInt ではなく Int? と書かれます。疑問符は、それが含む値は optional である事を示し、何らかの Int 値を含む場合があり、または まったく値を含んでいない かもしれないことを意味します。(これは、Bool 値または String 値のような、他のものを含めることはできません。それは、Int か、何もないかです。)



nil


特殊な値 nil を代入することによって、値のない状態への optional の変数を設定します。


  1. var serverResponseCode: Int? = 404
  2. // serverResponseCode contains an actual Int value of 404
  3. serverResponseCode = nil
  4. // serverResponseCode now contains no value


注意: nil は optional でない定数や変数では使用できません。コード内の定数または変数を、ある条件下で値が存在しない時に作業する必要がある場合は、必ず適切な型の optional の値としてそれを宣言して下さい。


デフォルト値を設けることなく、optional の変数を定義する場合は、変数は自動的に nil に設定されます:


  1. var surveyAnswer: String?
  2. // surveyAnswer is automatically set to nil


注意: Swift の nil は Objective-C の nil と同じではありません。Objective-C では、nil は、存在しないオブジェクトへのポインタです。Swift では、nil はポインタではなく、特定の型の値が存在しないことです。任意の 型の Optional が nil に設定されるのであって、オブジェクトの型では決してありません。


if 文と強制開封


if 文は、optional が nil に比較して、値を含むかどうかを調べるために使用できます。"等価" 演算子(==)または "非等価"演算子(!=)でこの比較を行って下さい。


Optional が値を持つ場合、それは nil と"等しくない(非等価)" と考えらます。


  1. if convertedNumber != nil {
  2.        print("convertedNumber contains some integer value.")
  3. }
  4. // Prints "convertedNumber contains some integer value."


optional が値が含んで いる ことを確認したら、optional の名前の末尾に感嘆符(!)を追加して、その基礎となる値にアクセスできます。感嘆符は効果的に、"この optional は間違いなく値を持っています。どうぞ使って下さい" と告げます。これは、optional の値の 強制開封 として知られています:


  1. if convertedNumber != nil {
  2.        print("convertedNumber has an integer value of \(convertedNumber!).")
  3. }
  4. // prints "convertedNumber has an integer value of 123."


if 文の詳細については、フロー制御 を参照してください。



注意: 存在しない optional の値にアクセスするのに ! を使用しようとすると、実行時エラーを引き起こします。! を使用してその値の強制開封をする前に optional が nil 以外の値を含んでいることを常に確認してください。



Optional の結合


Optional が値を含んでいるかどうかを調べるには optional の結合 を使用し、もし値を含んでいれば、一時的な定数または変数としてその値を利用できるようにします。Optional の結合は if および while 文を使って optional の中に値があるかをチェックするのに使われ、単一のアクションの一部として、その値を定数または変数に抽出します。if および while 文は、フロー制御 でより詳しく述べています。



if 文の Optional の結合は以下のようにを記述します。



if let = {

       

}



強制開封よりむしろ Optional の結合を使用するには、Optionals セクションから possibleNumber の例を書き直すことができます。


  1. if let actualNumber = Int(possibleNumber) {
  2.        print("\'\(possibleNumber) \' has an integer value of \(actualNumber)")
  3. } else {
  4.        print("\'\(possibleNumber)\' could not be converted to an integer")
  5. }
  6. // prints "123 has an integer value of 123"


このコードは次のように読めます。


"Int(possibleNumber) によって返された Optional の Int は、actualNumber と呼ばれる新しい定数を optional に含まれる値に設定します。"


変換が成功した場合、actualNumber 定数は、if 文の最初の分岐内で使用可能になります。これは既に optional の中に 含まれる値で初期化されており、この値にアクセスするのに ! を末尾に付けて使用する必要はありません。この例では、actualNumber は単に変換の結果を印刷するために使用されています。


optional の結合で定数と変数を両方とも使用できます。if 文の最初の分岐内の actualNumber の値を操作したい場合は、代わりに if var actualNumber と書き、optional の中に含まれる値が定数ではなく変数として利用可能になります。


する必要があるならば、単一の if 文でカンマで区切って、多くの optional の結合とブール条件を含めることができます。optional の結合の値のいずれかが nil であるか、または任意のブール条件が false に評価された場合、if 文の全体の条件は false と考慮されます。以下の if 文は等価です:


  1. if let firstNumber = Int("4"), let secondNumber = Int("42"), firstNumber < secondNumber && secondNumber < 100 {
  2.         print("\(firstNumber) < \(secondNumber) < 100")
  3. }
  4. // Prints "4 < 42 < 100"
  5. if let firstNumber = Int("4") {
  6.         if let secondNumber = Int("42") {
  7.                 if firstNumber < secondNumber && secondNumber < 100 {
  8.                         print("\(firstNumber) < \(secondNumber) < 100")
  9.                 }
  10.         }
  11. }
  12. // Prints "4 < 42 < 100"


注意: if 文内で optional の結合で作成された定数および変数は、if 文の本体内でのみ、利用可能です。これとは対照的に、guard 文で作成された定数と変数は、早期終了 で説明したように、guard 文の後に続くコードの行で利用できます。


暗黙に開封された Optional


上述したように、optionals は定数または変数が "値を持たない" 事を許可されていることを示します。if 文で、optionals は値が存在するかどうかをチェックでき、値が存在する場合は、optional の値にアクセスするには、optional の結合で条件付きで開封することができます。


時にはそれは、その値が最初に設定された後に、optional は 常に、値を持つことになる事はプログラムの構造から明らかです。このような場合、常に値があると安全に見なすことができるため、optional の値は常にアクセスされるたびにチェックしたり開封する必要がありません。


optionals のこれらの種類は、暗黙に開封された optionals として定義されています。optional にしたい型の後に疑問符(String?)ではなく感嘆符(String!)を配置して暗黙に開封された Optional を記述して下さい。


暗黙に開封された optionals は、optional が最初に定義された直後に、間違いなくその後の全ての時点で存在すると仮定できた時に有用です。所有されていない参照と暗黙に開封された Optional のプロパティ で説明したように、Swift での暗黙に開封された optional の主な用途は、クラスの初期化中にあります。


暗黙に開封された optional は、舞台裏では、通常の optional ですが、また optional でない値のようにも使われ、それがアクセスされるたびにその optional の値を開封する必要はなく、使用できます。以下の例では、明示的に String として開封されていない値にアクセスするときに、optional の文字列と、暗黙に開封された optional の文字列との間の動作の違いを示しています。


  1. let possibleString: String? = "An optional string."
  2. let forcedString: String = possibleString! // requires an exclamation mark
  3. let assumedString: String! = "An implicitly unwrapped optional string."
  4. let implicitString: String = assumedString // no need for an exclamation mark


暗黙に開封された optional は、それが使用されるたびに自動的に optional を開封するのに許可を与えると考えることができます。それを使用するたびに optional の名前の後に感嘆符を配置するのではなく、それを宣言する時に optional の型の後に感嘆符を配置します。


注意: 暗黙的に開封された optional が nil であり、その開封されていない値にアクセスしようとすると、実行時エラーを引き起こします。結果は、値を含まない通常の optional の後に感嘆符を配置した場合と全く同じです。


それが値を含んでいるかどうかをチェックするために、通常の optional のように暗黙に開封された optional を扱うことができます。


  1. if assumedString != nil {
  2.        print(assumedString)
  3. }
  4. // prints "An implicitly unwrapped optional string."


また、単一の文でその値をチェックして開封するために、optional の結合と共に、暗黙に開封された optional を使用できます。


  1. if let definiteString = assumedString {
  2.        print(definiteString)
  3. }
  4. // prints "An implicitly unwrapped optional string."


注意: 後の時点で変数が nil になる可能性がある場合には、暗黙に開封された optional を使用しないでください。変数の寿命中に nil の値をチェックする必要がある場合には、必ず通常の optional の型を使用して下さい。


エラー処理


プログラムが実行中に発生する可能性のあるエラーに対処するために エラー処理 を使用して下さい。


関数の成功や失敗を通信するための値の有無を使用できる optionals、とは対照的に、エラー処理を使用すると、失敗の基本的な原因を特定し、必要であれば、あなたのプログラムの別の部分にエラーを伝えることができます。


関数がエラー状態に遭遇すると、エラーを throws します。その関数の呼び出し元は、エラーを catch し、適切に対応できます。


  1. func canThrowAnError() throws {
  2.         // this function may or may not throw an error
  3. }


関数は、その宣言の中で throws キーワードを含めることによって、エラーを throw できることを示します。エラーを throw できる関数を呼び出すときは、式に try キーワードを付加します。


catch 節によって処理されるまで、Swift は、自動的に現在のスコープ外にエラーを伝播します。


  1. do {
  2.         try canThrowAnError()
  3.         // no error was thrown
  4. } catch {
  5.         // an error was thrown
  6. }


do 文は、エラーが一つ以上の catch 節に伝播できるようにする、新しく含んだスコープを作成します。


以下に、エラー処理が異なるエラー条件に応答するためにどのように使用できるかの例を示します。


  1. func makeASandwich() throws {
  2.         // ...
  3. }
  4. do {
  5.         try makeASandwich()
  6.         eatASandwich()
  7. } catch SandwichError.outOfCleanDishes {
  8.         washDishes()
  9. } catch SandwichError.missingIngredients(let ingredients) {
  10.         buyGroceries(ingredients)
  11. }


この例では、makeASandwich() 関数は、クリーンな料理が用意されていない場合、またはいずれかの原料が不足している場合は、エラーを throw します。makeASandwich() 関数がエラーを throw できるので、関数呼び出しを try 式で包まれています。do 文で関数呼び出しを包むことによって、throw されたエラーは、提供された catch 節に伝達されます。


エラーが throw されない場合、eatASandwich() 関数が呼び出されます。エラーが throw され、それが SandwichError.outOfCleanDishes の case に一致する場合は、washDishes() 関数が呼び出されます。エラーが throw され、それが SandwichError.missingIngredients の case に一致する場合は、buyGroceries(_:) 関数が catch パターンによって捕捉された、関連する [String] の値で呼び出されます。


throw、catch、およびエラーの伝播は、エラー処理 で、より詳細に説明されています。


アサーション(断言)と前提条件


アサーション前提条件 は、実行時に発生するチェックです。あなたは、それ以降のコードを実行する前に必須条件が満たされていることを確認するためにそれらを使用します。アサーションまたは前提条件のブール条件が true と評価された場合、コードの実行は通常通り続きます。条件が false と評価された場合、プログラムの現在の状態は無効になります。コードの実行が終了し、アプリが終了します。


アサーションと前提条件を使用して、前提を表現したり、コーディング中に期待していることを表現したりできるので、コードの一部として組み込むことができます。アサーションは、開発中の間違いや正しくない前提を見つけるのに役立ち、また、前提条件は生産する時の問題の検出に役立ちます。


アサーションと前提条件は、実行時の前提を検証することに加えて、コード内のドキュメントの有用な形式になります。上記の エラー処理 で説明したエラー条件とは異なり、アサーションおよび前提条件は、リカバリ可能なまたは予期されるエラーには使用されません。アサーションまたは前提条件のエラーが無効なプログラム状態を示すので、失敗したアサーションを catch する方法はありません。


アサーションと前提条件を使用しても、無効な条件が発生しにくいようにコードを設計することに代わるものではありません。しかし、有効なデータと状態を強制するためにそれらを使用すると、無効な状態が発生した場合にアプリがより予測可能に終了し、問題をより簡単にデバッグしやすくします。無効な状態が検出されるとすぐに実行を停止することは、その無効な状態によって引き起こされる損傷を制限するのにも役立ちます。


アサーションと前提条件の違いはチェックされたときです。アサーションはビルドをデバッグする時のみチェックされますが、前提条件はビルドのデバッグと製品ビルドの両方でチェックされます。製品ビルドでは、アサーション内の条件は評価されません。つまり、製品のパフォーマンスに影響を与えることなく、開発プロセス中に必要なだけ多くのアサーションを使用できます。


アサーションを使用したデバッグ


Swift の標準ライブラリから assert(_:_:file:line:) 関数を呼び出すことにより、アサーションを記述して下さい。この関数に、true または false への評価の式を渡して、条件の結果が false の場合メッセージを表示します。例えば:


  1. let age = -3
  2. assert(age >= 0, "A person's age cannot be less than zero")
  3. // this causes the assertion to trigger, because age is not >= 0


この例では、コードの実行は、age > =0true と評価された場合にのみ、すなわち、age の値が負でない場合にのみ続行されます。age の値が上記のコードのように、負であれば、age >= 0false と評価され、アサーションが引き起こされ、アプリを終了します。


以下の例のように、散文のように条件を続ける場合には、アサーション·メッセージは、省略できます。


assert(age >= 0)


コードがすでに条件をチェックしている場合は、アサーションが失敗したことを示すために assertionFailure(_:file:line:) 関数を使用して下さい。例えば:


  1. if age > 10 {
  2.         print("You can ride the roller-coaster or the ferris wheel.")
  3. } else if age > 0 {
  4. print("You can ride the ferris wheel.")
  5. } else {
  6.         assertionFailure("A person's age can't be less than zero.")
  7. }


前提条件の実施


条件が偽である可能性があるときは常に前提条件を使用しますが、コードが実行を継続するためには 必ず 真でなければなりません。たとえば、前提条件を使用して、添え字が範囲外でないことをチェックしたり、関数が有効な値を渡しているかどうかをチェックしたりします。


precondition(_:_:file:line:) 関数を呼び出して前提条件を記述して下さい。この関数に true または false と評価される式と、条件の結果が false の場合に表示するメッセージを渡します。例えば:


  1. // In the implementation of a subscript...
  2. precondition(index > 0, "Index must be greater than zero.")


また、preconditionFailure(_:file:line:) 関数を呼び出して、障害が発生したことを示すことができます。たとえば、switch のデフォルトの case が取られたが、すべての有効な入力データが switch のその他のいずれか 1 つで処理された場合。


注意: 非チェックモード (-Ounchecked) でコンパイルすると、前提条件はチェックされません。コンパイラは前提条件が常に true であるとみなし、それに応じてコードを最適化します。ただし、fatalError(_:file:line:) 関数は、最適化設定に関係なく、常に実行を停止します。

プロトタイプ化や初期開発中に fatalError(_:file:line:) 関数を使用して、まだ実装されていない機能のスタブ(部分) の実装として fatalError("Unimplemented") を記述してスタブを作成できます。致命的なエラーは、アサーションや前提条件とは異なり、決して最適化されないため、スタブの実装に出会うと実行は必ず停止することになります。





前:Swift のツアー 次:基本演算子
body { -webkit-text-size-adjust: 100%; } 目次
Xcode 9 の新機能

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

  • ようこそ Swift へ(Part I)
  • Swift について
  • バージョン互換性
  • Swift のツアー
  • 単純な値
    制御フロー
    関数とクロージャ
    オブジェクトとクラス
    列挙型と構造体
    プロトコルと拡張機能
    エラー処理
    汎用(ジェネリック)
  • Swift 言語のガイド(Part II)
  • Swift の基本
  • 定数と変数
  • 定数と変数の宣言
    型注釈
    定数と変数の命名
    定数と変数の印刷
    コメント
    セミコロン
  • 整数
  • 整数の境界
    Int
    UInt
    浮動小数点数
    安全な型と型推論
    数値リテラル
  • 数値型変換
  • 整数変換
    整数と浮動小数点間の変換
    型エイリアス
    ブール型
    タプル
  • Optional
  • nil
    if 文と強制開封
    Optional の結合
    暗黙に開封された Optionals
    エラー処理
  • アサーション(断言)と前提条件
  • アサーションを使用したデバッグ
    前提条件の実施
  • 基本演算子
  • 専門用語
    代入演算子
  • 算術演算子
  • 剰余演算子
    単項マイナス演算子
    単項プラス演算子
    複合代入演算子
    比較演算子
    三項条件演算子
    Nil 合体演算子
  • 範囲演算子
  • 閉鎖範囲演算子
    半開放範囲演算子
    片方の範囲
  • 論理演算子
  • 論理 NOT 演算子
    論理 AND 演算子
    論理 OR 演算子
    論理演算子の組み合わせ
    明示的な括弧
  • 文字列と文字
  • 文字列リテラル
    複数行の文字列リテラル
    文字列リテラル内の特殊文字
    空の文字列の初期化
    文字列の可変性
    文字列は値の型
    文字を使った作業
    文字列と文字を連結
    文字列補間
  • ユニコード(Unicode)
  • Unicode スカラー
    文字列リテラルの中の特別の文字
    拡張書記クラスタ
    文字を数える
  • 文字列のアクセスと変更
  • 文字列のインデックス
    部分文字列
    挿入と削除
  • 文字列の比較
  • 文字列と文字の等価性
    接頭辞と接尾辞の等価性
  • 文字列の Unicode 表現
  • UTF-8 の表現
    UTF-16 表現
    Unicode のスカラー表現
  • コレクション型
  • コレクションの可変性
  • 配列
  • 配列型省略構文
    空の配列の作成
    デフォルト値を持つ配列の作成
    2つの配列を共にして一つの配列に
    配列リテラルでの配列の作成
    配列へのアクセスと変更
    配列の繰り返し処理
  • セット
  • セット型のハッシュ値
    セット型の構文
    空のセットの作成と初期化
    配列リテラルでセットの作成
    セットへのアクセスと変更
    セットを反復処理
  • セット操作の実行
  • 基本的なセットの操作
    セットの身分と等価性
  • Dictionary
  • Dictionary 型の省略型構文
    空の Dictionary を作成
    Dictionary リテラルで Dictionary の作成
    Dictionary のアクセスと変更
    Dictionary を繰り返し処理
  • フロー制御
  • For-In ループ
  • While ループ
  • While
    Repeat-While
  • 条件文
  • if 文
  • Switch
  • 暗黙の Fallthrough なし
    範囲の一致
    タプル(Tuples)
    値の結合
    Where
    複合した case
  • 制御転送文
  • Continue
  • Break
  • ループ文内の Break
    Switch 文内の Break
    Fallthrough
    ラベル付きの文
    早期終了
    API 利用可能性の確認
  • 関数
  • 関数の定義と呼び出し
  • 関数のパラメータと戻り値
  • パラメータなしの関数
    複数パラメータの関数
    戻り値なしの関数
    複数の戻り値を持つ関数
    optional のタプル型の戻り値
  • 関数引数のラベルとパラメータ名
  • 引数のラベルの指定
    引数ラベルの省略
    デフォルトのパラメータ値
    可変個引数のパラメータ
    In-Out パラメータ
  • 関数型
  • 関数型の使用
    パラメータ型としての関数型
    戻り値の型としての関数型
    入れ子になった関数
  • クロージャ
  • クロージャ式
  • ソートするメソッド
    クロージャ式の構文
    文脈から型を推論
    単一式クロージャからの暗黙的戻り値
    引数名の省略
    演算子メソッド
    後続クロージャ
    値のキャプチャ
    クロージャは参照型
    クロージャのエスケープ
    オートクロージャ
  • 列挙型
  • 列挙型の構文
    switch 文で列挙型の値の一致
    関連する値
  • 生の値
  • 暗黙に割り当てられた生の値
    生の値からの初期化
    再帰的な列挙型
  • クラスと構造体
  • クラスと構造体を比較
  • 定義の構文
    クラスと構造体のインスタンス
    プロパティにアクセス
    構造体型のためのメンバー化イニシャライザ
    構造体と列挙型は値型
  • クラスは参照型
  • ID 演算子
    ポインタ
    クラスと構造体の間の選択
    文字列、配列、辞書の代入とコピーの動作
  • プロパティ
  • 格納されたプロパティ
  • 定数構造体インスタンスの格納されたプロパティ
    遅延した格納されたプロパティ
    格納されたプロパティとインスタンス変数
  • 計算されたプロパティ
  • セッタ宣言の省略形
    読み取り専用の計算されたプロパティ
    プロパティ監視者
    グローバルとローカル変数
  • 型プロパティ
  • 型プロパティの構文
    型プロパティの照会と設定
  • メソッド
  • インスタンスメソッド
  • self プロパティ
    インスタンスメソッド内から値の型を変更
    変異メソッド内で self に代入
    型メソッド
  • サブスクリプト
  • サブスクリプトの構文
    サブスクリプトの使用法
    サブスクリプトのオプション
  • 継承
  • 基本クラスの定義
    サブクラス化
  • オーバーライド(上書き)
  • スーパークラスメソッド、プロパティ、サブスクリプトへのアクセス
    オーバーライドするメソッド
  • オーバーライドするプロパティ
  • プロパティのゲッタとセッタのオーバーライド
    プロパティ監視者のオーバーライド
    オーバーライドの防止
  • 初期化
  • 格納されたプロパティの初期値を設定
  • イニシャライザ
    デフォルトのプロパティ値
  • 初期化のカスタマイズ
  • 初期化パラメータ
    パラメータ名と引数ラベル
    引数ラベルのないイニシャライザのパラメータ
    Optional のプロパティ型
    初期化中に定数プロパティへの代入
  • デフォルトのイニシャライザ
  • 構造体型のためのメンバ化イニシャライザ
    値型のイニシャライザデリゲート
  • クラスの継承と初期化
  • 指定イニシャライザとコンビニエンスイニシャライザ
    指定とコンビニエンスイニシャライザの構文
    クラス型のイニシャライザデリゲート
    二相の初期化
    イニシャライザ継承とオーバーライド
    自動イニシャライザの継承
    実際の指定とコンビニエンスイニシャライザ
  • 失敗可能イニシャライザ
  • 生の値を持つ列挙型のための失敗可能イニシャライザ
    初期化失敗の伝播
    失敗可能イニシャライザのオーバーライド
    init! の失敗可能イニシャライザ
    必須イニシャライザ
    クロージャや関数でのデフォルトのプロパティ値設定
  • デイニシャライザ
  • デイニシャライザはどのように働くか
    作動中のデイニシャライザ
  • Optional の連鎖
  • 強制開封の代替としての Optional の連鎖
    Optional の連鎖のモデルクラスの定義
    Optional の連鎖を使用したプロパティへのアクセス
    Optional の連鎖を通じてメソッドを呼び出す
  • Optional の連鎖を通じてサブスクリプトへのアクセス
  • Optional 型のサブスクリプトにアクセス
    連鎖の複数レベルのリンク
    optional の戻り値を持つメソッドでの連鎖
  • エラー処理
  • エラーの表現と Throw
    エラーの処理
    throw 関数を使用したエラーの伝播
    Do-Catch を使用したエラー処理
    エラー をOptional の値に変換
    エラー伝播を無効に
    クリーンアップアクションの指定
  • 型キャスト
  • 型キャストのためのクラス階層の定義
    型のチェック
    ダウンキャスト
  • Any と AnyObjecgt 用の型キャスティング
  • ネストした型
  • 実際のネストした型
    ネストした型への参照
  • 拡張機能
  • 拡張機能の構文
    計算されたプロパティ
    イニシャライザ
  • メソッド
  • 変異インスタンスメソッド
    サブスクリプト
    ネストした型
  • プロトコル
  • プロトコルの構文
    プロパティの要件
    メソッドの要件
    変異メソッドの要件
  • イニシャライザの要件
  • プロトコルイニシャライザ要件のクラス実装
    失敗可能イニシャライザの要件
    型としてのプロトコル
    デリゲート
  • 拡張機能を持つプロトコル準拠の追加
  • 拡張機能を持つプロトコルの採用を宣言
    プロトコル型のコレクション
    プロトコルの継承
    クラス専用プロトコル
    プロトコルの構成
    プロトコル準拠の確認
    Optional のプロトコル要件
  • プロトコル拡張機能
  • デフォルトの実装の提供
    プロトコル拡張機能に制約を追加
  • ジェネリック(汎用)
  • 汎用が解決する問題
    汎用関数
    型パラメータ
    型パラメータの命名
    汎用の型
    汎用型の拡張
  • 型の制約
  • 型制約の構文
    実際の型の制約
  • 関連型
  • 実際の関連型
    既存の型を拡張して関連型を指定
    型注釈を使用して関連型を制約
    汎用の Where 句
    汎用の Where 句を含む拡張機能
    関連する型と汎用の Where 句
    汎用のサブスクリプト
  • 自動参照カウント
  • どのように ARC は働くか
    実際の ARC
    クラスインスタンス間の強い循環参照
  • クラスインスタンス間の強い循環参照の解決
  • 弱い参照
    所有されていない参照
    所有されていない参照と暗黙に開封された Optional のプロパティ
    クロージャの strong な循環参照
  • クロージャの strong な循環参照の解決
  • キャプチャリストの定義
    弱い参照と所有されていない参照
  • メモリの安全性
  • メモリへのアクセス競合の理解
    メモリアクセスの特徴
    In-Out パラメータへのアクセスの競合
    メソッド内の Self へのアクセスの競合
    プロパティへのアクセスの競合
  • アクセス制御
  • モジュールとソースファイル
  • アクセスレベル
  • アクセスレベルの全体的指針
    デフォルトのアクセスレベル
    ターゲット一つのアプリのアクセスレベル
    フレームワークのアクセスレベル
    ユニットテストのターゲット用のアクセスレベル
    アクセス制御の構文
  • カスタム型
  • タプル型
    関数型
  • 列挙型
  • 生の値と関連する値
    ネストした型
    サブクラス化
  • 定数、変数、プロパティ、およびサブスクリプト
  • ゲッタとセッタ
  • イニシャライザ
  • デフォルトのイニシャライザ
    構造体型用のデフォルトメンバ化イニシャライザ
  • プロトコル
  • プロトコルの継承
    プロトコルの準拠
  • 拡張機能
  • 拡張機能の private メンバ
    汎用
    型エイリアス
  • 高度な演算子
  • ビット単位演算子
  • ビット単位の NOT 演算子
    ビット単位の AND 演算子
    ビット単位の OR 演算子
    ビット単位の XOR 演算子
  • ビット単位の左と右シフト演算子
  • 符号なし整数のシフト動作
    符号付き整数のシフト動作
  • オーバーフロー演算子
  • 値オーバーフロー
    優先順位と結合性
  • 演算子メソッド
  • 接頭辞と接尾辞演算子
    複合代入演算子
    等価演算子
  • カスタム演算子
  • カスタム挿入辞演算子の優先順位
  • 言語のガイド(Part III)
  • 言語リファレンスについて
  • 文法の読み方
  • 語彙の構造
  • 空白とコメント
    識別子
    キーワードと句読点
  • リテラル
  • 整数リテラル
    浮動小数点リテラル
    文字列のリテラル
    演算子

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

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

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



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












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)












    トップへ(Swift Language Basics)