SwiftUIアーキテクチャ
このスキルを使用するタイミング
以下のような場合にこのスキルを使用してください:
- SwiftUIのビューファイルにロジックが含まれており、それを抽出したい場合
- MVVM、TCA、バニラSwiftUIパターン、またはコーディネーターの間で選択する場合
- 関心事を分離するためにビューをリファクタリングする場合
- SwiftUIのコードをテスト可能にする場合
- 「このコードはどこに置くべき?」と質問する場合
- どのプロパティラッパー(@State、@Environment、@Bindable)を使用するかを決定する場合
- チーム開発のためにSwiftUIコードベースを整理する場合
プロンプト例
| 聞くかもしれないこと | このスキルが役立つ理由 |
|---|---|
| 「モデルビューファイルにロジック関連のコードがかなりあるんだけど、どうやって抽出すればいい?」 | ロジックの所属先を決定するための決定木を含むリファクタリングワークフローを提供 |
| 「MVVM、TCA、それともAppleのバニラパターンを使うべき?」 | アプリの複雑さ、チーム規模、テスト容易性のニーズに基づく判断基準 |
| 「SwiftUIのコードをテスト可能にするには?」 | SwiftUIのインポートを必要としないテストを可能にする分離パターンを提示 |
| 「フォーマッターや計算はどこに置くべき?」 | アンチパターンセクションでビュー本文内にロジックを置かないように防止 |
| 「どのプロパティラッパーを使えばいい?」 | @State、@Environment、@Bindable、またはプレーンなプロパティのための決定木 |
クイックアーキテクチャ決定木
何がアーキテクチャの選択を動機づけていますか?
│
├─ 新規プロジェクト、小規模/中規模アプリ、Appleのパターンを使いたい?
│ └─ Appleのネイティブパターンを使用(パート1)
│ - @Observableモデルでビジネスロジック
│ - 非同期境界にはState-as-Bridge
│ - プロパティラッパー決定木
│
├─ UIKitでMVVMに慣れている?
│ └─ MVVMパターンを使用(パート2)
│ - ViewModelをプレゼンテーションアダプターとして
│ - 明確なView/ViewModel/Modelの分離
│ - @Observableとの相性が良い
│
├─ 複雑なアプリ、厳密なテスト容易性、チームの一貫性が必要?
│ └─ TCAを検討(パート3)
│ - State/Action/Reducer/Storeアーキテクチャ
│ - 優れたテストのしやすさ
│ - 学習曲線とボイラープレートのトレードオフ
│
└─ 複雑なナビゲーション、ディープリンク、複数のエントリーポイントがある?
└─ コーディネーターパターンを追加(パート4)
- 上記のいずれかと組み合わせることが可能
- ナビゲーションロジックをビューから抽出
- NavigationPath + Coordinatorオブジェクト
パート1:Appleのネイティブパターン(iOS 26+)
中核となる原則
「データモデルは、データとそのデータを操作するビューとの間の分離を提供します。この分離はモジュール性を促進し、テスト容易性を向上させ、アプリの動作について推論しやすくするのに役立ちます。」 — Apple Developer Documentation
AppleのモダンなSwiftUIパターン(WWDC 2023-2025)は以下を中心としています:
- @Observable データモデル用(ObservableObjectを置き換え)
- State-as-Bridge 非同期境界用(WWDC 2025)
- 3つのプロパティラッパー:@State、@Environment、@Bindable
- アニメーションのための同期UI更新
State-as-Bridgeパターン
問題
非同期関数はアニメーションを壊す可能性のある中断ポイントを生成します:
// ❌ 問題あり:アニメーションがフレームの期限に間に合わない可能性がある
struct ColorExtractorView: View {
@State private var isLoading = false
var body: some View {
Button("色を抽出") {
Task {
isLoading = true // 同期 ✅
await extractColors() // ⚠️ 中断ポイント!
isLoading = false // ❌ 遅すぎる可能性がある
}
}
.scaleEffect(isLoading ? 1.5 : 1.0) // ⚠️ アニメーションのタイミングが不確か
}
}
解決策:Stateをブリッジとして使用する
「時間に敏感な変更を必要とするUIコードと、長時間実行される非同期ロジックとの間の境界を見つけてください。」
// ✅ 正しい:StateがUIと非同期コードをブリッジする
@Observable
class ColorExtractor {
var isLoading = false
var colors: [Color] = []
func extract(from image: UIImage) async {
// このメソッドは非同期であり、モデル内に存在できる
let extracted = await heavyComputation(image)
// UI更新のための同期ミューテーション
self.colors = extracted
}
}
struct ColorExtractorView: View {
let extractor: ColorExtractor
var body: some View {
Button("色を抽出") {
// アニメーションのための同期状態変更
withAnimation {
extractor.isLoading = true
}
// 非同期処理を開始
Task {
await extractor.extract(from: currentImage)
// アニメーションのための同期状態変更
withAnimation {
extractor.isLoading = false
}
}
}
.scaleEffect(extractor.isLoading ? 1.5 : 1.0)
}
}
利点:
- UIロジックは同期したまま(アニメーションが正しく動作する)
- 非同期コードはモデル内に存在する(SwiftUIなしでテスト可能)
- 時間に敏感なUIと長時間実行処理との間に明確な境界
プロパティラッパー決定木
答えなければならないのはたった3つの質問です:
どのプロパティラッパーを使うべきか?
│
├─ このモデルはVIEW ITSELFのSTATEである必要があるか?
│ └─ YES → @Stateを使用
│ 例:フォーム入力、ローカルトグル、シート表示
│ ライフタイム:ビューのライフタイムによって管理される
│
├─ このモデルはGLOBAL ENVIRONMENTの一部である必要があるか?
│ └─ YES → @Environmentを使用
│ 例:ユーザーアカウント、アプリ設定、依存性注入
│ ライフタイム:アプリ/シーンレベルで生存
│
├─ このモデルはBINDINGSだけが必要か?
│ └─ YES → @Bindableを使用
│ 例:親から渡されたモデルを編集する
│ 軽量:バインドのための$構文のみを有効にする
│
└─ 上記のいずれでもない?
└─ プレーンプロパティとして使用
例:不変データ、親が所有するモデル
ラッパー不要:@Observableが監視を処理する
例
// ✅ @State — ビューがモデルを所有する
struct DonutEditor: View {
@State private var donutToAdd = Donut() // ビュー自身の状態
var body: some View {
TextField("名前", text: $donutToAdd.name)
}
}
// ✅ @Environment — アプリ全体のモデル
struct MenuView: View {
@Environment(Account.self) private var account // グローバル
var body: some View {
Text("ようこそ、\(account.userName)")
}
}
// ✅ @Bindable — 親が所有するモデルへのバインディングが必要
struct DonutRow: View {
@Bindable var donut: Donut // 親が所有
var body: some View {
TextField("名前", text: $donut.name) // バインディングが必要
}
}
// ✅ プレーンプロパティ — 読み取りのみ
struct DonutRow: View {
let donut: Donut // 親が所有、バインディング不要
var body: some View {
Text(donut.name) // 読み取りのみ
}
}
@Observable モデルパターン
UI更新をトリガーする必要があるビジネスロジックには@Observableを使用します:
// ✅ ビジネスロジックを持つドメインモデル
@Observable
class FoodTruckModel {
var orders: [Order] = []
var donuts = Donut.all
var orderCount: Int {
orders.count // 計算プロパティは自動的に動作する
}
func addDonut() {
donuts.append(Donut())
}
}
// ✅ ビューはアクセスされたプロパティを自動的に追跡する
struct DonutMenu: View {
let model: FoodTruckModel // ラッパー不要!
var body: some View {
List {
Section("ドーナツ") {
ForEach(model.donuts) { donut in
Text(donut.name) // model.donutsを追跡
}
Button("追加") {
model.addDonut()
}
}
Section("注文") {
Text("件数: \(model.orderCount)") // model.ordersを追跡
}
}
}
}
仕組み(WWDC 2023/10149):
- SwiftUIは
bodyの実行中にどのプロパティにアクセスされたかを追跡します - 変更された場合、それらのプロパティのみがビュー更新をトリガーします
- 粒度の細かい依存関係追跡 = より良いパフォーマンス
ViewModelアダプターパターン
フィルタリング、ソート、またはビュー固有のロジックが必要な場合に、ViewModelをプレゼンテーションアダプターとして使用します:
// ✅ プレゼンテーションアダプターとしてのViewModel
@Observable
class PetStoreViewModel {
let petStore: PetStore // ドメインモデル
var searchText: String = ""
// ビュー固有の計算プロパティ
var filteredPets: [Pet] {
guard !searchText.isEmpty else { return petStore.myPets }
return petStore.myPets.filter { $0.name.contains(searchText) }
}
}
struct PetListView: View {
@Bindable var viewModel: PetStoreViewModel
var body: some View {
List {
ForEach(viewModel.filteredPets) { pet in
PetRowView(pet: pet)
}
}
.searchable(text: $viewModel.searchText)
}
}
ViewModelアダプターを使用すべき場合:
- 表示のためのフィルタリング、ソート、グループ化
- 表示用のフォーマット(ただし、重い計算は不可)
- ドメインモデルに属さないビュー固有の状態
- ドメインモデルとSwiftUIの慣習との橋渡し
ViewModelを使用すべきでない場合:
- モデルデータを表示するだけのシンプルなビュー
- ドメインモデルに属するロジック
- 「パターンの純粋さ」のための過剰な抽出
パート2:MVVMパターン
MVVMを使用すべき場合
MVVM(Model-View-ViewModel)は以下の場合に適しています:
✅ UIKitから慣れている — チームのオンボーディングが容易 ✅ 明示的なView/ViewModelの分離が必要 — 明確な契約 ✅ 複雑なプレゼンテーションロジックがある — 複数のフィルタリング/ソート操作 ✅ UIKitから移行中 — なじみのあるメンタルモデル
❌ MVVMを避けるべき場合:
- ビューがシンプルである(データを表示するだけ)
- 新規にSwiftUIを始める場合(Appleのパターンの方がシンプル)
- 不必要な抽象化レイヤーを作成している場合
SwiftUIのためのMVVM構造
// Model — ドメインデータとビジネスロジック
struct Pet: Identifiable {
let id: UUID
var name: String
var kind: Kind
var trick: String
var hasAward: Bool = false
mutating func giveAward() {
hasAward = true
}
}
// ViewModel — プレゼンテーションロジック
@Observable
class PetListViewModel {
private let petStore: PetStore
var pets: [Pet] { petStore.myPets }
var searchText: String = ""
var selectedSort: SortOption = .name
var filteredSortedPets: [Pet] {
let filtered = pets.filter { pet in
searchText.isEmpty || pet.name.contains(searchText)
}
return filtered.sorted { lhs, rhs in
switch selectedSort {
case .name: lhs.name < rhs.name
case .kind: lhs.kind.rawValue < rhs.kind.rawValue
}
}
}
init(petStore: PetStore) {
self.petStore = petStore
}
func awardPet(_ pet: Pet) {
petStore.awardPet(pet.id)
}
}
// View — UIのみ
struct PetListView: View {
@Bindable var viewModel: PetListViewModel
var body: some View {
List {
ForEach(viewModel.filteredSortedPets) { pet in
PetRow(pet: pet) {
viewModel.awardPet(pet)
}
}
}
.searchable(text: $viewModel.searchText)
}
}
SwiftUIにおける一般的なMVVMの間違い
❌ 間違い1:ViewとViewModelで@Observableを重複させる
// ❌ @State + @Observable は冗長 — @Stateは独自のストレージを作成する
struct MyView: View {
@State private var viewModel = MyViewModel() // ❌ 冗長なラッパー
}
// ✅ @Observableを直接渡す — ビューがライフサイクルを所有する場合のみ@Stateを使用
struct MyView: View {
let viewModel: MyViewModel // ✅ またはビューが作成する場合は@State
}
❌ 間違い2:神ViewModel
// ❌ これはやらないでください
@Observable
class AppViewModel {
// 設定
var isDarkMode = false
var notificationsEnabled = true
// ユーザー
var userName = ""
var userEmail = ""
// コンテンツ
var posts: [Post] = []
var comments: [Comment] = []
// ... さらに50のプロパティ
}
// ✅ 正しい:関心事を分離する
@Observable
class SettingsViewModel {
var isDarkMode = false
var notificationsEnabled = true
}
@Observable
class UserProfileViewModel {
var user: User
}
@Observable
class FeedViewModel {
var posts: [Post] = []
}
❌ 間違い3:ViewModel内のビジネスロジック
// ❌ ビジネスルールはModelに属し、ViewModelには属さない
@Observable class OrderViewModel {
func calculateDiscount(for order: Order) -> Double { /* ... */ } // ❌ ビジネスロジック
}
// ✅ Modelがビジネスロジックを所有し、ViewModelは表示用にフォーマットするだけ
struct Order {
func calculateDiscount() -> Double { /* ビジネスルール */ }
}
@Observable class OrderViewModel {
let order: Order
var displayDiscount: String {
"$\(order.calculateDiscount(), specifier: "%.2f")" // ✅ フォーマットのみ
}
}
パート3:TCA(コンポーザブルアーキテクチャ)
TCAを検討すべき場合
TCAはPoint-Free社のサードパーティアーキテクチャです。以下の場合に検討してください:
✅ 厳格なテスト容易性が重要な場合 — TestStoreによりテストが決定論的になる ✅ 大規模チームで一貫性が必要な場合 — 厳格なパターンがばらつきを減らす ✅ 複雑な状態管理が必要な場合 — 副作用、依存関係、コンポジション ✅ Reduxのようなパターンを重視する場合 — 単方向データフロー
❌ TCAを避けるべき場合:
- 小規模アプリまたはプロトタイプ(オーバーヘッドが大きすぎる)
- チームが関数型プログラミングに不慣れ
- 迅速な反復が必要(ボイラープレートが開発を遅らせる)
- 最小限の依存関係を望む
TCAの中核概念
TCAには4つの構成要素があります — State(データ)、Action(イベント)、Reducer(状態の進化)、Store(ランタイムエンジン)。以下にそれらを単一の機能で示します:
// STATE — 機能に必要なデータ
@ObservableState
struct CounterFeature {
var count = 0
var fact: String?
var isLoading = false
}
// ACTION — 可能なすべてのイベント
enum Action {
case incrementButtonTapped
case decrementButtonTapped
case factButtonTapped
case factResponse(String)
}
// REDUCER — アクションに応じて状態がどのように進化するか
struct CounterFeature: Reducer {
var body: some ReducerOf<Self> {
Reduce { state, action in
switch action {
case .incrementButtonTapped:
state.count += 1
return .none
case .decrementButtonTapped:
state.count -= 1
return .none
case .factButtonTapped:
state.isLoading = true
return .run { send in
let fact = await getFact(state.count)
await send(.factResponse(fact))
}
case let .factResponse(fact):
state.fact = fact
state.isLoading = false
return .none
}
}
}
}
テスト容易性:
// 完全に決定論的なテスト
@MainActor
func testIncrement() async {
let store = TestStore(initialState: CounterFeature()) {
CounterFeature()
}
await store.send(.incrementButtonTapped) {
$0.count = 1
}
}
TCAのトレードオフ
| 利点 | 欠点 |
|---|---|
| 決定論的テスト | ボイラープレート量が多い |
| 厳格な状態管理 | 学習曲線が急 |
| 依存性注入の容易さ | プロトタイプが遅くなる |
| チームの一貫性 | SwiftUIのシンプルさを弱める |
パート4:コーディネーターパターン
コーディネーターとは何か?
コーディネーターはビューからナビゲーションロジックを抽出するオブジェクトです。これは以下のような場合に役立ちます:
- 複雑なフロー(例:サインアップウィザード)
- ディープリンク
- 複数のエントリーポイント(例:Apple Payから、プッシュ通知から)
- 画面遷移の追跡(分析)
コーディネーターの実装
// 各画面のケース
enum Route: Hashable {
case petList
case petDetail(Pet.ID)
case addPet
}
// ナビゲーションロジックを処理するコーディネーター
@Observable
class PetCoordinator {
var path = NavigationPath()
func showPetList() {
path.append(Route.petList)
}
func showPetDetail(_ petID: Pet.ID) {
path.append(Route.petDetail(petID))
}
func showAddPet() {
path.append(Route.addPet)
}
func popToRoot() {
path.removeLast(path.count)
}
}
// アプリ構造
struct AppView: View {
@State private var coordinator = PetCoordinator()
var body: some View {
NavigationStack(path: $coordinator.path) {
PetListView(coordinator: coordinator)
.navigationDestination(for: Route.self) { route in
switch route {
case .petList:
PetListView(coordinator: coordinator)
case .petDetail(let petID):
PetDetailView(petID: petID, coordinator: coordinator)
case .addPet:
AddPetView(coordinator: coordinator)
}
}
}
}
}
コーディネーターアンチパターン
❌ ナビゲーションコードの重複
// ❌ すべてのビューにナビゲーションロジックを書かない
struct PetListView: View {
@State private var showDetail = false
@State private var selectedPetID: Pet.ID?
var body: some View {
List(pets) { pet in
Button(pet.name) {
selectedPetID = pet.id
showDetail = true
}
}
.navigationDestination(isPresented: $showDetail) {
if let id = selectedPetID {
PetDetailView(petID: id)
}
}
}
}
// ✅ ナビゲーションロジックをコーディネーターに委譲
struct PetListView: View {
let coordinator: PetCoordinator
var body: some View {
List(pets) { pet in
Button(pet.name) {
coordinator.showPetDetail(pet.id) // ✅ 委譲
}
}
}
}
❌ 単一の巨大なコーディネーター
// ❌ すべてを管理するコーディネーター
@Observable class AppCoordinator {
var path = NavigationPath()
// アプリ全体のすべてのルートをここに…
}
// ✅ 機能ごとに分離されたコーディネーター
@Observable class AuthCoordinator { /* ... */ }
@Observable class PetCoordinator { /* ... */ }
@Observable class SettingsCoordinator { /* ... */ }
リファクタリングワークフロー
ロジックを抽出するためのステップバイステップ
ステップ1:ロジックがビュー内にあるかどうかを特定する
// ⚠️ リファクタリングが必要:ビュー内のロジック
struct PetListView: View {
@State private var pets: [Pet] = []
@State private var searchText = ""
var body: some View {
List {
// ❌ フィルタリングロジックがビュー内にある
ForEach(pets.filter { $0.name.contains(searchText) }) { pet in
PetRow(pet: pet)
}
}
.searchable(text: $searchText)
}
}
// ✅ リファクタリング後:ロジックを@Observableモデルに抽出
@Observable
class PetStore {
var pets: [Pet] = []
var searchText = ""
var filteredPets: [Pet] {
guard !searchText.isEmpty else { return pets }
return pets.filter { $0.name.contains(searchText) }
}
}
struct PetListView: View {
@State private var store = PetStore()
var body: some View {
List {
ForEach(store.filteredPets) { pet in
PetRow(pet: pet)
}
}
.searchable(text: $store.searchText)
}
}
ステップ2:ロジックの種類を決定する
| ロジックの種類 | 抽出先 |
|---|---|
| 表示データ(フィルタリング、フォーマット) | ViewModelアダプター |
| ビジネスルール(計算、検証) | @Observableモデル |
| 非同期操作(ネットワーク、データベース) | サービス/リポジトリ層 |
| ナビゲーション(画面遷移) | コーディネーター |
ステップ3:境界を設ける
- 問題のロジックを含むメソッド/プロパティを特定する
- 新しい@Observableクラスまたは構造体を作成する
- ロジックを新しいタイプに移動する
- ビューで新しいタイプをインスタンス化し、ロジックを使用するように更新する
- ビューがデータアクセスにプロパティラッパーを正しく使用していることを確認する
共通アンチパターン
❌ View Body内のロジック
// ❌ ビュー本文内での計算やフォーマット
struct DonutView: View {
let donut: Donut
var body: some View {
VStack {
// ❌ ビュー内のフォーマッティング
Text("$\(donut.price, specifier: "%.2f")")
// ❌ ビュー内のスタイル適用
Text(donut.name).font(donut.isPremium ? .title : .body)
}
}
}
// ✅ 計算プロパティまたはモデルに委譲
extension Donut {
var formattedPrice: String {
"$\(price, specifier: "%.2f")"
}
var displayFont: Font {
isPremium ? .title : .body
}
}
❌ @Stateでの過剰なラッピング
// ❌ 不必要な@State
struct MyView: View {
@State private var user = User() // ユーザーが頻繁に変わらない場合
// ✅ 不変データにはプレーンプロパティ
struct MyView: View {
let user: User // 親から渡される
❌ 過剰なViewModel化
// ❌ 単純すぎるViewModel
@Observable
class DonutViewModel {
let donut: Donut // プレゼンテーションロジックなし
}
// ✅ 代わりにプレーンなモデルを使用
struct DonutView: View {
let donut: Donut
テスト戦略
SwiftUIなしでテスト可能にする
// ✅ テスト可能な@Observableモデル
@Observable
class PetStore {
var pets: [Pet] = []
func addPet(_ pet: Pet) {
pets.append(pet)
}
}
// テストはSwiftUIをインポートしない
import Testing
@Test func addPet() {
let store = PetStore()
let pet = Pet(name: "マックス")
store.addPet(pet)
#expect(store.pets.count == 1)
#expect(store.pets.first?.name == "マックス")
}
依存関係の注入
// ✅ テスト可能なサービス層
protocol PetService {
func fetchPets() async throws -> [Pet]
}
@Observable
class PetStore {
private let service: PetService
init(service: PetService = DefaultPetService()) {
self.service = service
}
func loadPets() async {
do {
self.pets = try await service.fetchPets()
} catch {
self.error = error
}
}
}
// テストではモックサービスを使用
struct MockPetService: PetService {
func fetchPets() async throws -> [Pet] {
[Pet(name: "テスト")]
}
}
クイックリファレンス
| パターン | 使用すべき場合 | iOS 26+ 向けの考慮事項 |
|---|---|---|
| Appleネイティブ | デフォルトの選択肢 | @ObservableとState-as-Bridgeを使用 |
| MVVM | UIKitからの移行、複雑なプレゼンテーション | ViewModelはプレゼンテーションアダプターのみ |
| TCA | 厳格なテスト、大規模チーム、複雑な状態 | 学習曲線とボイラープレートを考慮 |
| コーディネーター | 複雑なナビゲーション、ディープリンク | NavigationPathベースの実装 |
ワークフローチェックリスト
- ロジックの種類を特定する(ビジネス、プレゼンテーション、ナビゲーション)
- 適切なアーキテクチャパターンを選択する
- @Observableを使用してモデルを抽出する
- 正しいプロパティラッパー(@State、@Environment、@Bindable)を選択する
- アニメーションのためにState-as-Bridgeを適用する
- 必要な場合にViewModelアダプターを追加する
- コーディネーターにナビゲーションを委譲する
- SwiftUIなしでテストを書く