基本演算子


operator(演算子) は、値の確認、変更、または組み合わせるために使用する特殊記号又はフレーズです。たとえば、加算演算子(+)は、let i = 1 + 2 のように2つの数値を加算し、論理 AND 演算子(&&) は、if enteredDoorCode && passedRetinaScan のように、2つのブール値を組み合わせます。


Swift は最も標準的な C 言語の演算子をサポートしており、一般的なコーディングエラーを排除するために、いくつかの機能が向上しています。代入演算子(=) は、等価演算子(==) が意図されたときに誤って使用される事を防ぐために、値を返しません。算術演算子(+、 - 、*、/、% など) は、それらを保存できる型の許容値の範囲より大きくなったり小さくなった数字を扱うとき、予期しない結果を回避するために、値のオーバーフローを検知して禁止します。オーバーフロー演算子 で説明するように、Swift のオーバーフロー演算子を使用して値のオーバーフロー動作を選択することができます。


Swift はまた、C には見られない範囲演算子 (a..<b 及び a...b) を、値の範囲を表現するためのショートカットとして用意されています。


この章では、Swift の共通演算子について説明します。高度な演算子 では、Swift の高度な演算子をカバーし、独自のカスタム演算子を定義し、独自のカスタム型の標準演算子を実装する方法について説明します。



専門用語


演算子は、単項、二項、または三項のいずれかに分類されます。


演算子が影響する値が オペランド です。式 1 + 2 では、+ 記号は、二項演算子であり、その2つのオペランドは値 12 です。


代入演算子


代入演算子 (a = b) は b の値で a の値を初期化するか更新します。


  1. let b = 10
  2. var a = 5
  3. a = b
  4. // a is now equal to 10


代入の右側に複数の値を持つタプルがある場合、その要素は、一度に複数の定数または変数に分解されます。


  1. let (x, y) = (1, 2)
  2. // x is equal to 1, and y is equal to 2


C 言語や Objective-C の代入演算子とは異なり、Swift の代入演算子は、それ自体値を返しません。以下の文は有効ではありません:


  1. if x = y {
  2.        // this is not valid, because x = y does not return a value
  3. }


この機能は、等価演算子(==) が実際に意図されたときに、間違って代入演算子(=) が使用される事を防ぐことができます。if x = y を無効にすることで、Swift は、コード内のこれらの種類のエラーを避けるのを助けます。



算術演算子


Swift は、すべての数値型に対し4つの標準 算術演算子 をサポートしています。


  1. 1 + 2        // equals 3
  2. 5 - 3        // equals 2
  3. 2 * 3        // equals 6
  4. 10.0 / 2.5        // equals 4.0


C や Objective-C の算術演算子とは異なり、Swift の算術演算子は、デフォルトでは値がオーバーフローすることを許していません。Swift のオーバーフロー演算子(a &+ b のような) を使用して値のオーバーフローの動作を選択できます。オーバーフロー演算子 を参照してください。


加算演算子は、String の連結もサポートしています。


"hello, " + "world" // equals "hello, world"



剰余演算子


剰余演算子(a % b)は b の何倍の数が a の内輪に収まるかを示し、(剰余 として知られている) 残った値を返します。



注意: 剰余演算子(%) は、他の言語では モジュロ演算子 として知られています。しかし、負の数のための Swift での動作は、厳密に言えば、モジュロ演算と言うよりも、剰余演算であることを意味します。


剰余演算子がどのように機能するかをここに示します。9 % 4 を計算するには、まず 9 の内輪に収まるどれだけ多くの 4 がうまく収まるかを計算します:



remainderInteger_2x


9 の内輪に 2つの 4 を収めることができ、剰余は(オレンジ色で示すように) 1 です。


Swift では、これはのように書くことになります。


9 % 4        // equals 1


a % b の答えを決定するには、% 演算子は、次の式を計算し、その出力として 剰余(remainder) を返します。


a =(b × some multiplier) + remainder


ここで some multiplier は、a の内輪に収まる b の倍数の最大数です。


この式に 94 を入れると、こうなります:


9 = (4 × 2) + 1


a が負の値でも剰余を計算するときに、同じメソッドが適用されます。


-9 % 4    // equals -1


この式に -9 および 4 を挿入すると、こうなります:


-9 =(4×-2)+-1


剰余の値として -1 を与えます。


b の符号は b が負の値の場合は無視されます。これは a % ba % -b が常に同じ答えを与えることを意味します。


単項マイナス演算子


数値の符号は、- を数値の前に使用して切り替えることができ 、単項マイナス演算子 として知られています:


  1. let three = 3
  2. let minusThree = -three        // minusThree equals -3
  3. let plusThree = -minusThree        // plusThree equals 3, or "minus minus three"


単項マイナス演算子(-) は空白なしに、それが動作する値の直前に付加します。


単項プラス演算子


単項プラス演算子(+)は、単にそれが動作した値をそのまま返します。


  1. let minusSix = -6
  2. let alsoMinusSix = +minusSix    // alsoMinusSix equals -6


単項プラス演算子は、実際には何もしませんが、負の数値用の単項マイナス演算子も使用した場合、正の数用にあなたのコード内で対称性を提供するためにそれを使用できます。


複合代入演算子


C と同様に、Swift は代入(=)と別の操作を組み合わせた、複合代入演算子 を提供します。一つの例は、加算代入演算子(+=)です。


  1. var a = 1
  2. a += 2
  3. // a is now equal to 3


a += 2 は、 a = a + 2 の省略形です。効果的には、加算と代入が一つの演算子に結合され、同時に両方の演算を実行します。



注意: 複合代入演算子は値を返しません。例えば、let b = a += 2 と書くことはできません。


Swift 標準ライブラリで提供される演算子については、Swift 標準ライブラリ演算子リファレンス で述べます。



比較演算子


Swift は、標準 C の 比較演算子 を全てサポートしています。


注意: Swift は、2つの 同一演算子(=== および !==)を提供し、2つのオブジェクト参照が両方とも同じオブジェクトインスタンスを参照しているかどうかテストするために使用します。詳細については、クラスと構造体 を参照してください。


それぞれの比較演算子は、文が真であるかどうかを示す Bool 値を返します。


  1. 1 == 1        // true, because 1 is equal to 1
  2. 2 != 1        // true, because 2 is not equal to 1
  3. 2 > 1          // true, because 2 is greater than 1
  4. 1 < 2          // true, because 1 is less than 2
  5. 1 >= 1        // true, because 1 is greater than or equal to 1
  6. 2 <= 1        // false, because 2 is not less than or equal to 1


比較演算子は、多くの場合、if 文などの条件文で使用されます。


  1. let name = "world"
  2. if name == "world" {
  3.        print("hello, world")
  4. } else {
  5.        print("I'm sorry \(name), but I don't recognize you")
  6. }
  7. // prints "hello, world", because name is indeed equal to "world"


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


同じ型と同じ数値を持つタプルを 2 つ比較することができます。タプルは、左から右に、一度に 1 つの値を比較して、等しくない 2 つの値が見つかるまで比較されます。これらの 2 つの値は比較され、その比較の結果がタプル比較の全体的な結果を決定します。すべての要素が等しい場合、タプル自体は等しいです。例えば:


  1. (1, "zebra") < (2, "apple")       // true because 1 is less than 2; "zebra" and "apple" are not compared
  2. (3, "apple") < (3, "bird")         // true because 3 is equal to 3, and "apple" is less than "bird"
  3. (4, "dog") == (4, "dog")         // true because 4 is equal to 4, and "dog" is equal to "dog"


上に挙げた例では、左から右への比較動作を最初の行で確認できます。12 より小さいため、タプル内の他の値に関係なく、(1,"zebra")(2,"apple") よりも小さいとみなされます。比較が既にタプルの最初の要素によって決定されているので、"zebra""apple" より小さくはありません。ただし、タプルの最初の要素が同じ場合、2 番目の要素が比較されます。これが、2 行目と 3 行目で起こっている事です。


タプルは、演算子がそれぞれのタプルの各値に適用できる場合のみ、与えられた演算子と比較できます。たとえば、以下のコードで示すように、String 型と Int 型の両方の値が < 演算子を使用して比較できるため、(String、Int) の型の 2 つのタプルを比較できます。対照的に、< 演算子は Bool 値に適用できないため、(String、Bool) 型の 2 つのタプルは < 演算子で比較できません。


  1. ("blue", -1) < ("purple", 1)             // OK, evaluates to true
  2. ("blue", false) < ("purple", true)     // Error because < can't compare Boolean values


注意: Swift 標準ライブラリは7つの要素より少ないタプル用のタプルの比較演算子を含んでいます。7つ以上の要素のタプルを比較するには、比較演算子を自分で実装する必要があります。

三項条件演算子


三項条件演算子 は、question ? answer1:answer2 の形式を取る、三つの部分から成る特別な演算子です。それは question が真か偽かに基づいて2つの式のいずれか一つを評価するための省略形です。question が true の場合、それは answer1 を評価し、その値を返します。それ以外の場合は、answer2 を評価し、その値を返します。


三項条件演算子は、以下のコードの省略形です。


  1. if question {
  2.        answer1
  3. } else {
  4.        answer2
  5. }


ここで、表の列の高さを計算する例を挙げましょう。列の高さは、ヘッダーを持っている場合、コンテンツの高さよりも 50 ポイント高く、ヘッダーを持っていない場合、列の高さは 20 ポイント高くなります。


  1. let contentHeight = 40
  2. let hasHeader = true
  3. let rowHeight = contentHeight + (hasHeader ? 50 : 20)
  4. // rowHeight is equal to 90


前の例は、以下のコードの省略形です。


  1. let contentHeight = 40
  2. let hasHeader = true
  3. var rowHeight = contentHeight
  4. if hasHeader {
  5.        rowHeight = rowHeight + 50
  6. } else {
  7.        rowHeight = rowHeight + 20
  8. }
  9. // rowHeight is equal to 90


最初の例の三項条件演算子の使用は、rowHeight を 1 行のコードで正しい値に設定できることを意味し、これは、2 番目の例で使用されるコードよりも簡潔です。


三項条件演算子は、考慮すべき2つの式を決定するための効率的な省略形を提供します。しかし、注意して三項条件演算子を使用してください。過剰に使用すると、その簡潔さは、読みにくいコードにつながることになります。1つの複合文に三項条件演算子の複数のインスタンスを組み合わせることは避けてください。


Nil 合体演算子


nil 合体演算子 (a ?? b) は、optional a が値を含んでいる場合それを開封するか、または anil の場合、デフォルトの b の値を返します。式 a は、常に optional の型です。式 b は、a の内部に保存されている型と一致しなければなりません。


nil 合体演算子は、以下のコードの省略形です。


a != nil ? a! : b



上記のコードは、三項条件演算子を使用し、anil でないときに a の内側に包まれた値にアクセスするのに、強制開封(a!)を使用し、そうでなければ b を返します。nil 合体演算子は、この条件のチェックと簡潔で読みやすい形式で開封をカプセル化するためのよりエレガントな方法を提供します。



注意: a の値が nil でない場合は、b の値は評価されません。これは、短絡評価 として知られています。


以下の例では、デフォルトの色名と optional のユーザー定義の色名のどちらかを選択する nil 合体演算子を使用しています。


  1. let defaultColorName = "red"
  2. var userDefinedColorName: String?        // defaults to nil
  3. var colorNameToUse = userDefinedColorName ?? defaultColorName
  4. // userDefinedColorName is nil, so colorNameToUse is set to the default of "red"


userDefinedColorName 変数は nil のデフォルト値を持ち、optional の String として定義されています。 userDefinedColorName は optional 型であるため、その値を考慮するために nil 合体演算子を使用できます。上記の例では、演算子が colorNameToUse と呼ばれる String 変数の初期値を決定するために使用されています。userDefinedColorNamenil なので、式 userDefinedColorName ?? defaultColorNamedefaultColorName の値、つまり "red" を返します。


userDefinedColorName に、nil でない値を代入し、もう一度 nil 合体演算子チェックを実行した場合、userDefinedColorName 内に包まれた値が、デフォルトの代わりに使用されます。


  1. userDefinedColorName = "green"
  2. colorNameToUse = userDefinedColorName ?? defaultColorName
  3. // userDefinedColorName is not nil, so colorNameToUse is set to "green"


範囲演算子


Swift は、値の範囲を表現するための省略形であるいくつかの 範囲演算子 を含んでいます。



閉鎖範囲演算子


閉鎖範囲演算子 (a...b)は a から b に至る範囲を定義し、値 ab を含みます。a の値は b より大きくてはいけません。


閉鎖範囲演算子は、for-in ループなどと同様に、使用されるすべての値の範囲を反復処理する時に便利です。


  1. for index in 1...5 {
  2.        print("\(index) times 5 is \(index * 5)")
  3. }
  4. // 1 times 5 is 5
  5. // 2 times 5 is 10
  6. // 3 times 5 is 15
  7. // 4 times 5 is 20
  8. // 5 times 5 is 25


for-in ループの詳細については、フロー制御 を参照してください。



半開放範囲演算子


半開放範囲演算子(a . . <b) は a から b に至る範囲を定義しますが、b を含みません。それは、その最後の値を含まず、その最初の値を含んでいるので、半開放 であると呼ばれます。閉鎖範囲演算子と同じように、a の値は b より大きくてはいけません。a の値が b に等しい場合、結果の範囲は空になります。


半開放範囲は、リストの(それを含まない) 長さまでカウントする時に有用で、配列などのゼロベースのリストを操作するときに特に有用です:


  1. let names = ["Anna", "Alex", "Brian", "Jack"]
  2. let count = names.count
  3. for i in 0..<count {
  4.        print("Person \(i + 1) is called \(names[i])")
  5. }
  6. // Person 1 is called Anna
  7. // Person 2 is called Alex
  8. // Person 3 is called Brian
  9. // Person 4 is called Jack


それは半開放範囲であるため、配列は4つの項目を含んでいることに注意し、0..<count は、3 (配列の最後の項目のインデックス)までしかカウントしません。配列の詳細については、配列 を参照してください。



片方の範囲


閉じた範囲演算子には、ある方向で可能な限り継続する範囲 (たとえば、インデックス 2 から配列の終わりまでの配列のすべての要素を含む範囲) の代替形式があります。このような場合、範囲演算子の片方から値を省略できます。このような範囲は演算子には片方だけに値があるため 片方の範囲 と呼ばれます。 例えば:


  1. for name in names[2...] {
  2.         print(name)
  3. }
  4. // Brian
  5. // Jack
  6. for name in names[...2] {
  7.         print(name)
  8. }
  9. // Anna
  10. // Alex
  11. // Brian


半開放範囲演算子にも、最後の値のみで書かれた片方の書式があります。両側に値を含めるのと同じように、最後の値は範囲の一部ではありません。例えば:


  1. for name in names[..<2] {
  2.         print(name)
  3. }
  4. // Anna
  5. // Alex


片方の範囲は、下付き文字だけでなく、他のコンテキストでも使用できます。最初の値を省略した片方の範囲を反復することはできません。なぜなら、繰り返しの開始場所が明確でないためです。最後の値を省略した片方の範囲で反復処理を行うことが できます。ただし、範囲が無限に続くので、ループの明示的な終了条件を追加してください。以下のコードに示すように、片方の範囲に特定の値が含まれているかどうかを確認することもできます。


  1. let range = ...5
  2. range.contains(7)         // false
  3. range.contains(4)         // true
  4. range.contains(-1)         // true


論理演算子


論理演算子 は、ブール論理値の truefalse の変更または結合をします。Swift は C ベースの言語に見られる3つの標準的な論理演算子をサポートしています。


論理 NOT 演算子


論理 NOT 演算子 (!a)は、truefalse になり、falsetrue になるようにブール値を反転します。


論理 NOT 演算子は前置演算子であり、空白なしで、それが操作する値の直前に表示されます。それは以下の例のように、"not a"と読むことができます:


  1. let allowedEntry = false
  2. if !allowedEntry {
  3.        print("ACCESS DENIED")
  4. }
  5. // prints "ACCESS DENIED"


if !allowedEntry のフレーズは、"もしエントリが許されてなかったら" のように読むことができます。"エントリが許されていない"が true の場合にのみ、後続の行が実行されます:すなわち、allowesEntryfalse の場合。


この例のように、ブール定数と変数の名を慎重に選択すると、二重陰性または論理文を混乱させる事を回避しながら、読みやすく簡潔なコードを維持するのを助けます。


論理 AND 演算子


論理 AND 演算子(a && b) は式全体も true になるためには、両方の値が true でなければならない論理式を作成します。


どちらかの値が false の場合、式全体も false になります。事実、最初 の値が false の場合、全体の式は true とならないので、第2の値は、評価すらされません。これは、短絡評価 として知られています。


以下の例は、2つの Bool 値を考慮し、両方の値が true である場合にのみアクセスを許可します:


  1. let enteredDoorCode = true
  2. let passedRetinaScan = false
  3. if enteredDoorCode && passedRetinaScan {
  4. print("Welcome!")
  5. } else {
  6.        print("ACCESS DENIED")
  7. }
  8. // prints "ACCESS DENIED"


論理 OR 演算子


論理 OR 演算子(a || b)は、二つの隣接するパイプ文字から作られた中置演算子です。2つの値の 一方 のみが true であれば式全体が true となる論理式を作成するためにそれを使用できます。


上記の論理 AND 演算子と同様に、論理 OR 演算子は、その式を検討する短絡評価を使用します。論理 OR 式の左辺が true であれば、式全体の結果を変更することはできないので、右辺は、評価されません。


以下の例では、最初の Bool 値(hasDoorKey) は false ですが、2番目の値(knowsOverridePassword) が true です。一つの値が true であるため、式全体も true に評価され、アクセスが許可されます。


  1. let hasDoorKey = false
  2. let knowsOverridePassword = true
  3. if hasDoorKey || knowsOverridePassword {
  4.        print("Welcome!")
  5. } else {
  6.        print("ACCESS DENIED")
  7. }
  8. // prints "Welcome!"


論理演算子の組み合わせ


複数の論理演算子を組み合わせて長い複合式を作成できます。


  1. if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
  2.        print("Welcome!")
  3. } else {
  4.        print("ACCESS DENIED")
  5. }
  6. // prints "Welcome!"


この例では、長い複合式を作成するために、複数の &&|| 演算子を使用しています。しかし、&&|| 演算子は、2つの値を操作するだけで、これは実際には互いに連鎖する3つの小さい式です。この例は以下のように読むことができます:


我々は正しいドアのコードを入力し、網膜スキャンに合格したか、または有効なドアの鍵を持っているか、または緊急オーバーライドパスワードを知っている場合、アクセスを許可します。


enteredDoorCode、passedRetinaScan、および hasDoorKey の値に基づいて、最初の二つの部分式は false です。ただし、緊急オーバーライドパスワードが知られているので、全体的な複合式は、依然として true と評価されます。


注意: Swift の論理演算子 &&|| は左結合性で、複数の論理演算子を持つ複合式は最も左端にある部分式を最初に評価することを意味します。


明示的な括弧


複合式の意図を読みやすくするために、厳密に言えば必要でない括弧を含めることが便利な場合があります。上記のドアアクセスの例では、その意図を明示的にするために複合式の最初の部分の周りに括弧を追加するのが便利です。


  1. if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
  2.        print("Welcome!")
  3. } else {
  4.        print("ACCESS DENIED")
  5. }
  6. // prints "Welcome!"


括弧は、最初の2つの値が、全体的な論理では可能ならば分けられる一部の状態とみなされることを明らかにします。複合式の出力は変化しませんが、全体的な意図は、読者へより明確に伝わります。読みやすさは常に簡潔さよりも好ましく、意図を明確にするのに役立つ所に括弧を使用して下さい。





前:Swift の基本 次:文字列と文字
目次
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 句
    汎用引数句
  • 文法のまとめ
  • 語彙の構造



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