ページビューの合計

2026年9月26日土曜日

iOSアプリの開発(100 Days of SwiftUI) Day13 – Protocols, extensions, and checkpoint 8

100 Days of SwiftUIのDay13です。

Day13の内容は以下の通りです。 

今日は、Swiftならではの機能、つまりプロトコル、拡張機能、そしてプロトコル拡張機能について学びます。
プロトコル拡張によって、大規模で複雑な継承階層を廃止し、より小さくシンプルなプロトコルを組み合わせることが可能になります。
これはまさに、トニー・ホーアが何年も前に言った「あらゆる大規模プログラムの中には、外に出ようとする小規模プログラムが存在する」という言葉の実現と言えるでしょう。

初めてSwiftUIプロジェクトに取り組む際に使用するプロトコルは、その後もSwiftコーディングのキャリア全体を通して非常に貴重なものとなるため、時間をかけてそれらに慣れておく価値は十分にあります。

今日は4つのチュートリアル動画を視聴していただきます。これらの動画では、プロトコル、拡張機能などについて学びます。各動画を視聴し、必要に応じて追加の資料を読んだ後、学習内容の理解度を確認するための簡単なテストがあります。

ヒント:この日は、ほぼ間違いなく1時間以上かかる数少ない日のひとつです。
4日目にも警告しましたが、だからといって楽になるわけではありません。
扱う内容が非常に多いのです!なお、オプションの読書はあくまでオプションです。一度読んだだけで理解できたトピックは飛ばしても構いません。

1. How to create and use protocols

プロトコルはSwiftにおける契約のようなものです。
データ型がどのような機能をサポートすることを期待するかを定義でき、Swiftは残りのコードがそのルールに従うことを保証します。
自宅からオフィスへの通勤をシミュレートするコードを書く場合を考えてみましょう。
小さなCar構造体を作成し、次のような関数を書くかもしれません。

func commute(distance: Int, using vehicle: Car) {
    // lots of code here
}

もちろん、彼らは電車で通勤する可能性もあるので、以下のようにも書きます。

func commute(distance: Int, using vehicle: Train) {
    // lots of code here
}

あるいは、バスで移動するかもしれない。

func commute(distance: Int, using vehicle: Bus) {
    // lots of code here
}

あるいは、自転車、電動スクーター、ライドシェア、その他さまざまな交通手段を利用するかもしれません。
実際、このレベルでは、根本的な移動方法そのものには関心がありません。

私たちが関心を持っているのは、もっと広範なことです。
つまり、各交通手段を使ってユーザーが通勤するのにどれくらいの時間がかかるか、そして新しい場所へ移動する実際の方法はどうするか、ということです。

ここでプロトコルが登場します。
プロトコルを使うことで、使用したい一連のプロパティとメソッドを定義できます。
プロトコル自体は、これらのプロパティを実装するものではありません。

例えば、次のような新しい車両プロトコルを定義することができます。

protocol Vehicle {
    func estimateTime(for distance: Int) -> Int
    func travel(distance: Int)
}

詳しく見ていきましょう。

  • 新しいプロトコルを作成するには、"protocol"の後にプロトコル名を記述します。これは新しい型なので、大文字で始まるキャメルケースを使用する必要があります。
  • このプロトコル内では、このプロトコルが期待どおりに機能するために必要なすべてのメソッドを列挙しています。
  • これらのメソッドには内部にコードは含まれていません。つまり、関数本体は提供されていません。代わりに、メソッド名、パラメータ、および戻り値の型を指定します。必要に応じて、メソッドを例外をスローするメソッドまたは変更するメソッドとしてマークすることもできます。

私たちはプロトコルを作成しましたが、それはどのように役立ったのでしょうか?

これでそのプロトコルに対応する型を設計できるようになります。
つまり、そのプロトコルの要件を満たす新しい構造体、クラス、または列挙型を作成するということです。
このプロセスを、プロトコルの採用または準拠と呼びます。

このプロトコルは、必須となる機能の全範囲を規定しているわけではなく、最低限必要な機能のみを規定しています。
つまり、このプロトコルに準拠する新しい型を作成する際に、必要に応じて様々なプロパティやメソッドを追加できるということです。

例えば、以下のように、Vehicleに準拠するCar構造体を作成できます。

struct Car: Vehicle {
    func estimateTime(for distance: Int) -> Int {
        distance / 50
    }

    func travel(distance: Int) {
        print("I'm driving \(distance)km.")
    }

    func openSunroof() {
        print("It's a nice day!")
    }
}

このコードの中で特に注目していただきたい点がいくつかあります。

  1. Swiftでは、サブクラスをマークするのと同じように、Carという名前の後にコロンを付けることで、CarがVehicleに準拠していることを伝えます。
  2. Vehicleクラスにリストアップしたメソッドはすべて、Carクラスにも完全に一致して存在する必要があります。名前が少しでも違ったり、受け取るパラメータが違ったり、戻り値の型が違ったりすると、Swiftはプロトコルに準拠していないと警告します。
  3. Carクラスのメソッドは、プロトコルで定義したメソッドの実際の実装を提供します。この場合、構造体は特定の距離を走行するのにかかるおおよその時間を分単位で推定し、travel()メソッドが呼び出されたときにメッセージを表示します。
  4. openSunroof() メソッドは Vehicle プロトコル由来のものではなく、多くの車種にはサンルーフがないため、このプロトコルにはあま​​り意味がありません。しかし、これは問題ありません。なぜなら、プロトコルは準拠する車種が持つべき最低限の機能のみを規定しており、必要に応じて独自の機能を追加できるからです。

これでVehicleプロトコルを作成し、そのプロトコルに準拠するCar構造体を作成しました。

最後に、先ほど作成したcommuter()関数を更新して、Carに追加した新しいメソッドを使用するようにしましょう。

func commute(distance: Int, using vehicle: Car) {
    if vehicle.estimateTime(for: distance) > 100 {
        print("That's too slow! I'll try a different vehicle.")
    } else {
        vehicle.travel(distance: distance)
    }
}

let car = Car()
commute(distance: 100, using: car)

このコードは全て正常に動作しますが、ここではプロトコルは実際には何の価値ももたらしていません。
確かに、プロトコルによってCarクラス内に2つの非常に特殊なメソッドを実装する必要が生じましたが、それはプロトコルを追加しなくてもできたことなので、わざわざ追加する意味があるのでしょうか?

ここからが巧妙なところです。
Swiftは、Vehicleに準拠する型はestimateTime()メソッドとtravel()メソッドの両方を実装する必要があることを認識しているため、パラメータの型としてCarではなくVehicleを使用できます。
関数は次のように書き換えることができます。
func commute(distance: Int, using vehicle: Vehicle) {

つまり、この関数は、Vehicleプロトコルに準拠する限り、どのような型のデータでも呼び出すことができるということです。
SwiftはestimateTime()メソッドとtravel()メソッドが存在することを確実に認識しているため、関数の本体を変更する必要はありません。

これがなぜ役立つのかまだ疑問に思っているなら、次の構造体について考えてみてください。
struct Bicycle: Vehicle {
    func estimateTime(for distance: Int) -> Int {
        distance / 10
    }

    func travel(distance: Int) {
        print("I'm cycling \(distance)km.")
    }
}

let bike = Bicycle()
commute(distance: 50, using: bike)

これで、Vehicle に準拠する 2 番目の構造体ができました。
ここでプロトコルの威力が明らかになります。

commuter() 関数にCarまたはBicycleを渡すことができるようになりました。
関数内部では必要なロジックをすべて記述でき、estimateTime() または travel() を呼び出すと、Swift が自動的に適切なものを使用します。

車を渡すと「運転しています」と表示され、自転車を渡すと「サイクリングしています」と表示されます。

つまり、プロトコルを使うことで、具体的な種類ではなく、どのような機能が必要かを明確に伝えることができるようになります。
「このパラメータは必ず車でなければならない」と言う代わりに、「このパラメータは、移動時間を推定して新しい場所に移動できる限り、何でも構わない」と言うことができるのです。
注記:つまりJavaのinterfaceみたいなものですね。

メソッドに加えて、準拠する型に存在しなければならないプロパティを記述するプロトコルを作成することもできます。
これを行うには、`var` と記述し、次にプロパティ名を記述し、そのプロパティが読み取り可能か書き込み可能か、あるいはその両方であるかを列挙します。

例えば、Vehicle に準拠するすべてのタイプは、その名前と現在の乗客数を指定しなければならないと指定できます。
protocol Vehicle {
    var name: String { get }
    var currentPassengers: Int { get set }
    func estimateTime(for distance: Int) -> Int
    func travel(distance: Int)
}

これにより、2つのプロパティが追加されます。
  1. nameという名前の文字列で、読み取り可能な形式である必要があります。これは定数である場合もありますが、ゲッターを持つ計算プロパティである場合もあります。
  2. currentPassengersという名前の整数型変数。読み書き可能である必要があります。これは変数である可能性もありますが、ゲッターとセッターを持つ計算プロパティである可能性もあります。
どちらの場合も型注釈が必要です。
なぜなら、プロトコルではデフォルト値を提供できないのと同様に、プロトコルがメソッドの実装を提供できないからです。

これら2つの追加要件が満たされると、SwiftはCarとBicycleの両方にプロパティが不足しているため、プロトコルに準拠していないと警告します。これを修正するには、Carに次のプロパティを追加します。
let name = "Car"
var currentPassengers = 1

そしてこれらはBicycle用です。
let name = "Bicycle"
var currentPassengers = 1
ただし、ルールに従う限り、それらを計算プロパティに置き換えることもできます。{ get set } を使用する場合は、定数プロパティを使用してプロトコルに準拠することはできません。

つまり、私たちのプロトコルでは2つのメソッドと2つのプロパティが必須となり、コードが正しく動作するためには、すべての準拠型がこれら4つの要素を実装する必要があるということです。
これにより、Swiftは機能が確実に存在することを認識できるため、それに依存するコードを記述することができます。

例えば、車両の配列を受け取り、それを使って様々なオプションの見積もりを計算するメソッドを作成できます。
func getTravelEstimates(using vehicles: [Vehicle], distance: Int) {
    for vehicle in vehicles {
        let estimate = vehicle.estimateTime(for: distance)
        print("\(vehicle.name): \(estimate) hours to travel \(distance)km")
    }
}

これでプロトコルの真の力がお分かりいただけたかと思います。
Vehicleプロトコルの配列全体を受け入れることができるため、車、自転車、またはVehicleに準拠するその他の構造体を渡しても、動作します。
getTravelEstimates(using: [car, bike], distance: 150)

プロトコルをパラメータとして受け取るだけでなく、必要に応じて関数からプロトコルを返すこともできます。

ヒント:必要なプロトコルはいくつでも指定できます。プロトコルを1つずつカンマで区切って列挙してください。サブクラスを作成してプロトコルに準拠する必要がある場合は、親クラス名を最初に記述し、その後にプロトコルを記述してください。

2. How to use opaque return types

Swiftには、非常に分かりにくく複雑ではあるものの、非常に重要な機能である「不透明な戻り値型」があります。
これを使うことで、コードの複雑さを軽減できます。
正直なところ、初心者向けのコースでこの機能を取り上げるのは、非常に重要な事実があるからです。
それは、初めてSwiftUIプロジェクトを作成するとすぐにこの機能を目にすることになるためです。

重要:不透明な戻り値型がどのように機能するかを詳細に理解する必要はありません。
ただ、それらが存在し、非常に特定の役割を果たしていることを知っておけば十分です。
この説明を読み進めていくうちに、なぜこの機能が役立つのか疑問に思うかもしれませんが、信じてください。
これは重要で、非常に役立つ機能です。ですから、ぜひ最後まで読み進めてください!

それでは、2つのシンプルな関数を実装してみましょう。

func getRandomNumber() -> Int {
    Int.random(in: 1...6)
}

func getRandomBool() -> Bool {
    Bool.random()
}

ヒント:Bool.random() は true または false を返します。ランダムな整数や小数とは異なり、カスタマイズオプションがないため、パラメータを指定する必要はありません。

つまり、getRandomNumber()はランダムな整数を返し、getRandomBool()はランダムなブール値を返します。

IntとBoolはどちらもEquatableと呼ばれる共通のSwiftプロトコルに準拠しています。Equatableとは「等しいかどうかを比較できる」という意味です。
Equatableプロトコルのおかげで、次のように==演算子を使用できます。

print(getRandomNumber() == getRandomNumber())

これらの型はどちらもEquatableに準拠しているため、関数を修正してEquatable値を返すようにすることができます。
例えば、次のようにします。

func getRandomNumber() -> Equatable {
    Int.random(in: 1...6)
}

func getRandomBool() -> Equatable {
    Bool.random()
}

しかし、このコードは動作せず、Swift は次のようなエラーメッセージを表示します。
「プロトコル 'Equatable' は Selfまたは関連型の要件があるため、汎用制約としてのみ使用できます」。
Swift のエラーメッセージの意味するところは、Equatableを返すのは意味がないということです。
そして、なぜ意味がないのかを理解することが、不透明な戻り値型を理解する鍵となります。

まず最初に、関数がプロトコルを返すことは可能です。
そして多くの場合、それは非常に便利なことです。
たとえば、ユーザーのためにレンタカーを探す関数があるとします。
この関数は、運ぶ必要のある乗客数と必要な荷物の量を受け取りますが、Compact、SUV、Minivanなど、いくつかの構造体のいずれかを返すことができます。

この問題を解決するには、これらの構造体すべてが準拠しているVehicleプロトコルを返すようにすれば良いでしょう。
そうすれば、関数を呼び出す人は、あらゆる車種に対応する10種類の関数を作成することなく、要求に合った何らかの車を受け取ることができます。
これらの車タイプはそれぞれVehicleのすべてのメソッドとプロパティを実装するため、互換性があります。

つまり、コーディングの観点からは、どのオプションが返されても問題ありません。

では元の話題に戻って、Int 型または Bool 型を返す場合について考えてみましょう。
どちらもEquatableプロトコルに準拠していますが、互換性はありません。
Swiftでは、準拠するプロトコルに関係なく、"==" を使用してInt 型と Bool 型を比較す​​ることはできません。

関数からプロトコルを返すことは、情報を隠蔽できるため便利です。
返される正確な型を指定する代わりに、返される機能に焦点を当てることができます。
車両プロトコルの場合、座席数、おおよその燃料消費量、価格などを報告することになります。
これにより、後でコードを変更しても壊れることなく済みます。
プロパティとメソッドを実装している限り、レースカーやピックアップトラックなどを返すことができます。

このように情報を隠すのは非常に便利ですが、Equatableでは不可能です。
なぜなら、Equatableの異なる2つの要素を比較することができないからです。
getRandomNumber()を2回呼び出して2つの整数を取得したとしても、それらの正確なデータ型を隠しているため、比較することはできません。
つまり、それらが実際に比較可能な2つの整数であるという事実を隠しているのです。

ここで不透明な戻り値型が登場します。
これを使うと、コード内の情報を隠蔽できますが、Swiftコンパイラからは隠蔽されません。
つまり、将来的に異なる値を返すことができるように、コード内部を柔軟に設計する権利を留保しつつも、Swiftは常に返される実際のデータ型を理解し、適切にチェックしてくれるということです。

2つの関数を不透明な戻り値型にアップグレードするには、戻り値型の前にキーワード「some」を追加します。
func getRandomNumber() -> some Equatable {
    Int.random(in: 1...6)
}

func getRandomBool() -> some Equatable {
    Bool.random()
}

これでgetRandomNumber()を2回呼び出し、==演算子を使って結果を比較できます。
私たちの視点から見ると、まだEquatableデータしかありませんが、Swiftは内部的にそれらが実際には2つの整数であることを認識しています。
戻り値の型を不透明にすることで、特定の型ではなく、返したい機能に集中できるため、将来的に変更しても他のコードに影響を与えずに済みます。
例えば、getRandomNumber() メソッドの実装を Double.random(in:) に変更しても、コードは問題なく動作します。

しかし、ここでの利点は、Swiftが常に実際の基となるデータ型を把握している点です。
微妙な違いですが、「Vehicle」を返すということは「何らかのVehicle型だが、それが何であるかはわからない」という意味です。
「some Vehicle」を返すということは「特定の種類のVehicle型だが、それがどれであるかは言いたくない」という意味です。

ここまでで頭が混乱していると思いますので、SwiftUIでこれがなぜ重要なのか、具体的な例を挙げて説明しましょう。
SwiftUIは画面に表示したいレイアウトの種類を正確に把握する必要があるため、それを記述するコードを書くのです。

英語では、次のように表現するかもしれません。
「画面の上部にツールバー、下部にタブバーがあり、中央にはスクロール可能なカラーアイコンのグリッドがあります。各アイコンの下には、そのアイコンの意味が太字で書かれたラベルがあり、アイコンをタップするとメッセージが表示されます。」

SwiftUIがレイアウトを要求すると、その説明全体(つまり、説明全体)がレイアウトの戻り値の型になります。
画面に表示したいすべての要素、つまり位置、色、フォントサイズなどを明示的に指定する必要があります。
これを戻り値の型として入力することを想像してみてください。とてつもなく長いコードになるでしょう。
そして、レイアウトを生成するコードを変更するたびに、それに合わせて戻り値の型も変更しなければなりません。

ここで役立つのが不透明な戻り値の型です。
"some View"という型を返すことで、何らかのビュー画面が返されますが、その長々とした型を記述する必要はありません。
同時に、Swiftは実際の基となる型を把握しています。
なぜなら、不透明な戻り値の型はそういう仕組みになっているからです。
Swift は常に返されるデータの正確な型を把握しており、SwiftUI はその型を使ってレイアウトを作成します。

冒頭でも述べたように、不透明な戻り値型は非常に分かりにくく、非常に複雑ですが、非常に重要な機能です。
SwiftUIで広く使われているという事実がなければ、初心者向けのコースで取り上げることはなかったでしょう。

つまり、SwiftUIコードでsome Viewを見かけたら、それは実質的にSwiftに対して「これはレイアウトするための何らかのビューを返すが、具体的な内容は書きたくないので、自分で考えてほしい」と伝えているということです。

3. How to create and use extensions

拡張機能を使用すると、自分で作成した型でも、他の人が作成した型でも、Apple独自の型であっても、あらゆる型に機能を追加できます。

これを実証するために、文字列の便利なメソッドである trimmingCharacters(in:) を紹介します。
これは、文字列の先頭または末尾から、英数字、10進数、あるいは最も一般的な例としては空白文字や改行文字など、特定の種類の文字を削除します。

空白文字とは、スペース文字、タブ文字、およびこれら2つの文字のさまざまなバリエーションの総称です。
改行とはテキスト内の行の区切りであり、単純に聞こえるかもしれませんが、実際には改行を作成する方法は一つではありません。
そのため、改行を削除するように指示すると、すべてのバリエーションが自動的に処理されます。

例えば、両側に空白文字がある文字列は次のようになります。

var quote = "   The truth is rarely pure and never simple   "

両側の空白と改行を削除したい場合は、次のようにします。

let trimmed = quote.trimmingCharacters(in: .whitespacesAndNewlines)

.whitespacesAndNewlinesの値は Apple の Foundation API から取得され、実際 trimmingCharacters(in:) も同様です。
このコースの冒頭で述べたように、Foundationには本当に便利なコードが満載です。

毎回 trimmingCharacters(in:) を呼び出すのは少し冗長なので、それを短縮するための拡張機能を作成しましょう。

extension String {
    func trimmed() -> String {
        self.trimmingCharacters(in: .whitespacesAndNewlines)
    }
}

詳しく見ていきましょう。

  1. まず、"extension"キーワードから始めます。これは、既存の型に機能を追加したいことをSwiftに伝えるものです。
  2. どの型か?それは次の問題です。"String"に機能を追加したいのです。
  3. ここで中括弧を開くと、最後の閉じ中括弧までのすべてのコードが文字列に追加されます。
  4. 新しい文字列を返す、trimmed() という新しいメソッドを追加します。
  5. その中で、以前と同じメソッド trimmingCharacters(in:) を呼び出し、その結果を返します。
  6. ここで`self`が使えることに注目してください。`self`は自動的に現在の文字列を参照します。これは、現在文字列拡張の中にいるため可能です。

これで、空白文字や改行文字を削除したい箇所すべてに、次のように記述するだけで済みます。

let trimmed = quote.trimmed()

ずっと簡単になった!

これで入力の手間は省けましたが、通常の関数と比べてそれほど優れているのでしょうか? 実は、次のような関数を書くこともできたのです。

func trim(_ string: String) -> String {
    string.trimmingCharacters(in: .whitespacesAndNewlines)
}

そして、次のように使用しました。

let trimmed2 = trim(quote)

これは、関数を作成する際にも使用する際にも、拡張機能を使うよりもコード量が少なくて済みます。
このような関数は、プロジェクト内のどこからでも利用できるため、グローバル関数と呼ばれます。
ただし、拡張機能にはグローバル関数に比べて以下のような多くの利点があります。

  1. 「quote」と入力すると、Xcodeは文字列に対するメソッドの一覧を表示します。これには、拡張機能で追加したメソッドもすべて含まれています。これにより、追加機能を簡単に見つけることができます。
  2. グローバル関数を書くとコードがかなり煩雑になり、整理しにくく、管理も難しくなります。一方、拡張機能は拡張対象のデータ型ごとに自然にグループ化されます。
  3. 拡張メソッドは元の型の完全な一部であるため、型の内部データに完全にアクセスできます。つまり、例えばプライベートアクセス制御が設定されたプロパティやメソッドも使用できます。

さらに、拡張機能を使用すると、値をその場で変更することが容易になります。
つまり、新しい値を返すのではなく、値を直接変更することができます。
例えば、先ほど、空白と改行を削除した新しい文字列を返す trimmed() メソッドを作成しましたが、文字列を直接変更したい場合は、拡張機能に以下を追加できます。
mutating func trim() {
    self = self.trimmed()
}

引用文字列は変数として作成されているため、次のようにその場でトリミングできます。
quote.trim()

メソッド名が少し変わっていることに注目してください。
新しい値を返す場合は trimmed() を使用しますが、文字列を直接変更する場合は trim() を使用します。
これは意図的なものであり、Swiftの設計ガイドラインの一部です。
値をその場で変更するのではなく、新しい値を返す場合は、`ed`や`ing`などの語尾を使用し、`reversed()`のように記述する必要があります。

ヒント:以前、配列の sorted() メソッドについて説明しました。このルールを理解した今、変数配列を作成した場合、新しいコピーを返すのではなく、その場で配列をソートするために sort() メソッドを使用できることに気づくはずです。

extensionを使用して型にプロパティを追加することもできますが、1つのルールがあります。
それは、計算プロパティのみであり、格納プロパティではないということです。
その理由は、新しい格納プロパティを追加すると、データ型の実際のサイズに影響が出るためです。
例えば、整数に多数の格納プロパティを追加すると、あらゆる場所のすべての整数がメモリ内でより多くのスペースを占有する必要があり、さまざまな問題が発生する可能性があります。

幸いなことに、計算プロパティを使えば多くのことが可能です。例えば、私が文字列に追加するのが好きなプロパティの一つに「lines」というものがあり、これは文字列を個々の行の配列に分割します。
これは、components(separatedBy:) という別の文字列メソッドをラップしたもので、指定した境界で文字列を分割して文字列配列にします。
この場合、境界線を新しい行にしたいので、文字列拡張に以下を追加します。
var lines: [String] {
    self.components(separatedBy: .newlines)
}

これで、任意の文字列のlinesプロパティを次のように読み取ることができるようになりました。
let lyrics = """
But I keep cruising
Can't stop, won't stop moving
It's like I got this music in my mind
Saying it's gonna be alright
"""

print(lyrics.lines.count)

拡張機能は、一行のコードであれ、複雑な機能であれ、常に同じ目標を持っています。
それは、コードをより簡単に記述し、読みやすくし、長期的に保守しやすくすることです。最後に、拡張機能を扱う際に非常に役立つテクニックを一つご紹介したいと思います。
Swift が構造体に対してメンバーごとのイニシャライザを自動的に生成する方法は、すでにご覧になったとおりです。
struct Book {
    let title: String
    let pageCount: Int
    let readingHours: Int
}

let lotr = Book(title: "Lord of the Rings", pageCount: 1178, readingHours: 24)

また、独自のイニシャライザを作成すると、Swiftがメンバーごとのイニシャライザを提供しなくなることも述べました。
これは意図的なもので、カスタムイニシャライザとは、次のような独自のロジックに基づいてデータを割り当てたいことを意味するからです。
struct Book {
    let title: String
    let pageCount: Int
    let readingHours: Int

    init(title: String, pageCount: Int) {
        self.title = title
        self.pageCount = pageCount
        self.readingHours = pageCount / 50
    }
}

この場合、Swift がメンバごとのイニシャライザ保持すると、おおよその読み取り時間を計算するロジックがスキップされてしまいます。

しかし、カスタムイニシャライザを使用したい場合と、Swift の自動メンバごとのイニシャライザを保持したい場合の両方が必要になることがあります。
このような状況では、Swiftが実際に何をしているのかを正確に理解しておくことが重要です。
構造体内にカスタムイニシャライザを実装すると、Swift は自動メンバごとのイニシャライザを無効にします。

そのちょっとした詳細が、次に何が起こるかのヒントになるかもしれません。
拡張機能内にカスタムイニシャライザを実装した場合、Swift は自動メンバーワイズイニシャライザを無効にしません。
考えてみれば当然のことです。
拡張機能内に新しいイニシャライザを追加した際にデフォルトのイニシャライザも無効になってしまうと、ちょっとした変更で他のあらゆる Swift コードが壊れてしまう可能性があるからです。
注記:壊れるという表記が逆にわかりずらい。単にコンパイルエラーとなるだけです。
開発中に自動メンバーワイズイニシャライザを使っていたとして、誰かが勝手にイニシャライザを追加すると、自動メンバーワイズイニシャライザを使っている部分がコンパイルエラーになります。
そして、もし拡張機能内に新しいイニシャライザを追加したときに自動メンバーワイズイニシャライザを無効にするのであれば、同じことが起きます。
→もしの話で、実際はそんなことは起きないです。

したがって、Book構造体にデフォルトのメンバーごとのイニシャライザとカスタムイニシャライザの両方を持たせたい場合は、カスタムイニシャライザを次のように拡張機能に配置します。
extension Book {
    init(title: String, pageCount: Int) {
        self.title = title
        self.pageCount = pageCount
        self.readingHours = pageCount / 50
    }
}

4. How to create and use protocol extensions

プロトコルによって、準拠する型が遵守しなければならない契約を定義でき、拡張機能によって既存の型に機能を追加できます。
では、プロトコルに拡張機能を記述できたらどうなるでしょうか?

さあ、もう悩む必要はありません。Swiftはまさにこの機能をサポートしており、適切な名前のプロトコル拡張を使用しています。
プロトコル全体を拡張してメソッドの実装を追加できるため、そのプロトコルに準拠するすべての型がそれらのメソッドを取得できます。

まずは簡単な例から始めましょう。
配列に値が含まれているかどうかをチェックする条件を、次のように記述することはよくあります。
let guests = ["Mario", "Luigi", "Peach"]

if guests.isEmpty == false {
    print("Guest count: \(guests.count)")
}

ブール演算子「!」を使うことを好む人もいます。例えば、次のように使います。

if !guests.isEmpty {
    print("Guest count: \(guests.count)")
}

私はどちらのアプローチもあまり好きではありません。
なぜなら、「配列が空でない場合」という表現が私には自然に聞こえないからです。

これは、配列に以下のような非常にシンプルな拡張機能を追加することで解決できます。

extension Array {
    var isNotEmpty: Bool {
        isEmpty == false
    }
}

 ヒント:Xcodeのプレイグラウンドはコードを上から下へ実行するため、拡張機能を使用する場所の前に必ず配置してください。

これで、より理解しやすいと思われるコードを書けるようになりました。

if guests.isNotEmpty {
    print("Guest count: \(guests.count)")
}

しかし、もっと良い方法があります。
今回は、配列にisNotEmptyを追加しましたが、セットや辞書はどうでしょうか?
確かに、同じコードを繰り返してそれらの拡張機能にコピーすることもできますが、より良い解決策があります。
配列、セット、辞書はすべて、Collectionと呼ばれる組み込みプロトコルに準拠しており、contains()、sorted()、reversed() などの機能を利用できます。

これは重要です。
なぜなら、Collectionは、isEmptyプロパティの存在を必要とするからです。
したがって、Collectionに拡張機能を記述した場合でも、isEmptyは必須であるためアクセスできます。
つまり、コード内でArrayをCollectionに変更することで、次のようになります。

extension Collection {
    var isNotEmpty: Bool {
        isEmpty == false
    }
}

この単語の変更により、配列、セット、辞書、そしてCollectionに準拠するその他のあらゆる型でisNotEmptyを使用できるようになりました。
信じられないかもしれませんが、この小さな拡張機能は、多くの人が読みやすさを実感しているため、何千ものSwiftプロジェクトで使用されています。

さらに重要なのは、プロトコルを拡張することで、本来であれば個々の構造体内で実装する必要があった機能を追加できる点です。
これは非常に強力で、Appleがプロトコル指向プログラミングと呼ぶ手法につながります。
プロトコルで必須メソッドを列挙し、それらのデフォルト実装をプロトコル拡張内に追加できます。
準拠するすべての型は、これらのデフォルト実装を使用するか、必要に応じて独自の実装を提供できます。

例えば、次のようなプロトコルがあったとします。
protocol Person {
    var name: String { get }
    func sayHello()
}

つまり、プロトコルPersonに準拠するすべては、sayHello() メソッドを追加する必要がありますが、以下のように拡張機能としてデフォルトの実装を追加することもできます。

extension Person {
    func sayHello() {
        print("Hi, I'm \(name)")
    }
}

そして、準拠する型は必要に応じて独自の sayHello() メソッドを追加できますが、追加する必要はありません。
常に、プロトコル拡張内に用意されているメソッドを利用できます。

つまり、sayHello() メソッドを使わずに従業員を作成することもできます。

struct Employee: Person {
    let name: String
}

しかし、Person に準拠しているため、拡張機能で提供したデフォルトの実装を使用できます。

let taylor = Employee(name: "Taylor Swift")
taylor.sayHello()

Swiftではプロトコル拡張機能が多用されますが、正直なところ、現時点では詳細まで理解する必要はありません。
プロトコル拡張機能を一切使わなくても、素晴らしいアプリを開発できます。
現時点では、プロトコル拡張機能の存在を知っているだけで十分です。

5. Summary: Protocols and extensions

これらの章では、Swiftの複雑ながらも強力な機能について解説してきましたが、少し苦労したとしても気にしないでください。
これらの機能は最初は理解しにくく、実際に自分のコードで試してみることで初めて真に理解できるようになります。それでは、これまでに学んだことをまとめてみましょう。

  • プロトコルはコードにおける契約のようなものです。必要な関数やメソッドを指定し、それに準拠する型はそれらを実装しなければなりません。
  • 不透明な戻り値型を使うことで、コード内の情報を一部隠蔽できます。これは、将来的な変更に対応できる柔軟性を維持したい場合や、巨大な戻り値型を記述する必要がなくなる場合などに有効です。
  • 拡張機能を使うと、独自のカスタム型やSwiftの組み込み型に機能を追加できます。例えば、メソッドを追加するだけでなく、算出プロパティを追加することも可能です。
  • プロトコル拡張を使用すると、多くの型に一度に機能を追加できます。プロトコルにプロパティやメソッドを追加すると、それに準拠するすべての型がそれらにアクセスできるようになります。

突き詰めて言うと、これらの機能は簡単そうに見えますが、実際はそうではありません。
それらが存在することを知っておく必要はありますが、学習を続けるためには、表面的な使い方にとどめる必要があるのです。


補足:プロトコルと拡張と実装について

プロトコル
プロトコルに準拠する実装側が実装すべきプロパティ、メソッドの定義のみを行います。

拡張機能
プロトコルを拡張できます。主なものは以下の2つ
プロパティにデフォルト値を設定できます。ただし、値は保存できないので計算プロパティとして固定の値を返すだけです。
メソッドにデフォルトの振る舞いを実装することができます。

実装
プロトコルに準拠するには、実装側でプロトコルで定義したプロパティ、メソッドを全て実装する必要があります。
特にインスタンスごとに変わる変数は実装側で保持する必要があります。
ただし、上記の拡張機能でデフォルトが実装されていれば不要です。

補足:不透明な戻り値型について
someをつけてSwiftに対してあいまいだけど、きちんと把握するようにする指示です。
プログラマーは長い型定義を書く必要がなくなります。

0 件のコメント:

コメントを投稿

iOSアプリの開発(100 Days of SwiftUI) Day 26 – Project 4, part one

100 Days of SwiftUIの Day26 です。 今日から新しいプロジェクトを始めます。SwiftUIのスキルをさらに磨きながら、プログラミングの魅力的な分野である機械学習にも挑戦していきます。 オックスフォード大学で教鞭を執るスウェーデン人教授、ニック・ボストロムは...