ページビューの合計

2026年10月29日木曜日

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

100 Days of SwiftUIのDay23です。

ウォルト・ディズニーはかつて「魔法に魔法はない、すべては細部に宿る」と言いました。
これはSwiftUIにもまさに当てはまります。一見すると、効率的な動作を実現するためにあらゆる魔法が働いているように思えるかもしれませんが、実際にはその裏側を覗いてみると、どのように機能しているのかが正確に分かり始め、それによってSwiftUIの使い方をより深く理解できるようになります。

今日は最初の技術プロジェクトで、SwiftUIの2つの基本要素であるビューとモディファイアに焦点を当てます。
これらは既に使ってはいますが、その仕組みについては軽く触れる程度でした。
しかし、今日はそれが終わりです。ビューとモディファイアとは何か、どのように動作するのか、そしてなぜそのように動作するのかについて、詳しく解説していきます。

すべてが計画通りに進めば、最終的には魔法のような要素は減り、詳細な情報が増えるでしょう。SwiftUIを使うのは引き続き楽しいでしょうが、その仕組みを正確に理解できるようになります。

今日は10個のトピックに取り組みます。これらのトピックを通して、カスタムビュー修飾子とカスタムコンテナの構築方法を学び、SwiftUIが内部でどのように動作するのかについての理解を深めていきます。

1. Views and modifiers: Introduction

この3つ目のSwiftUIプロジェクトは、実は初めての技術系プロジェクトです。今回は、SwiftUIの特定の機能を深く掘り下げ、その仕組みと動作原理を詳細に見ていくという、いつもとは趣向を変えたプロジェクトとなっています。

このテクニックプロジェクトでは、ビューとビュー修飾子について詳しく見ていき、現時点で多くの人が抱いている疑問、つまり、なぜSwiftUIはビューに構造体を使用するのか、なぜsome Viewを多用するのか、修飾子は実際にはどのように機能するのか、といった疑問に答えていきたいと思います。このプロジェクトを終える頃には、SwiftUIの仕組みを深く理解できるようになっていることを願っています。

他の日と同様に、コードの動作を確認できるようにXcodeプロジェクトで作業することをお勧めします。そのため、ViewsAndModifiersという名前の新しいアプリプロジェクトを作成してください。

2. Why does SwiftUI use structs for views?

UIKitやAppKit(iOSとmacOS向けのAppleのオリジナルユーザーインターフェースフレームワーク)のプログラミング経験がある方なら、ビューに構造体ではなくクラスを使用していることをご存知でしょう。
SwiftUIはそうではありません。私たちはビューに構造体を使用することを推奨しており、それにはいくつかの理由があります。

まず、パフォーマンスという要素があります。
構造体はクラスよりもシンプルで高速です。
パフォーマンスという要素と言ったのは、多くの人がこれがSwiftUIが構造体を使用する主な理由だと考えているからです。実際には、それは全体像の一部に過ぎません。

UIKitでは、すべてのビューはUIViewというクラスから派生しており、このクラスには背景色、配置方法を決定する制約、コンテンツをレンダリングするためのレイヤーなど、多くのプロパティとメソッドがありました。これらのプロパティとメソッドは多数存在し、継承の仕組み上、すべてのUIViewおよびUIViewのサブクラスはそれらを持つ必要がありました。

SwiftUIでは、すべてのビューは単純な構造体であり、作成にほとんど費用がかかりません。考えてみてください。単一の整数を保持する構造体を作成した場合、構造体全体のサイズは…その単一の整数だけです。それ以外は何もありません。親クラス、祖父母クラス、曾祖父母クラスなどから継承された予期せぬ余分な値は一切ありません。ビューには、目に見えるものだけが含まれており、それ以上のものは含まれていません。

最新のiPhoneの性能のおかげで、1000個の整数、あるいは10万個の整数を作成することなど、何の躊躇もなく瞬時に完了します。
1000個のSwiftUIビュー、あるいは10万個のSwiftUIビューについても同様で、処理速度が非常に速いため、考える必要すらありません。

しかし、パフォーマンスも重要ですが、ビューを構造体として扱うことには、もっと重要な点があります。それは、状態をきちんと分離することを意識させられる点です。
クラスは値を自由に変更できるため、コードが複雑になりがちです。
SwiftUIは、値が変更されたことをどのように把握してUIを更新すればよいのでしょうか?

SwiftUIは、時間の経過とともに変化しないビューを生成することで、より機能的な設計アプローチへの移行を促します。
つまり、ビューは制御不能に成長しうるインテリジェントなものではなく、データをUIに変換するシンプルで静的な存在になるのです。

ビューとして使用できるものの種類を見てみると、このことがよくわかります。
すでにColor.redとLinearGradientをビューとして使用しましたが、これらはごくわずかなデータしか保持しない単純な型です。
実際、Color.redをビューとして使用すること以上にシンプルな方法はありません。Color.redは「私のスペースを赤で塗りつぶす」以外の情報を何も保持しないからです。

それに対し、AppleのUIViewに関するドキュメントには、UIViewが持つ約200のプロパティとメソッドが記載されており、それらはサブクラスが必要かどうかに関わらずすべてサブクラスに渡されます。

ヒント
ビューにクラスを使用すると、コードがコンパイルされなかったり、実行時にクラッシュしたりする可能性があります。私を信じてください。構造体を使用してください。

3. What is behind the main SwiftUI view?

SwiftUIを始めたばかりの頃は、次のようなコードが表示されます。
struct ContentView: View {
    var body: some View {
        VStack {
            Image(systemName: "globe")
                .imageScale(.large)
                .foregroundStyle(.tint)
            Text("Hello, world!")
        }
        .padding()
    }
}
その後、そのVStackに背景色を追加して、画面全体に表示されることを期待するのが一般的です。
struct ContentView: View {
    var body: some View {
        VStack {
            Image(systemName: "globe")
                .imageScale(.large)
                .foregroundStyle(.tint)
            Text("Hello, world!")
        }
        .padding()
        .background(.red)
    }
}
しかし、そうはなりません。代わりに、画面中央に小さな赤い領域が表示され、その向こうには白い海が広がっています。

これは人々を混乱させ、たいてい「画面の背後にあるものを赤くするにはどうすればいいですか?」という疑問につながります

はっきり言っておきますが、SwiftUI開発者にとって、ビューの背後には何もありません。
奇妙なハックや回避策を使って、あの白い空間を赤くしようと試みるべきではありませんし、ましてやSwiftUIの外部からそれを実現しようとすべきではありません。

現状では、少なくともコンテンツビューの背後にはUIHostingControllerと呼ばれるものが存在します。
これは、UIKit(AppleのオリジナルのiOS UIフレームワーク)とSwiftUIをつなぐブリッジです。しかし、これを変更しようとすると、Appleの他のプラットフォームではコードが動作しなくなり、将来的にはiOSでも完全に動作しなくなる可能性があります。

補足
確かに画面中央に小さな赤い領域が表示され、それ以外は白い背景のままですね。


そうではなく、私たちの視界の裏には何もない、つまり、あなたが見ているものが私たちの全てだという考え方を身につけるように努めるべきです。

その考え方に至ったら、正しい解決策はVStackがより多くのスペースを占めるようにすることです。
つまり、コンテンツに合わせて正確にサイズ調整するのではなく、画面全体を埋めるようにするのです。そのためには、frame()修飾子を使用し、最大幅と最大高さの両方に.infinityを指定します。

そこで、padding() 修飾子を次のように置き換えてください。
.frame(maxWidth: .infinity, maxHeight: .infinity)
maxWidthとmaxHeightを使うことは、widthとheightを使うこととは異なります。VStackがそのスペースをすべて占有しなければならないという意味ではなく、占有できるという意味です。
周囲に他のビューがある場合、SwiftUIはそれらすべてに十分なスペースが確保されるようにします。

補足
全領域が赤くなりました。

4. Why modifier order matters

SwiftUIビューに修飾子を適用するたびに、実際にはその変更が適用された新しいビューが作成されます。既存のビューをその場で変更するわけではありません。
考えてみれば、この動作は理にかなっています。ビューは指定されたプロパティのみを保持するため、背景色やフォントサイズを設定しても、そのデータを保存する場所がないからです。

なぜこのようなことが起こるのかについては後ほど詳しく見ていきますが、まずはこの動作がもたらす実際的な影響について見ていきましょう。以下のコードをご覧ください。
Button("Hello, world!") {
    // do nothing
}    
.background(.red)
.frame(width: 200, height: 200)
実際に実行されたら、どんな見た目になると思いますか?
おそらくあなたの予想は外れます。真ん中に「Hello, world!」と書かれた200×200の赤いボタンが表示されるわけではありません。代わりに、真ん中に「Hello, world!」と書かれた200×200の空の正方形が表示され、その「Hello, world!」を赤い長方形が囲んでいるでしょう。
修飾子の仕組みを考えてみれば、ここで何が起こっているのか理解できるでしょう。
それぞれの修飾子は、ビューのプロパティを設定するだけでなく、その修飾子が適用された新しい構造体を作成します。
ビューのボディのタイプを問い合わせることで、SwiftUIの内部構造を垣間見ることができます。ボタンを以下のように変更してください。

Button("Hello, world!") {
    print(type(of: self.body))
}    
.background(.red)
.frame(width: 200, height: 200)

Swiftのtype(of:)関数は、特定の値の正確な型を出力します。この場合、以下のように出力されます。ModifiedContent<ModifiedContent<Button<Text>, _BackgroundStyleModifier<Color>>, _FrameLayout>

ここでは2つのことが分かります。
  • ビューを変更するたびに、SwiftUI はジェネリクスを使用してその修飾子を適用します: ModifiedContent<OurThing, OurModifier>
  • 複数の修飾子を適用すると、それらは単純に積み重なります: ModifiedContent<ModifiedContent<…
タイプを読み取るには、最も内側のタイプから始めて外側に向かって調べていきます。
  • 最も内側の型は ModifiedContent<Button<Text>, _BackgroundStyleModifier<Color> です。このボタンには、背景色が適用されたテキストが含まれています。
  • その周りには ModifiedContent<…, _FrameLayout> があり、これは最初のビュー (ボタン + 背景色) を取得し、より大きなフレームを与えます。

ご覧のとおり、最終的には ModifiedContent 型が積み重なって表示されます。それぞれの型は、ビューを直接変更するのではなく、変換するビューと実際に行う変更を受け取ります。
つまり、修飾子の順序が重要だということです。フレームの後に背景色を適用するようにコードを書き直せば、期待通りの結果が得られる可能性があります。
Button("Hello, world!") {
    print(type(of: self.body))
}
.frame(width: 200, height: 200)
.background(.red)
現時点では、SwiftUI は修飾子を一つずつ適用するたびにビューをレンダリングすると考えるのが一番良いでしょう。
つまり、.background(.red) と記述するとすぐに、指定したフレームサイズに関係なく背景が赤色に塗りつぶされます。その後、フレームサイズを拡大しても、背景が魔法のように再描画されることはありません。既に適用済みの色だからです。

もちろん、これは実際のSwiftUIの動作方法ではありません。
もしそうだったらパフォーマンスが悪夢になってしまうからです。しかし、学習中は便利な思考の近道として活用できます。
修飾子を使用する重要な副次的効果は、同じ効果を複数回適用できることです。それぞれの修飾子は、以前に存在していたものに単純に加算されます。

例えば、SwiftUIにはpadding()修飾子があり、これを使うとビューの周囲に少しスペースを追加して、他のビューや画面の端にぶつからないようにすることができます。パディングを適用してから背景色を適用し、さらにパディングを適用してから別の背景色を適用すると、次のようにビューに複数の境界線を設定できます。
Text("Hello, world!")
    .padding()
    .background(.red)
    .padding()
    .background(.blue)
    .padding()
    .background(.green)
    .padding()
    .background(.yellow)

補足
frameとbackgroundの適用を逆にした場合、複数境界線が適用した場合などは以下のようになります。
ようは記述した順に上から下に対象へ適用するということですね。


5. Why does SwiftUI use “some View” for its view type?

SwiftUIは、「不透明な戻り値型」と呼ばれるSwiftの強力な機能に大きく依存しており、some Viewを記述するたびにその動作を確認できます。
これは、「Viewプロトコルに準拠するオブジェクトが1つ存在するが、それが何であるかは明示しない」ことを意味します。

some Viewを返すということは、返されるViewの型が何であるかを我々には知らなくても、コンパイラはそれを知っているということです。これは些細なことのように思えるかもしれませんが、重要な意味を持ちます。

まず、パフォーマンスのためには、some Viewを使用することが重要です。
SwiftUIは、表示されているビューを調べて、それらがどのように変化するかを理解する必要があります。そうすることで、ユーザーインターフェースを正しく更新できるからです。SwiftUIがこの追加情報を持たない場合、何が変更されたかを正確に把握するのに非常に時間がかかり、小さな変更があるたびにすべてを破棄して最初からやり直す必要が生じます。

2つ目の違いは、SwiftUIがModifiedContentを使用してデータを構築する方法に関係しています。以前、このコードをお見せしました。
Button("Hello World") {
    print(type(of: self.body))
}
.frame(width: 200, height: 200)
.background(.red)

これにより、シンプルなボタンが作成され、その正確なSwift型が出力され、ModifiedContentのインスタンスがいくつか含まれる長い出力が表示されます。

補足
この長い出力が実際のViewです。それをsome Viewという名前で隠蔽しています。
コンパイラーは実際の長い名前は把握しています。

Viewプロトコルには関連型が付随しており、これはSwiftにおける「View」というだけでは意味をなさない、つまりそれがどのような種類のビューであるかを正確に指定する必要がある、ということを示しています。
これは実質的に抜け穴のようなもので、Swiftでは「この変数は配列です」と直接記述することはできず、代わりに「この変数は文字列配列です」のように配列の内容を明示的に指定する必要があるのと同様です。

したがって、次のようなビューを作成することは許可されていません。
struct ContentView: View {
    var body: View {
        Text("Hello, world!")
    }
}
このようなビューを作成することは完全に合法です。
struct ContentView: View {
    var body: Text {
        Text("Hello, world!")
    }
}
Viewを返すのは意味がありません。なぜなら、Swiftはビューの中身を知りたいからです。ビューには埋めなければならない大きな穴があります。一方、Textを返すのは問題ありません。なぜなら、穴は埋められているので、Swiftはビューが何であるかを知っているからです。

それでは、先ほどのコードに戻りましょう。
Button("Hello World") {
    print(type(of: self.body))
}
.frame(width: 200, height: 200)
.background(.red)

body プロパティからそれらのいずれかを返したい場合、何を書けばよいでしょうか?
使用する ModifiedContent 構造体の正確な組み合わせを突き止めようとすることもできますが、それは非常に面倒な作業であり、実際には、それはすべて SwiftUI の内部的な処理なので、気にする必要はありません。

「some View」を使うことで、「これはボタンやテキストなどのビューになりますが、具体的に何であるかは指定しません」という指定が可能です。
つまり、View の持つ空白は実際のビューオブジェクトによって埋められますが、正確な長い型を記述する必要はありません。

少し複雑になる点が2つあります。
  1. VStackはどのように動作するのでしょうか?Viewプロトコルに準拠していますが、内部に様々な種類のものを含めることができる場合、「どのようなコンテンツが含まれているのか?」という疑問をどのように解消するのでしょうか?
  2. ボディプロパティから2つのビューをStackでラップせずに直接送信すると、どうなるでしょうか?
まず最初の質問にお答えすると、2つのテキストビューを含むVStackを作成すると、SwiftUIはそれらの2つのビューを格納するためのTupleViewを自動的に作成します。TupleViewは、内部に正確に2つのビューを保持する特殊なタイプのビューです。そのため、VStackは「これはどのような種類のビューですか?」という質問に対して、「2つのテキストビューを含むTupleViewです」という回答を返します。
VStackの中に3つのテキストビューがある場合はどうでしょうか?
その場合、3つのビューを含むTupleViewになります。あるいは4つ、8つ、10個でも構いません。TupleViewはどんどん拡張していくのです。

2つ目の質問についてですが、Swiftはbodyプロパティに@ViewBuilderという特別な属性を暗黙的に適用します。
これにより、複数のビューがTupleViewコンテナの1つに暗黙的にラップされるため、複数のビューを送信しているように見えても、実際には1つのTupleViewに結合されます。

この動作は魔法ではありません。
View プロトコルを右クリックして「定義へジャンプ」を選択すると、body プロパティの要件が表示され、@ViewBuilder 属性が付与されていることも確認できます。
@ViewBuilder @MainActor var body: Self.Body { get }
もちろん、スタックなしで複数のビューが戻る場合、SwiftUIがどのように解釈するかはどこにも具体的に定義されていませんが、後ほど説明するように、これは実際には役立ちます。

補足
XcodeでViewを右クリックして、Jump to Definitionを選択すると、以下のようになります。


6. Conditional modifiers

特定の条件が満たされた場合にのみ適用される修飾子が必要になることはよくありますが、SwiftUI では、それを実現する最も簡単な方法は三項条件演算子を使用することです。

念のためおさらいしておくと、三項演算子を使うには、まず条件を記述し、次に疑問符と条件が真の場合に使うべきものを記述し、最後にコロンと条件が偽の場合に使うべきものを記述します。この順序をよく忘れてしまう場合は、スコット・ミショーの便利な覚え方を思い出してください。「何を検証したいのか、真か偽か、略して「WTF」」です。
例えば、trueまたはfalseのいずれかの値をとるプロパティがあれば、それを使ってボタンのフォアグラウンドスタイルを次のように制御できます

struct ContentView: View {
    @State private var useRedText = false

    var body: some View {
        Button("Hello World") {
            // flip the Boolean between true and false
            useRedText.toggle()            
        }
        .foregroundStyle(useRedText ? .red : .blue)
    }
}

つまり、useRedTextがtrueの場合、修飾子は実質的に.foregroundStyle(.red)を読み取り、falseの場合は.foregroundStyle(.blue)になります。SwiftUIは@Stateプロパティの変更を監視し、bodyプロパティを再呼び出しするため、そのプロパティが変更されるたびに色が即座に更新されます。

状態に基づいて異なるビューを返すために通常のif条件を使用することはよくありますが、これは実際にはSwiftUIにとってより多くの処理を引き起こします。異なる色で使用されている1つのボタンを見るのではなく、2つの異なるボタンビューを見るようになり、ブール条件を切り替えると、既存の色を変更するのではなく、一方を破棄してもう一方を作成します。
つまり、このようなコードは見た目は同じように見えるかもしれませんが、実際には効率が悪いのです。
var body: some View {
    if useRedText {
        Button("Hello World") {
            useRedText.toggle()
        }
        .foregroundStyle(.red)
    } else {
        Button("Hello World") {
            useRedText.toggle()
        }
        .foregroundStyle(.blue)
    }
}

if文の使用が避けられない場合もありますが、可能な限り三項演算子を使用することをお勧めします。

補足
SwiftUIは@Stateのプロパティが変わったときに、全てを書き直すわけではなく、差分を検知して変わったところだけを書き直しているようです。
三項演算子であれば同じボタンの属性が変わるだけです。
if文を使うと実態が異なる2つのボタンのどちらかを再生成することになります。

7. Environment modifiers

コンテナには多くの修飾子を適用できるため、同じ修飾子を複数のビューに同時に適用することが可能です。

例えば、VStack内に4つのテキストビューがあり、それらすべてに同じフォント修飾子を適用したい場合、VStackに直接修飾子を適用することで、その変更を4つのテキストビューすべてに適用できます。
VStack {
    Text("Gryffindor")
    Text("Hufflepuff")
    Text("Ravenclaw")
    Text("Slytherin")
}
.font(.title)
これは環境修飾子と呼ばれ、ビューに適用される通常の修飾子とは異なります。

コーディングの観点から見ると、これらの修飾子は通常の修飾子と全く同じように使用されます。ただし、子ビューのいずれかが同じ修飾子をオーバーライドした場合、子ビューのバージョンが優先されるため、動作は微妙に異なります。

例として、タイトルフォントを使用した4つのテキストビューを示しますが、そのうち1つはタイトルが大きくなっています。
VStack {
    Text("Gryffindor")
        .font(.largeTitle)
    Text("Hufflepuff")
    Text("Ravenclaw")
    Text("Slytherin")
}
.font(.title)
そこでは、font() は環境修飾子であり、グリフィンドールのテキスト ビューはそれをカスタム フォントで上書きできることを意味します。

しかし、これはVStackにぼかし効果を適用した後、テキストビューの1つでぼかしを無効にしようとします。
VStack {
    Text("Gryffindor")
        .blur(radius: 0)
    Text("Hufflepuff")
    Text("Ravenclaw")
    Text("Slytherin")
}
.blur(radius: 5)
それは同じようには機能しません。blur() は通常の修飾子なので、子ビューに適用されたぼかしは VStack のぼかしを置き換えるのではなく、追加されます

私の知る限り、どの修飾子が環境修飾子で、どの修飾子が通常の修飾子なのかを事前に知る方法は、各修飾子の個別のドキュメントを読んで、そこに記載されていることを期待する以外にはありません。とはいえ、ないよりはあった方が良いでしょう。一つの修飾子をあらゆる場所に適用できる方が、同じものを複数の場所にコピー&ペーストするよりもずっと便利です。

補足
通常の修飾子は、効果が積み重なります。
環境修飾子は、子ビューが親ビューを上書きします。
ただし上記のようにどの修飾子が通常の修飾子か環境修飾子かを事前に知ることはできません。

8. Views as properties

SwiftUIで複雑なビュー階層を簡単に扱う方法はたくさんありますが、その1つはプロパティを使うことです。つまり、ビューを独自のビューのプロパティとして作成し、そのプロパティをレイアウト内で使用します。

例えば、次のようなテキストビューを2つのプロパティとして作成し、それらをVStack内で使用することができます。
struct ContentView: View {
    let motto1 = Text("Draco dormiens")
    let motto2 = Text("nunquam titillandus")

    var body: some View {
        VStack {
            motto1
            motto2
        }
    }
}
次のように、プロパティを使用する際に、修飾子を直接適用することもできます。
VStack {
    motto1
        .foregroundStyle(.red)
    motto2
        .foregroundStyle(.blue)
}
ビューをプロパティとして作成することは、bodyコードをより分かりやすく保つのに役立ちます。繰り返しを避けるだけでなく、より複雑なコードをbodyプロパティから分離することもできます。

Swiftでは、他の保存プロパティを参照する保存プロパティを作成することはできません。
オブジェクトの作成時に問題が発生するためです。つまり、ローカルプロパティにバインドされたTextFieldを作成しようとすると問題が発生します。
ただし、必要に応じて以下のように計算プロパティを作成することもできます。
var motto1: some View {
    Text("Draco dormiens")
}

補足
Swiftでは、他の保存プロパティを参照する保存プロパティを作成することはできません。
なんか意味わからんですね。
保存プロパティはイニシャライザで全て初期化するまで使えません。
var firstName = "Tom"
var greeting = "Hello, " + firstName // ← エラー!

firstNameは初期化していますが、全てのプロパティを初期化するまでは、使えないということです。

これは、複雑なビューをより小さなチャンクに分割するのに最適な方法であることが多いですが、注意が必要です。body プロパティとは異なり、Swift はここで @ViewBuilder 属性を自動的に適用しないため、複数のビューを返す場合は 3 つのオプションがあります。

まず、このように積み重ねることができます。
var spells: some View {
    VStack {
        Text("Lumos")
        Text("Obliviate")
    }
}
それらを特にスタック状に整理したくない場合は、グループを返すこともできます。
この場合、ビューの配置は、コードの他の場所でビューがどのように使用されているかによって決まります。
var spells: some View {
    Group {
        Text("Lumos")
        Text("Obliviate")
    }
}
3つ目の方法は、次のように@ViewBuilder属性を自分で追加することです。
@ViewBuilder var spells: some View {
    Text("Lumos")
    Text("Obliviate")
}

中でも私は@ViewBuilderを好んで使います。なぜなら、これはbodyの動作を模倣しているからです。しかし、プロパティに多くの機能を詰め込んでいるのを見ると、警戒してしまいます。それは通常、ビューが少し複雑になりすぎていて、分割する必要がある兆候だからです。さて、次はそれについて取り上げましょう…

9. View composition

SwiftUIでは、複雑なビューを小さなビューに分割しても、パフォーマンスへの影響はほとんどありません。つまり、大きなビューを複数の小さなビューに分割すれば、SwiftUIがそれらを自動的に再構成してくれるのです。

例えば、このビューではテキストビューのスタイル設定に特別な方法を採用しています。
大きなフォント、パディング、前景色と背景色、そしてカプセル型の形状などです。
struct ContentView: View {
    var body: some View {
        VStack(spacing: 10) {
            Text("First")
                .font(.largeTitle)
                .padding()
                .foregroundStyle(.white)
                .background(.blue)
                .clipShape(.capsule)

            Text("Second")
                .font(.largeTitle)
                .padding()
                .foregroundStyle(.white)
                .background(.blue)
                .clipShape(.capsule)
        }
    }
}

これら2つのテキストビューはテキスト以外は全く同じなので、次のように新しいカスタムビューにまとめることができます。
struct CapsuleText: View {
    var text: String

    var body: some View {
        Text(text)
            .font(.largeTitle)
            .padding()
            .foregroundStyle(.white)
            .background(.blue)
            .clipShape(.capsule)
    }
}

そして、そのCapsuleTextビューを元のビュー内で次のように使用できます。
struct ContentView: View {
    var body: some View {
        VStack(spacing: 10) {
            CapsuleText(text: "First")
            CapsuleText(text: "Second")
        }
    }
}

もちろん、一部の修飾子をビューに保存し、使用時に他の修飾子をカスタマイズすることもできます。たとえば、CapsuleText から foregroundStyle() を削除した場合、次のようにそのビューのインスタンスを作成する際にカスタムカラーを適用できます。
VStack(spacing: 10) {
    CapsuleText(text: "First")
        .foregroundStyle(.white)
    CapsuleText(text: "Second")
        .foregroundStyle(.yellow)
}

パフォーマンスの問題については心配する必要はありません。このようにSwiftUIのビューを分割することは非常に効率的です。

補足
説明が下手くそでわかりずらいので、
CapsuleTextの中で.foregroundStyle(.white)と定義しています。
それを使う側で
CapsuleText(text: "Second")
        .foregroundStyle(.yellow)
としても上書きできません。



CapsuleTextの中の.foregroundStyle(.white)をコメントアウトすると、有効になります。


10. Custom modifiers

SwiftUIには、font()、background()、clipShape()といった組み込みの修飾子が多数用意されています。しかし、特定の動作をするカスタム修飾子を作成することも可能です。

カスタム修飾子を作成するには、ViewModifierプロトコルに準拠する新しい構造体を作成します。この構造体には、処理対象となるコンテンツを受け取り、some Viewを返すbodyというメソッドが必要であるという要件が1つだけあります。

例えば、アプリ内のすべてのタイトルに特定のスタイルを適用したい場合、まず、目的の動作を実現するカスタムのViewModifier構造体を作成する必要があります。
struct Title: ViewModifier {
    func body(content: Content) -> some View {
        content
            .font(.largeTitle)
            .foregroundStyle(.white)
            .padding()
            .background(.blue)
            .clipShape(.rect(cornerRadius: 10))
    }
}

これで、modifier() 修飾子と一緒に使用できます。そうです、「modifier」という名前の修飾子ですが、次のように、あらゆる種類の修飾子をビューに適用できます。
Text("Hello World")
    .modifier(Title())

カスタム修飾子を扱う場合、View に拡張機能を作成して使いやすくするのが賢明です。たとえば、Title 修飾子を次のような拡張機能でラップすることができます。
extension View {
    func titleStyle() -> some View {
        modifier(Title())
    }
}

これで、修飾子を次のように使用できるようになりました。
Text("Hello World")
    .titleStyle()

カスタム修飾子は、既存の修飾子を適用するだけでなく、必要に応じて新しいビュー構造を作成することもできます。修飾子は既存のオブジェクトを変更するのではなく、新しいオブジェクトを返すため、ビューをスタックに埋め込み、さらに別のビューを追加する修飾子を作成できます。
struct Watermark: ViewModifier {
    var text: String

    func body(content: Content) -> some View {
        ZStack(alignment: .bottomTrailing) {
            content
            Text(text)
                .font(.caption)
                .foregroundStyle(.white)
                .padding(5)
                .background(.black)
        }
    }
}

extension View {
    func watermarked(with text: String) -> some View {
        modifier(Watermark(text: text))
    }
}

これで、次のような透かしを任意のビューに追加できるようになりました。
Color.blue
    .frame(width: 300, height: 200)
    .watermarked(with: "Hacking with Swift")
ヒント: Viewに新しいメソッドを追加するのと、カスタムビュー修飾子を追加するのとではどちらが良いのか、という疑問がよく寄せられますが、主な理由は1つあります。
カスタムビュー修飾子は独自の保存プロパティを持つことができますが、Viewの拡張機能はそれができません。


これはかなりの学習量ですが、さらに学びたいという方のために、ボーナスチュートリアルを1つ用意しました。これは任意なので、時間がある場合にのみ完了してください。カスタムコンテナです。


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

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