More than 5 years have passed since last update.

Swift3 全予約語 (98語) の解説

Last updated at 2019-08-15Posted at 2016-10-16

Swift3 に合わせて Swift2 全予約語 (82語) の解説をまとめ直しました。

Swift4 はこちら Swift4 全予約語 (98語) の解説

宣言 (declarations)

クラス、変数、定数、メソッド、関数などの宣言部分で使用する予約語

class

クラスの宣言や、メソッドやプロパティの前に指定することでクラスメソッド、クラスプロパティの宣言をします。

class Sample {
    var member = 1
}

let a = Sample()
let b = a
a === b       // -> true (指すものは同じ)
a.member = 2
b.member      // -> 2

プロトコルで、適用先をクラスだけに制限したいときにも使います。

protocol SampleProtocol : class {
    
}

class Sample : SampleProtocol {
    
}

deinit

デストラクタの宣言をします。これは class でのみ有効です。
スーパークラスの deinit はサブクラスの deinit 実行後に自動的に呼ばれます。

class SuperClass {
    deinit { print("Super Class's deinit is called") }
}

class SubClass: SuperClass {
    deinit { print("Sub Class's deinit is called") }
}

var subClass: SubClass? = SubClass()
subClass = nil

出力

Sub Class's deinit is called
Super Class's deinit is called

enum

列挙型の宣言をします。

extension

定義済みのクラス、構造体、プロトコル、列挙型に対して振る舞いを追加します。

fileprivate

アクセス修飾子の一種です。(Swift2 での private)
同じファイル内からのアクセスが可能です。

func

メソッドまたは関数の宣言をします。

import

モジュールを読み込みます。

init

コンストラクタを宣言します。

inout

intout 指定された引数として渡された変数は、function 内での変更が適応されます。(表面的には参照渡しに似た動作になります)

具体的には下記の動作をします。

function の呼び出し時に、引数として与えられた値がコピーされ、そのコピーが function の中で使われます。
function の終了時に引数として与えられた変数にコピーが代入されます。

class SampleClass {}

func inoutSampleForClass(sampleClass: inout SampleClass?) {
    sampleClass = nil
}

func withoutInoutSampleForClass(var sampleClass: SampleClass?) {
    sampleClass = nil
}

var sampleClass: SampleClass? = SampleClass()

// inout なし
withoutInoutSampleForClass(sampleClass)
sampleClass  // => SampleClass のインスタンス

// inout あり
inoutSampleForClass(&sampleClass)
sampleClass  // => nil

func inoutSample(a: inout Int) {
    a = 100
}

func withoutInoutSample(var a: Int) {
    a = 100
}

var varInt = 1

// inout なし
withoutInoutSample(varInt)
varInt // => 1

// inout あり
inoutSample(&varInt)
varInt // => 100

参考: In-Out Parameters

internal

アクセス修飾子の一種です。
同じモジュール内からアクセスできます。
アクセス修飾子をつけなかった場合、デフォルトで internal となります。
関連: public, private, open, fileprivate
参考: The Swift Programming Language (Swift 3) # Access Control

let

定数を宣言します。
関連: var

open

アクセス修飾子の一種です。アクセス制限の種類の中で最もアクセス制限の緩い指定です。
外のモジュールからのアクセス、継承・オーバーライドが可能です。
性質上、この制限を指定できるのは class またはオーバーライド可能な class member のみです。

public との違いは、継承・オーバーライドの許可範囲 (外のモジュールからの継承・オーバーライド可能性) です。

operator

独自の演算子を定義します。
演算子として採用できる文字については規定があります。詳細は iOS Developer Library の Language Reference > Lexical Structure > Operators をご覧ください。
関連: prefix, postfix, infix

prefix operator ☁
prefix func ☁ (a: inout Int) -> Int {
    a *= a
    return a
}
postfix operator ***  // 複数文字列も可能
postfix func *** (a: inout Int) -> Int {
    a *= a
    return a
}
infix operator ☁
func ☁ (left: Int, right: Int) -> Int {
    return left + right
}

var hoge = 2
☁hoge    // => 4
hoge***  // => 16
1 ☁ 2    // => 3

###precedencegroup
左右に被演算子をとる演算子の優先度グループを定義します。
higherThan で、どのグループより優先度が高いか指定できます。lowerThan では、他のモジュールのどのグループより優先度が低いか指定できます。associativity と assignment も指定できます。

演算子を定義する構文

infix operator <#operator name#> : <#precedence group name#>

+++が先に評価される場合

precedencegroup GroupA {

    associativity: none
}
precedencegroup GroupB {
    
    higherThan: GroupA
    associativity: none
}

infix operator ***: GroupA
infix operator +++: GroupB

func *** (left: Int, right: Int) -> Int {
    return left * right
}
func +++ (left: Int, right: Int) -> Int {
    return left + right
}

1 +++ 1 *** 0  // => 0

関連: operator, associativity, assignment

private

アクセス修飾子の一種です (クラス、変数、定数、メソッド、関数の公開範囲の指定)
最も制限の強いアクセス修飾子で、下記のように、定義されたスコープ内でのみアクセスできます。

privateのアクセス制限

class SampleClass {
    func otherScopefunc() {
        // ❗️error: use of unresolved identifier 'privateFunc'
        privateFunc()
    }
}

extension SampleClass {
    private func privateFunc() {}
    
    func sameScopefunc() {
        // OK
        privateFunc()
    }
}

let sample = SampleClass()
// ❗️error: use of unresolved identifier 'privateFunc'
sample.privateFunc()

protocol

プロトコルを宣言します。

public

アクセス修飾子の一種です (クラス、変数、定数、メソッド、関数の公開範囲の指定)
同じターゲット(モジュール)外からアクセス可能になります。主に、ライブラリなどで API として公開するものに対して指定します。
関連: private, internal

static

static 変数や static メソッドを宣言します。
protocol での宣言時 (下記参照) は class func と class var も意味に含みます。

protocol SampleProtocol {
    static func staticFuncInProtocol()
    static var staticVarInProtocol: Int { get }
}

class Sample {
    // `static func staticFuncInProtocol()` can be implemented by `static func` or `class func`
    class func staticFuncInProtocol() {}
    // ditto
    class var staticVarInProtocol: Int { return 1 }
}

struct

構造体を宣言します。

subscript

クラスや構造体に [] を実装します。
Objective-C の場合についてはクラスに [], {} を実装するに書いてみました。

実装例

class SubscriptSample {
    var hoge: Any?
    subscript(index: Int) -> String {
        get {
            return "Int もらいました"
        }
        set {
            hoge = newValue
        }
    }
    
    subscript(index: String) -> String {
        get {
            return "String もらいました"
        }
        // setter なくても良いです
    }
    
    subscript(index: AnyObject?) -> String {
        return "何かもらいました"
    }
    
    subscript(x: Int, y: Int) -> String {
        return "\(x), \(y)"
    }

    subscript() -> String {
        return "nothing"
    }
}

使用例

let subscriptSample = SubscriptSample()
var optionalSample: Int? = 1;
subscriptSample[3]     // => "Int もらいました"
subscriptSample["a"]   // => "String もらいました"
subscriptSample[nil]   // => "何かもらいました"
subscriptSample[optionalSample]  // => "何かもらいました"
subscriptSample[1, 2]  // => "1, 2"
subscriptSample[]  // => "nothing"

typealias

型の別名を宣言します。

使用例

typealias IntAlias = Int
typealias Point = (Int, Int)

参考:
The Swift Programming Language (Language Reference -> Declaration -> Type Alias Declaration)
The Swift Programming Language (Language Reference -> Declaration -> Protocol Associated Type Declaration)

associatedtype

associated type (付属型) の宣言をします。

protocol SampleProtocol {
    associatedtype AssociatedType      // 付属型を宣言します
    func sampleFunc(param :AssociatedType) -> AssociatedType
}

struct SampleStruct: SampleProtocol {
    func sampleFunc(param: Int) -> Int {  // 付属型が Int であると決定されます
        return param + param
    }
}

var

変数を宣言します。

Keywords used in statements

break

switch 文やループから抜けます。
for, while の前にラベルをつけることで抜けるブロックを指定できます。
詳細: [document の Control Flow -> Labeled Statements] (https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ControlFlow.html)

var i = 0
firstLoop: while true {
    print("first loop: \(i)")
    while true {
        i += 1
        print("second loop: \(i)")
        switch i {
        case 5:
            print("break firstLoop")
            break firstLoop
        default:
            break
        }
    }
}
print("finish: \(i)")

first  loop: 0
second loop: 1
second loop: 2
second loop: 3
second loop: 4
second loop: 5
break firstLoop
finish: 5

補足

下記の補足です。

厳密には、fallthrough の所属している case ブロックの中から抜け、所属する case 文の次の case 文または default 文内の処理を実行します。

下記のように、fallthrough が呼ばれると、即座に case ブロックから抜けます。
そのため、その下の print("1-2") は実行されません。

switch 1 {
case 1:
    defer { print("defer") }  // ブロック(スコープ) から抜ける様子を観察
    print("1-1")
    if true {
        fallthrough
    }
    print("1-2")
case 2:
    print("2")
default:
    print("default")
}

1-1
defer
2

###for
繰り返し処理を記述できます。

for-in

for i in 1...10 {
    // 処理
}

for _ in 1...10 {
    // 処理
}

Keywords used in expressions and types

as

大きく分けて、2 種類の役割があります。

キャスト

class A {}
let anyObj: AnyObject = A()
let a = anyObj as! A  // AnyObject から A にキャスト

型を明示すること

let v = 1 as Double

###Any
すべての型のインスタンス (関数型も含む) を表現します。

参考:
Type Casting for Any and AnyObject
Import Objective-C id as Swift Any type

###catch
例外が投げられた際にブロック内が実行されます。

###false
真偽値リテラルの一種で、偽を表します。

###is
ある型またはあるプロトコルを実装した型として振る舞えるかどうかを検査します。

1 is Int             // -> true
(1, 1) is AnyObject  // -> false
(1, 1) is (Int, Int) // -> true

// プロトコルの検査
protocol SampleProtocol { }
class SampleClass: SampleProtocol { }

let sampleClassInstance = SampleClass()
sampleClassInstance is SampleClass      // true
sampleClassInstance is SampleProtocol   // true

###nil
nil リテラルを表します。

Optional.None == nil // -> true

###rethrows
引数にとったクロージャが投げた例外を呼び出し元に対して更に投げます。

func sample(callback: () throws -> Int) rethrows {
    try callback()
}

super

親クラスを返します。

self

インスタンスメソッド内などで単独で使用した場合、インスタンス自身を返します
[expression (式) に対して呼び出した場合、式が評価された値が返ります](#expression (式) に対して呼び出した場合、式が評価された値が返ります )
[type (型) に対して呼び出した場合、自身の型が返ります](#type (型) に対して呼び出した場合、自身の型が返ります )

インスタンスメソッド内などで単独で使用した場合、インスタンス自身を返します

class Sample {
    var a: Int?
    func sampleMethod() -> Sample {
        a = 1
        return self     // 自身 (playground 上では Sample と見えますが、プロパティ a が変更されているので上で作成したインスタンスだと確認できます)
    }
}

expression (式) に対して呼び出した場合、式がそのまま返ります

<#expression#>.self

(1 + 1).self の返り値は (1 + 1) という式と同等です。

式がそのまま返るとは

(1 + 1).self // (1 + 1)

余談

(1 + 1).self // 2 as Int ではない
// 証明
(1 + 1).self + 1.0 // OK
(1 + 1) + 1.0      // OK

let exp = 1 + 1    // 2 as Int
exp + 1.0          // Error (type mismatch)

type (型) に対して呼び出した場合、自身の型が返ります

<#type#>.self

class Sample {
}
Sample.self    // -> Sample.Type    

Sample.self.init() // -> Sample のインスタンス (= Sample.self は自身の型を返しています)

参考: The Swift Programming Language (Language Reference -> Expressions -> Postfix Self Expression)

###Self
自身の型を返します。

###throw
例外を投げます。

###throws
メソッド、関数の宣言部に書き、例外が投げられる可能性があることを示します。

###true
真偽値リテラルの一種で、真を表します。

###try
例外が投げられる可能性のある関数・メソッドを実行します。

##Keywords that begin with a number sign (#)

#available

OS 及びそのバージョンによる条件を表現します。

if #available(iOS 10.0, *) {
    print("iOS10 or later")
}

#colorLiteral

下記の構文で色を表現するリテラルを記述できます。

#colorLiteral(red: <# expression #>, green: <# expression #>, blue: <# expression #>, alpha: <# expression #>)

型を明示しない場合は、AppKit モジュールをインポートした場合は NSColor 型、UIKit モジュールをインポートした場合は UIColor 型として解釈されます。

#column

#column が評価された場所の列番号 (Int)

#if, #else, #elseif, #endif

コンパイル時に指定のコードを含めるか否かを制御します。

条件例

#if <# Custom Flag に設定した名前 (設定せずにコンパイルすると無視される) #>
  print("DEBUG")
#endif

#if swift(>=3.0)
  print("Swift3.0")
#endif

#if arch(arm64)
  print("arm64")
#endif

#if os(OSX)
  print("OSX")
#endif

Swiftのバージョンを条件に制御する例

#if swift(>=3.0)
    print(">=Swift3.0")
#elseif swift(>=2.0)
    print(">=Swift2.0")
#else
    print("else")
#endif

参考:

#file

#file が評価された場所のファイル名 (String)

#fileLiteral

下記の構文でファイルリテラルを記述できます。

#fileLiteral(resourceName: "<# ファイル名 #>")

型を明示しない場合は URL 型として解釈されます。（Foundation モジュールがインポートされている場合のみ）
また、ファイルが取得できなかった場合、実行時エラーとなります。

参考:

#function

#function が評価された場所の関数・メソッドの名前 (String) を表現します。

#imageLiteral

下記の構文で画像リソースを表現するリテラルを記述できます。

#imageLiteral(resourceName: "<# ファイル名 #>")

型を明示しない場合は、AppKit モジュールをインポートした場合は NSImage 型、UIKit モジュールをインポートした場合は UIImage 型として解釈されます。

#keypath

key や keypath (string literal) を生成します。

class Object: NSObject {
    let value = 1
    var matryoshka: Object?
}

#keyPath(Object.value)  // "value"
#keyPath(Object.matryoshka.value)  // "matryoshka.value"

let object = Object()
object.matryoshka = Object()

object.value(forKey: #keyPath(Object.value))  // 1
object.value(forKeyPath: #keyPath(Object.matryoshka.value))  // 1

#line

#line が評価された場所の行番号 (Int)

#selector

Selector を生成します。

Swift3 から、以前の機能に加え、Objective-C で記述された class のプロパティの getter, setter メソッドの Selector を \#selector を用いて生成できるようになりました。(以前は \#selector が対応していなかったため、文字列で指定していました)

@interface ViewController : UIViewController
@property(assign) int num;
@end

#selector(getter: ViewController.num)
#selector(setter: ViewController.num)

参考:

#sourceLocation

#line, #file の値を操作します。
(Swift2.2~ での #line の機能の一つが #sourceLocation に分離されました)

(注: 私の環境 [Xcode8.0] では #file が変化することを確認できませんでした)

参考:The Swift Programming Language (Swift 3) > Line Control Statement

#dsohandle

#line, #filename, #function と同様に、書かれている場所に関する情報を表すキーワードです。
自身が書かれているライブラリがロードされている場所のアドレスを表します。(アドレスなので、他のキーワードと違い、UnsafePointer型です)

provides an UnsafePointer to the current dynamic shared object (.dylib or .so file)
引用: Modernizing Swift's Debugging Identifiers

特定の文脈でのみ予約語として使用

assignment

左右に値を取る演算子を宣言した際に、Optional Chaining 評価の一連の流れで演算するかを指定します。
true を指定すると、Optional Chaining 評価の一環として演算を行おうとします。false は既定の動作で、Optional Chaining の評価が終わってから、その評価結果と演算します。

オプショナルチェイニングでの畳み込み

precedencegroup OperationFoldedIntoOptionalChaining {
    assignment: true
}

precedencegroup OperationOutsideOfOptionalChaining {
    assignment: false
}

infix operator ~~ : OperationFoldedIntoOptionalChaining
infix operator ~^ : OperationOutsideOfOptionalChaining

func ~~ (left: Int, right: Int) -> Int {
    print("~~")
    return left + right
}

func ~^ (left: Int?, right: Int) -> Int {
    print("~^")
    return left?.advanced(by: right) ?? -1
}

let values = nil as [Int]?

values?.count ~~ 5  // => nil
values?.count ~^ 5  // => -1

/*
    ~~ 演算は、
        最初に `values` の nil 判定、nil でなければ `.count ~~ 5` を評価
        values.map { $0.count ~~ 5 } と同等。この例では `~~` 演算は実行されない。

    ~^ 演算は、最初に `values?.count` を評価、続いて `その結果 ~^ 5` を評価
        普通に `(values?.count) ~^ 5` としたのと同等。演算子の既定の動作。
*/

関連: infix, operator, precedencegroup

associativity

左右に値を取る優先度グループを宣言した際に、結合方向を指定します。
指定できる値は下記の 3 種類です。

left
right
none: 結合方向を指定しないため、同じグループの演算子同士を並べて使用することができなくなります。

優先度グループを定義する構文

precedencegroup <#precedence group name#> {
    higherThan: <#lower group name#>
    associativity: <#left | right | none#>
}

同優先度、結合方向　none

precedencegroup MyAddition {
    associativity: none
}

infix operator +++ : MyAddition
infix operator --- : MyAddition

func +++ (left: Int, right: Int) -> Int {
    return left + right
}

func --- (left: Int, right: Int) -> Int {
    return left - right
}

1 +++ 1 --- 1
/*
 error: adjacent operators are in non-associative precedence group 'MyAddition'
 1 +++ 1 --- 1
   ^     ~~~
 */

関連: left, right, none, operator, precedencegroup

###convenience
init の前に記述することで、convenience initializer を宣言します。
関連: init

###dynamic
Objective-C のランタイムを使用して値にアクセスします。

構文例

dynamic <#var | let #> <# name #>

###didSet
Stored プロパティまたは変数の値が変更された際の処理を宣言します。

###final
継承、オーバーライドを不可にします。

###get
文脈によって意味が異なります。

computed property 内: プロパティにアクセスした際の処理

class A {
    var value: Int {
        get { return 1 }
    }
}

protocol 内で宣言した場合: 値が取得可能であることの宣言

protocol Sample {
    var value: Int { get }
}

class A: Sample {
    let value = 1
}

class B: Sample {
    var value: Int { return 1 }
}

###infix
左右に被演算子をとる演算子の処理を定義します。

infix operator ☁
func ☁ (left: Int, right: Int) -> Int {
    return left + right
}

1 ☁ 2    // => 3

computed property 内: プロパティにアクセスした際の処理

class A {
    var value: Int {
        get { return 1 }
        set {}
    }
}

protocol 内で宣言した場合: 値を受け渡し可能であることを宣言

protocol Sample {
    var value: Int { get set }
}

class A: Sample {
    var value = 1
}

class B: Sample {
    var value: Int {
        get { return 1 }
        set {}
    }
}

###Type
クラス、構造体、列挙体のメタタイプを取得します。

class Sample {
    required init() {}
}

let metatype: Sample.Type = Sample.self
let instance = metatype.init()

その他

_

ワイルドカード

switch (1, "a") {
case (1, "b"):
    print("1, b")
case (1, _):
    print("1, _")  // ここがマッチします。 (_ はワイルドカード)
}

引数名の省略

引数が必要なinit

class Sample {
    var a: Int
    init(param: Int) {
        a = param
    }
}
let sample = Sample(param: 1)

引数が不要なinit

class Sample {
    var a: Int
    init(_ param: Int) {
        a = param
    }
}
let sample = Sample(1)

値を捨てる

let a: Int
(a, _) = (0, 1)
a // -> 0

257

244

You get articles that match your needs
You can efficiently read back useful information
You can use dark theme

What you can do with signing up