Swiftのプロパティを三つの分類で整理してみた

OSSのコードを読んでいたり、他の人の講演やLTを聞いていると、あれ？lazyってなんだったっけ？と、「プロパティについてちゃんと理解していないよな。。。」って思うことがよくあります。
今回はそんなプロパティについてまとめましたので、同じような悩みをもった方の参考となれば嬉しいです。


# 対象とする読者
- プロパティについてなんとなく使えるけど、聞かれると困る人
- lazyってなんだっけ？コンピューテッドプロパティってなんだっけ？って人

# 目次
- プロパティの分類方法
- 分類①：定数と変数
- 分類②：インスタンスプロパティとスタティックプロパティ
- 分類③：ストアドプロパティとコンピューテッドプロパティ


# 検証環境
- Swift : 5.0.1
- Xcode : 11.0（Playground）

# プロパティの分類方法

### プロパティとは
型に紐づく値のこと。プロパティと言ったり、属性と言ったりする。
型はプロパティとメソッド（関数/ふるまい）で構成される。

### 分類①：定数と変数
値の再代入が不可能な定数と、再代入が可能な変数での分け方。letとvar。

### 分類②：インスタンスプロパティとスタティックプロパティ
インスタンスに紐づくプロパティと型自身に紐づくプロパティでの分類。
インスタンスによらず、型共通の値をもたせたいときには、スタティックプロパティを用いる。
スタティックプロパティにはlet/varの前にstaticを付ける。

### 分類③：ストアドプロパティとコンピューテッドプロパティ
値を保持するプロパティと値を都度計算するプロパティ
値を保持するストアドプロパティに対して、コンピューテッドプロパティは既存のプロパティを用いて都度用意されるため、計算もととの整合性が常に保たれるという特徴がある。



# 分類①：定数と変数

プロパティは値の名前の前に必ずletかvarを付けて、プロパティが定数か変数かを宣言しなければならない。変数には値の再代入が可能だが、定数への値の再代入は不可能。

```Swift
struct Message {
    let greeting = "Hello," // 定数
    var name = "Everyone!"  // 変数
}

var message = Message()
message.name = "@ichikawa7ss!" // 変数には再代入可能だが
message.greeting = "Goodbye,"  // 定数には再代入不可能 -> コンパイルエラー
```

# 分類②：インスタンスプロパティとスタティックプロパティ
インスタンスに紐づくプロパティと型自身に紐づくプロパティでの分類。

次のソースコードでの例のように、インスタンスプロパティではプロパティがインスタンスに紐づいているので、インスタンスごとにプロパティの設定が可能。

```Swift
struct Message {
    let greeting = "Hello," // インスタンスプロパティ（定数）
    var name = "Everyone!"  // インスタンスプロパティ（変数）
}

// Message構造体のインスタンスを生成
var message1 = Message()
let name1 = message1.name        // Everyone!

// 別のMessage構造体のインスタンスを生成
var message2 = Message()
// インスタンスプロパティに値を代入
message2.name = "@ichikawa7ss!"
let name2 = message2.name        // @ichikawa7ss!
```

一方でスタティックプロパティでは、プロパティが型自身に紐づくため、インスタンスによらずプロパティの値は一定である。
また、呼び出し方法もインスタンスプロパティが`インスタンス名.プロパティ名`であるのに対して、型に紐づくスタティックプロパティは`型名.プロパティ名`で値の呼び出しを行う必要がある。

```Swift
struct Student {
    static let className = "3-A"          // スタティックプロパティ
    static var teacherName = "Ms.Tanaka"  // スタティックプロパティ
    var name = "Shoma Ichiakwa"           // インスタンスプロパティ
}

// 一つ目のインスタンスを生成
var student1 = Student()
let teacherName1 = Student.teacherName  // Ms.Tanaka (スタティックプロパティ)
let name1 = student1.name               // Shoma Ichiakwa

// 別のインスタンスを生成
var student2 = Student()
// インスタンスプロパティ（インスタンスに紐づくプロパティ）に値を代入
student2.name = "Taro Yamada"
// スタティックプロパティも変数であれば変更可能
// スタティックプロパティは'型.プロパティ名'で値を呼び出す
Student.teacherName = "Ms.Suzuki"

let teacherName2 = Student.teacherName  // Ms.Suzuki (スタティックプロパティ)
let name2 = student2.name               // Taro Yamada

Student.className = "3-B"               // 定数は再代入不可能　-> コンパイルエラー
```

letとstaticは最初混同するかもしれないが、staticは型に共通の変数を持たせるだけなので、値の変更は可能。

# 分類③：ストアドプロパティとコンピューテッドプロパティ

## ストアドプロパティ
これまで見てきたプロパティはインスタンスや型に値を保持することができた。これをストアドプロパティという。一方で値を保持せずにアクセスするたびに値を計算するプロパティをコンピューテッドプロパティと呼ぶ。
まずはストアドプロパティに特有なプロパティオブザーバーいう機能とレイジーストアドプロパティについて確認する。

### プロパティオブザーバー
ストアドプロパティにはプロパティオブザーバーという、値の変更を監視する処理を定義することができる。（コンピューテッドプロパティは変更前の値を保持しないので、変更の監視という考え方自体が存在しない。）
以下は、インスタンス化したStudentのnameプロパティに値が更新された際に、オブザーバープロパティが機能している例。

```Swift
struct Student {
    static let className = "3-A"
    // プロパティオブサーバーの用いてプロパティの変更を監視
    var name = "Shoma Ichiakwa" {　// ストアドプロパティ
        // 値変更の"直前"に実行
        willSet {
            // 代入された値は'newValue'として使用可能
            print("**Student name will chenge to \(newValue) from \(name)**")
        }
        // 値変更の"直後"に実行
        didSet {
            // didSetの場合は代入された値はプロパティを指定して呼び出し
            print("**Student name had chenged to \(name)**")
        }
    }
}

// Student構造体のインスタンスを作成
var student = Student()
print("Created Instance: \(student)")
student.name = "Taro Yamada"
print("Student name: \(student.name)")
```

この結果は以下の通り。

```:【実行結果】
Created Instance: Student(name: "Shoma Ichiakwa")
**Student name will chenge to Taro Yamada from Shoma Ichiakwa**
**Student name had chenged to Taro Yamada**
Student name: Taro Yamada
```

インスタンス生成後、studentのnameプロパティに値の変更を行うとwillSet->didSetの順に呼び出される。

### レイジーストアドプロパティ

`var`の前に`lazy`をつけることで、レイジーストアドプロパティを宣言することができる。
通常のプロパティはインスタンスが生成され初期化されるときに値が取得されるのに対して、レイジーストアドプロパティではインスタンス生成後、実際にプロパティへのアクセスが行われるまで値の取得を遅延できる。
これにより初期化コストの高いプロパティの初期化を遅延させることができるため、アプリケーションのパフォーマンス向上に有効。
ちなみにコンピューテッドプロパティでは、そもそも毎回アクセスのたびに値が取得されるため、アクセスを遅延させる必要がない。

``` Swift:
struct SomeStruct {

    // ストアドプロパティ
    var value : Int = {
        print("** Accessed and set 'value' **")
        return 1
    }()
    
    // レイジーストアドプロパティ
    lazy var lazyValue: Int = {
        print("** Accessed and set 'lazyValue' **")
        return 2
    }()
}

var someStruct = SomeStruct()
print("Instance Created")
print("value is \(someStruct.value)")
print("lazyValue is \(someStruct.lazyValue)")
```

この出力結果は以下の通り。

```:【実行結果】
** Accessed and set 'value' **
Instance Created
value is 1
** Accessed and set 'lazyValue' **
lazyValue is 2
```
インスタンス作成時には`lazyValue`へのアクセスは遅延されており、値をプリントするときに初めて`lazyValue`へのアクセスが行われている。

また以下の例のように、レイジーストアドプロパティはインスタンス生成後にアクセスされるため、他のストアドプロパティを使用することができる。

```Swift
struct SomeStruct {
    // ストアドプロパティ
    var value = 1
    // ストアドプロパティ
    var notLazyDoubleValue: Int = {
        return value * 2 // 通常のストアドプロパティは初期化時に他のプロパティを使うことができない　-> コンパイルエラー
    }()
    // レイジーストアドプロパティ
    lazy var lazytripledValue: Int = {
        return value * 3 // レイジーストアドプロパティはインスタンス生成後にアクセスされるため、他のプロパティを使用可能
    }()
}
```

## コンピューテッドプロパティ
コンピューテッドプロパティはすでにあるプロパティを用いて、アクセスするたびに計算を行うため、計算元のプロパティと常に値の整合性が取れることが特徴。
コンピューテッドプロパティには値を呼び出すときに、他のプロパティの値を用いて値を返してくれる**ゲッタ**と、プロパティに値が代入されたときに、他のプロパティを更新してくれる**セッタ**が存在する。

### ゲッタ

ゲッタではプロパティにアクセスしたときに他のプロパティを用いて、値を返却してくれる。以下の例では`message.signature`にアクセスするたびにgetの処理が走り、`to`プロパティを用いて値を計算する。

```Swift
struct Message {
    var to : String
    // コンピューテッドプロパティ
    var signature : String {
        // ゲッタを使用して、他のプロパティを用いた値の取得が可能
        get {
            return "Dear,\(String(describing: to))"
        }
    }
    init(to: String) {
        self.to = to
    }
}

let message = Message(to: "Ms.Tanaka")
message.signature // Dear,Ms.Tanaka
```

### セッタ

セッタを定義されたプロパティは、プロパティに値が代入されると、`set`のスコープ部に書かれた処理を実行する。これにより他のプロパティの更新処理ができるため、ゲッタと併用することで、相関のある二つのプロパティ間での整合性を記述することが可能。
以下の処理ではkmとmという二つの距離単位をゲッタとセッタを用いることで二変数間の整合性を保っている。

```Swift
struct Distance {
    var kirometers : Int = 0
    
    // コンピューテッドプロパティ
    var meters : Int {
        // ゲッタを使用して、他のプロパティを用いた値の取得が可能
        get {
            return kirometers * 1000
        }
        // セッタを使用して、他のプロパティを更新することが可能
        // セットされた値を変数として命名して利用可能
        set(inputMeters) {
            kirometers = inputMeters / 1000
        }
    }
}

var distanceStations = Distance()
distanceStations.kirometers = 2
distanceStations.meters          // 2000

var distanceSchoolAndHome = Distance()
distanceSchoolAndHome.meters = 5000
distanceSchoolAndHome.kirometers // 5
```
`distanceSchoolAndHome.meters = 5000`のようにと値を格納するので、直観的にはプロパティが値を保持しているように思えるが、実際には`set`キーワード定義された処理を行なっているだけで、値は保持されていない。
`kirometers`に値が代入されようと、`meters`に値が代入されようと、結果的に値の更新・保持がなされるのはストアドプロパティである`kirometers`である。`meters`の値を取得するときには`get`内の処理により、`kirometers`を通して正しい`meters`の値取得を行なっている。

# まとめ
プロパティ、ややこしくて今まで避けてきましたが、Swiftの基礎なだけに一度整理することで様々な領域の理解に繋がると感じました。三つの分類に分けて考えると、役割の明確化なプロパティの宣言ができるようになりそうです。


# 参考
[[改訂新版]Swift実践入門 ── 直感的な文法と安全性を兼ね備えた言語 (WEB+DB PRESS plus)](https://www.amazon.co.jp/%E6%94%B9%E8%A8%82%E6%96%B0%E7%89%88-Swift%E5%AE%9F%E8%B7%B5%E5%85%A5%E9%96%80-%E7%9B%B4%E6%84%9F%E7%9A%84%E3%81%AA%E6%96%87%E6%B3%95%E3%81%A8%E5%AE%89%E5%85%A8%E6%80%A7%E3%82%92%E5%85%BC%E3%81%AD%E5%82%99%E3%81%88%E3%81%9F%E8%A8%80%E8%AA%9E-PRESS-plus/dp/477419414X/ref=pd_sbs_14_t_0/357-0934753-7062157?_encoding=UTF8&pd_rd_i=477419414X&pd_rd_r=4ba3752a-8d08-42b6-b64e-c5ac3875817d&pd_rd_w=CVeCs&pd_rd_wg=lAluN&pf_rd_p=ca22fd73-0f1e-4b39-9917-c84a20b3f3a8&pf_rd_r=H4ZPEXXMQ44YAZK9PEFP&psc=1&refRID=H4ZPEXXMQ44YAZK9PEFP)
（いつも大変お世話になっております🙇‍♂️）