【Swift】クロージャ(Closure)完全ガイド｜基本構文から応用まで網羅

By /

はい、承知いたしました。
Swiftのクロージャ（Closure）について、基本から応用までを網羅した約5000語の詳細な解説記事を作成します。

【Swift】クロージャ(Closure)完全ガイド｜基本構文から応用まで網羅

はじめに

Swiftは、モダンで安全、そして非常に表現力豊かなプログラミング言語です。その表現力を支える中心的な機能の一つが、今回徹底的に解説する「クロージャ（Closure）」です。

iOSアプリ開発やサーバーサイドSwiftを学び始めると、map, filter といった高階関数、非同期処理の完了ハンドラ、SwiftUIのView定義など、至る所でクロージャに遭遇します。最初は { ( ) -> in ... } という独特の構文に戸惑うかもしれませんが、クロージャをマスターすることは、Swiftプログラミングを次のレベルに引き上げるための必須スキルです。

なぜなら、クロージャは単なる「無名関数」以上の力を持っているからです。

  • コードの簡潔化: 冗長な for ループを、map や filter などの高階関数とクロージャの組み合わせで、宣言的で読みやすいコードに変換できます。
  • 非同期処理の実現: ネットワーク通信や時間のかかる処理の結果を、完了ハンドラ（Completion Handler）という形でエレガントに受け取ることができます。
  • 柔軟なAPI設計: Delegateパターンの代替としてクロージャを用いることで、より疎結合で再利用性の高いコンポーネントを設計できます。
  • メモリ管理の鍵: クロージャは周囲の変数や定数を「キャプチャ」する強力な機能を持つ一方で、メモリリーク（循環参照）の原因にもなり得ます。これを正しく理解し、[weak self] などを使いこなすことが、安定したアプリケーション開発には不可欠です。

この記事では、Swiftのクロージャについて、以下の内容を体系的に、そして深く掘り下げていきます。

  • 第1章: クロージャの基礎 – 「クロージャとは何か？」という根本的な問いから、基本的な構文までを学びます。
  • 第2章: クロージャ構文の簡略化 – Swiftが提供する様々な省略記法を駆使して、クロージャを驚くほど短く書くテクニックを習得します。
  • 第3章: クロージャの強力な機能（応用編） – 値のキャプチャ、循環参照、@escaping, @autoclosure といった、クロージャの真価を発揮するための核心的な概念を解説します。
  • 第4章: 実践！クロージャの活用例 – 高階関数、非同期処理、SwiftUIなど、実際の開発現場でクロージャがどのように使われているかを具体例と共に見ていきます。

この記事を読み終える頃には、あなたはクロージャの構文に自信を持ち、その強力な機能を理解し、実際のコードで自在に使いこなせるようになっているはずです。それでは、Swiftクロージャの奥深い世界へ旅立ちましょう。

第1章: クロージャの基礎

まずは、クロージャの最も基本的な概念と構文から理解を深めていきましょう。

1-1. クロージャとは何か？

Swiftの公式ドキュメントでは、クロージャは「自己完結した機能のコードブロック（self-contained blocks of functionality）」と定義されています。これだけでは少し抽象的かもしれません。

より具体的に言うと、クロージャは以下の3つの特徴を併せ持つオブジェクトです。

  1. 名前を持たない関数（無名関数）: 通常の関数のように func キーワードや関数名を持ちません。コードブロックそのものが実体です。
  2. 変数や定数に代入できる: 作成したクロージャを、Int型やString型のように変数や定数に入れて持ち運ぶことができます。
  3. 関数の引数や戻り値として使える: 関数が別の関数を引数に取ったり、戻り値として返したりすることを可能にします。このような関数を「高階関数（Higher-Order Function）」と呼びます。

そして、最も重要な特徴が「定義されたコンテキスト（文脈）から定数や変数をキャプチャ（捕捉）して保持できること」です。この「キャプチャ」については第3章で詳しく解説しますが、これがクロージャを単なる無名関数以上の存在にしている理由です。

関数との関係

実は、Swiftにおいて関数は、名前を持つ特別なクロージャの一種です。
例えば、以下のグローバル関数とクロージャは、本質的に同じことをしています。

“`swift
// グローバル関数
func add(_ a: Int, _ b: Int) -> Int {
return a + b
}

// クロージャ
let addClosure = { (a: Int, b: Int) -> Int in
return a + b
}

// どちらも同じように呼び出せる
print(add(10, 5)) // 出力: 15
print(addClosure(10, 5)) // 出力: 15
“`

このように、関数はクロージャの特殊なケースと考えることができます。この視点を持つと、Swiftの様々な機能が一貫性を持って設計されていることが見えてきます。

1-2. 基本的な構文 (フル構文)

クロージャの最も完全な形式（フル構文）は、以下のようになります。

swift
{ (引数リスト) -> 戻り値の型 in
// 実行する文
// ...
return 戻り値
}

各パーツを分解してみましょう。

  • { }: 全体を波括弧で囲みます。これがクロージャの本体です。
  • (引数リスト): クロージャが受け取る引数を定義します。通常の関数と同じように (parameterName: Type, ...) と書きます。引数がない場合は () となります。
  • -> 戻り値の型: クロージャが返す値の型を指定します。戻り値がない場合は Void と書くか、-> Void ごと省略できます。
  • in: このキーワードが、引数と戻り値の定義部分と、クロージャの実行本体部分を区切ります。

具体的な例を見てみましょう。

例1: 引数も戻り値もあるクロージャ

“`swift
// 2つの文字列を連結して返すクロージャ
let greeting: (String, String) -> String = { (name: String, message: String) -> String in
return “(message), (name)!”
}

let result = greeting(“Tim”, “Hello”)
print(result) // 出力: Hello, Tim!
“`

この例では、greeting という定数にクロージャを代入しています。: の右側 (String, String) -> String は、このクロージャの「型」を表しています。

例2: 引数のみで戻り値がないクロージャ

“`swift
// 名前をコンソールに出力するだけのクロージャ
let printName: (String) -> Void = { (name: String) in
print(“My name is (name).”)
}

printName(“Sarah”) // 出力: My name is Sarah.
``Voidは「何もない」ことを示す型です。-> Void` は省略可能です。

例3: 引数も戻り値もないクロージャ

“`swift
// 単にメッセージを出力するクロージャ
let sayHello: () -> Void = {
print(“Hello, Closure!”)
}

sayHello() // 出力: Hello, Closure!
``
引数がない場合は()inの前に記述しますが、このケースでは()in` ごと省略することも可能です。

1-3. 型推論の活用

Swiftの強力な型推論機能は、クロージャの記述を大幅に簡潔にしてくれます。コンパイラが文脈からクロージャの型を推論できる場合、引数の型や戻り値の型を省略できます。

先ほどの greeting の例を思い出してください。

swift
// フル構文
let greeting: (String, String) -> String = { (name: String, message: String) -> String in
return "\(message), \(name)!"
}

このコードでは、定数 greeting の型を (String, String) -> String と明示的に指定しています。そのため、コンパイラはクロージャ本体の引数 name と message が String 型であり、戻り値も String 型であることを知っています。したがって、クロージャ内の型定義は省略できます。

swift
// 型推論による省略
let greeting: (String, String) -> String = { (name, message) in
return "\(message), \(name)!"
}

逆もまた然りです。クロージャが関数の引数として渡される場合、コンパイラは関数の定義からクロージャがどのような型であるべきかを推論できます。

sorted メソッドを例に見てみましょう。これは配列の要素を並べ替えるメソッドで、並べ替えのルールをクロージャで受け取ります。

“`swift
let names = [“Chris”, “Alex”, “Ewa”, “Barry”, “Daniella”]

// sorted(by:) メソッドは (String, String) -> Bool という型のクロージャを期待する
// そのため、クロージャ内の型はすべて省略可能
let reversedNames = names.sorted(by: { (s1, s2) -> Bool in
return s1 > s2
})

print(reversedNames)
// 出力: [“Ewa”, “Daniella”, “Chris”, “Barry”, “Alex”]
“`

sorted(by:) の定義から、引数のクロージャは「2つの String を受け取り、Bool を返す」ことが分かっているため、(s1: String, s2: String) -> Bool と書く必要がなく、(s1, s2) in と簡潔に記述できます。

第2章: クロージャ構文の簡略化

Swiftは、クロージャをより短く、より読みやすく書くための様々なシンタックスシュガー（構文糖衣）を提供しています。これらを使いこなすことで、コードは劇的に変化します。

2-1. 単一式クロージャの暗黙的なリターン

クロージャの本体が、値を返す単一の式で構成されている場合、return キーワードを省略できます。

先ほどの sorted の例を再掲します。

swift
// 元のコード
let reversedNames = names.sorted(by: { (s1, s2) in
return s1 > s2 // この行が単一の式
})

return s1 > s2 は単一の式なので、return を省略できます。

swift
// returnを省略
let reversedNames = names.sorted(by: { (s1, s2) in
s1 > s2
})
コードが一行分スッキリしました。これはSwiftUIの body プロパティなどでも頻繁に使われるテクニックです。

2-2. 引数名の省略（Shorthand Argument Names）

Swiftは、クロージャの引数を $0, $1, $2 のような短い名前で自動的に提供します。$0 は最初の引数、$1 は2番目の引数、といった具合です。

この省略記法を使うと、引数リストと in キーワードを両方とも省略できます。

sorted の例をさらに簡略化してみましょう。

swift
// s1 -> $0, s2 -> $1 に置き換える
let reversedNames = names.sorted(by: { $0 > $1 })

(s1, s2) in が完全に消え、{ $0 > $1 } という非常に短い形になりました。これは非常に強力で、高階関数と組み合わせる際に絶大な効果を発揮します。

2-3. 演算子メソッド（Operator Methods）

もしクロージャの処理が、既存の演算子（+, -, >, < など）と完全に一致する場合、その演算子自体を渡すことができます。

String 型の > 演算子は、2つの文字列を受け取り、最初の文字列が2番目の文字列より大きい（辞書順で後にある）場合に true を返す関数として実装されています。これは sorted(by:) が要求する (String, String) -> Bool という型と完全に一致します。

そのため、先ほどのコードはさらに短くできます。

swift
// 演算子メソッドを使用
let reversedNames = names.sorted(by: >)

{ } すら不要になりました。信じられないほど簡潔です。
同様に、数値の配列を昇順にソートする場合は < を使えます。

swift
let numbers = [5, 2, 8, 1, 9]
let sortedNumbers = numbers.sorted(by: <)
print(sortedNumbers) // 出力: [1, 2, 5, 8, 9]

2-4. トレーリングクロージャ（Trailing Closure）

関数の最後の引数がクロージャである場合、そのクロージャを関数の () の外に書くことができます。これを「トレーリングクロージャ（後置クロージャ）」構文と呼びます。

この構文は、コードの可読性を大幅に向上させます。特に関数にクロージャ以外の引数もある場合に効果的です。

sorted(by:) はまさにこのケースに該当します。

“`swift
// 通常の構文
let reversedNames = names.sorted(by: { $0 > $1 })

// トレーリングクロージャ構文
let reversedNamesWithTrailing = names.sorted() { $0 > $1 }
“`

さらに、もしクロージャが関数にとって唯一の引数である場合、() 自体も省略できます。

swift
// 唯一の引数なので () も省略
let reversedNamesFinal = names.sorted { $0 > $1 }

これが、Swiftで一般的に見られる sorted の書き方です。まるで sorted というキーワードに { } のコードブロックが続いているかのように見え、独自の制御構文を定義しているかのような見た目になります。

2-5. 複数のトレーリングクロージャ（Multiple Trailing Closures）

Swift 5.3からは、関数が複数のクロージャを引数に取る場合に、2つ目以降のクロージャもトレーリングクロージャとして記述できるようになりました。

この構文は、特にSwiftUIで複雑なViewを構築する際に多用されます。
例として、アニメーションの完了時に何か処理を行う架空の関数を考えてみましょう。

“`swift
// 架空のViewアニメーション関数
func animate(duration: TimeInterval, animation: () -> Void, completion: () -> Void) {
print(“アニメーション開始（(duration)秒）”)
animation()
print(“アニメーション終了”)
completion()
}

// 従来の呼び出し方（2つ目のクロージャは引数の中）
animate(duration: 0.3, animation: {
print(“フェードイン処理…”)
}, completion: {
print(“完了！”)
})

// 複数のトレーリングクロージャを使った呼び出し方
animate(duration: 0.3) {
// 最初のクロージャ (animation)
print(“フェードイン処理…”)
} completion: {
// 2つ目以降のクロージャ (completion)
// 引数ラベルが必要
print(“完了！”)
}
“`

2つ目以降のトレーリングクロージャには、引数ラベル（この場合は completion:）を付ける必要があることに注意してください。これにより、どのクロージャがどの引数に対応するかが明確になります。この構文は、ドメイン固有言語（DSL）のような、宣言的で読みやすいAPIを設計するのに非常に役立ちます。

第3章: クロージャの強力な機能（応用編）

ここからは、クロージャを単なる構文の簡略化ツールから、強力なプログラミングパラダイムへと昇華させる核心的な機能について解説します。特にメモリ管理に関する「値のキャプチャ」と「循環参照」は、すべてのSwiftデベロッパーが理解すべき最重要トピックです。

3-1. 値のキャプチャ（Capturing Values）

クロージャの最も強力な特徴は、それが定義されたスコープ（文脈）にある定数や変数を「キャプチャ（捕捉）」できることです。キャプチャした値は、たとえ元のスコープが消滅した後でも、クロージャ内で保持され、参照・変更できます。

簡単な例を見てみましょう。

“`swift
func makeIncrementer(forIncrement amount: Int) -> () -> Int {
var runningTotal = 0

let incrementer: () -> Int = {
    // runningTotalとamountをキャプチャしている
    runningTotal += amount
    return runningTotal
}

return incrementer

}

let incrementByTen = makeIncrementer(forIncrement: 10)

print(incrementByTen()) // 出力: 10
print(incrementByTen()) // 出力: 20
print(incrementByTen()) // 出力: 30

let incrementBySeven = makeIncrementer(forIncrement: 7)
print(incrementBySeven()) // 出力: 7
“`

このコードの動きを順に追ってみましょう。

  1. makeIncrementer は amount という引数を取り、() -> Int 型（引数なし、Intを返す）のクロージャを返す関数です。
  2. 関数内部で、runningTotal という変数が 0 で初期化されます。
  3. incrementer というクロージャが定義されます。このクロージャは、自身のスコープの外にある runningTotal と amount を参照しています。これがキャプチャです。Swiftはこれらの値への参照をクロージャ内に保存します。
  4. makeIncrementer は incrementer クロージャを返して、その実行を終了します。通常、関数の実行が終わると、その中のローカル変数（runningTotal）はメモリから解放されるはずです。
  5. しかし、返されたクロージャ（incrementByTen）は runningTotal をキャプチャしているため、runningTotal はメモリ上に生き続けます。
  6. incrementByTen() を呼び出すたびに、キャプチャされた runningTotal が更新されていきます。
  7. incrementBySeven は、incrementByTen とは独立した、新しい runningTotal と amount をキャプチャした別のクロージャインスタンスです。

このように、クロージャは状態を保持するための軽量なメカニズムとして機能します。

循環参照 (Retain Cycle) – 最大の注意点

値のキャプチャは非常に便利ですが、大きな落とし穴があります。それが「循環参照（Retain CycleまたはStrong Reference Cycle）」です。これは、2つのオブジェクト（典型的にはクラスのインスタンスとクロージャ）が、お互いを強い参照（Strong Reference）で保持し合い、どちらもメモリから解放されなくなってしまう状態を指します。これにより、メモリリークが発生します。

循環参照が最も発生しやすいのは、クラスのプロパティとしてクロージャを持ち、そのクロージャが自身のインスタンス (self) をキャプチャするケースです。

“`swift
class HTMLElement {
let name: String
var text: String?

// このクロージャが HTMLElement インスタンス (self) をキャプチャする可能性がある
lazy var asHTML: () -> String = {
    // ここで self を参照すると循環参照が発生！
    if let text = self.text {
        return "<\(self.name)>\(text)</\(self.name)>"
    } else {
        return "<\(self.name) />"
    }
}

init(name: String, text: String? = nil) {
    self.name = name
    self.text = text
    print("\(name) is being initialized")
}

deinit {
    print("\(name) is being deinitialized")
}

}
“`

このコードの問題点を図解します。

  1. var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world") のようにインスタンスを作成します。
    • paragraph インスタンスは、プロパティ asHTML (クロージャ) を強参照で保持します。
  2. paragraph.asHTML() のようにクロージャを初めて呼び出すと、lazy プロパティであるクロージャが生成されます。
  3. このクロージャは、self.text や self.name を参照しているため、paragraph インスタンス (self) を強参照でキャプチャします。

結果として、
paragraph インスタンス → (強参照) → asHTML クロージャ
asHTML クロージャ → (強参照) → paragraph インスタンス (self)

という参照の鎖ができてしまいます。

ここで、paragraph = nil としてインスタンスを解放しようとしても、asHTML クロージャが paragraph インスタンスを強参照で掴んでいるため、paragraph の参照カウントは0になりません。同様に、paragraph インスタンスも asHTML クロージャを掴んでいるため、こちらも解放されません。結果、どちらもメモリに残り続け、deinit が呼ばれることはありません。

循環参照の解決策: キャプチャリスト

この問題を解決するために、クロージャは「キャプチャリスト（Capture List）」という構文を提供します。クロージャの冒頭に [ ] を使い、キャプチャする際の参照の強度を指定します。

主な選択肢は weak と unowned です。

1. weak 参照

weak は、キャプチャしたインスタンスを弱参照で保持します。弱参照は参照カウントを増加させません。参照先のインスタンスが解放された場合、weak 参照は自動的に nil になります。

そのため、weak でキャプチャした変数は常にオプショナル型になります。

先ほどの HTMLElement を修正しましょう。

“`swift
class HTMLElement {
let name: String
var text: String?

lazy var asHTML: () -> String = {
    // キャプチャリストで self を weak 参照する
    [weak self] in

    // self はオプショナル型 (HTMLElement?) になる
    guard let self = self else {
        // selfが解放済みの場合は空文字列を返すなど
        return ""
    }

    if let text = self.text {
        return "<\(self.name)>\(text)</\(self.name)>"
    } else {
        return "<\(self.name) />"
    }
}

// ... init と deinit は同じ ...

}
``
**変更点:**
* クロージャの冒頭に[weak self]を追加しました。これにより、クロージャからselfへの参照が弱参照になります。
* クロージャ内でselfを使う際、selfはオプショナル型 (HTMLElement?) になっています。そのため、guard let self = self else { return }のようなアンラップ処理（シャドーイング）が必要です。これにより、安全にself` を利用できます。

この修正により、paragraph インスタンスからクロージャへの参照は強いままですが、クロージャから paragraph インスタンスへの参照は弱くなったため、循環参照の鎖が断ち切られます。paragraph = nil とすれば、インスタンスは正しく解放され、deinit が呼ばれます。

2. unowned 参照

unowned も weak と同様に、キャプチャしたインスタンスを強参照せずに保持します。しかし、大きな違いがあります。

  • unowned: 参照先のインスタンスが、クロージャの生存期間中、絶対に nil にならないことが保証されている場合に使用します。unowned でキャプチャした変数はオプショナル型にはなりません。もし参照先のインスタンスが解放された後にアクセスしようとすると、アプリがクラッシュします。
  • weak: 参照先のインスタンスが先に解放される可能性がある場合に使用します。安全ですが、オプショナルを扱う手間が少し増えます。

使い分けの指針はシンプルです。
「クロージャとインスタンスが常に同時に解放される」または「インスタンスがクロージャより長生きすることが確実」と言い切れる場合にのみ unowned を使います。それ以外の、少しでも不安がある場合は、安全な weak を選択してください。

swift
// unownedを使った例
lazy var asHTML: () -> String = {
[unowned self] in // selfがnilにならない自信がある場合
if let text = self.text {
return "<\(self.name)>\(text)</\(self.name)>"
} else {
return "<\(self.name) />"
}
}
unowned は guard let が不要でコードはスッキリしますが、その分リスクを伴います。基本は [weak self] と覚えておけば間違いありません。

3-2. エスケープクロージャ（Escaping Closures）

関数の引数として渡されたクロージャが、その関数の実行が終了した後に呼び出される可能性がある場合、そのクロージャを「エスケープ（脱出）する」と言います。このようなクロージャは、引数の型の前に @escaping 属性を付けて明示する必要があります。

エスケープする典型的なケースは非同期処理です。

  • ネットワーク通信の完了ハンドラ
  • タイマー (DispatchQueue.main.asyncAfter)
  • アニメーションの完了ブロック

例として、非同期でデータを取得する関数を考えてみましょう。

“`swift
class DataManager {
// 完了ハンドラをプロパティとして保持するため、クロージャはエスケープする必要がある
var completionHandlers: [() -> Void] = []

// @escaping が必要
func fetchData(completion: @escaping () -> Void) {
    print("データ取得を開始...")
    // データをプロパティに保存して、後で実行する
    completionHandlers.append(completion)
    print("関数 fetchData の実行はここで一旦終了")
}

func completeFetching() {
    print("データ取得が完了！")
    // 保存しておいたクロージャをすべて実行
    completionHandlers.forEach { $0() }
}

}

let manager = DataManager()
manager.fetchData {
// このクロージャは fetchData() が終了した後に呼ばれる
print(“完了ハンドラが実行されました。”)
}

// … しばらく経ってから …
manager.completeFetching()

// — 出力 —
// データ取得を開始…
// 関数 fetchData の実行はここで一旦終了
// データ取得が完了！
// 完了ハンドラが実行されました。
“`

fetchData 関数は、引数で受け取った completion クロージャをすぐに実行せず、completionHandlers 配列に保存しています。そして関数の実行は終了します。クロージャは関数のスコープから「脱出」し、後で completeFetching が呼ばれたときに実行されます。

もし @escaping を付けないと、コンパイラは「このクロージャは関数のスコープ内でしか使われないはずだ」と判断するため、外部に保存しようとするとエラーになります。@escaping はコンパイラに対して「このクロージャは後で呼ばれるかもしれないから、メモリ管理など、それ相応の注意を払ってね」と伝えるためのサインなのです。

@escaping と self

エスケープクロージャ内で self を参照する場合、コンパイラは self. の明記を要求します。これは、意図せず self をキャプチャし、循環参照を引き起こすリスクを開発者に意識させるための安全機能です。

“`swift
class MyViewController {
var data = String

func fetchData() {
    someAsyncFunction { [weak self] result in
        // エスケープクロージャ内なので self が必要
        // 循環参照を避けるため [weak self] を使用
        guard let self = self else { return }
        self.data = result
        self.updateUI()
    }
}

func updateUI() { /* ... */ }
func someAsyncFunction(completion: @escaping ([String]) -> Void) { /* ... */ }

}
“`

3-3. オートクロージャ（Autoclosures）

@autoclosure は、引数として渡された式を、自動的にクロージャでラップする機能です。これにより、呼び出し側は { } を書かずに、ただの式を渡すだけでよくなります。

この機能の最大の目的は「遅延評価（Lazy Evaluation）」です。つまり、引数の式が実際に必要になるまで評価（実行）されないようにすることです。

Swiftの標準ライブラリで最も有名な例は assert 関数です。

swift
func assert(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = String(), file: StaticString = #file, line: UInt = #line)

condition 引数に @autoclosure が付いています。これにより、私たちは assert をこう呼び出せます。

swift
var age = 20
assert(age >= 18, "未成年者はアクセスできません")
{ age >= 18 } と書く必要はありません。Swiftが自動的にクロージャに変換してくれます。

なぜこれが重要なのでしょうか？
assert はデバッグビルドでのみ動作し、リリースビルドでは無効化されます。もし @autoclosure がなければ、age >= 18 という式は assert 関数が呼ばれる前に評価されてしまいます。たとえリリースビルドで assert の中身が空だとしても、この評価コストは発生してしまいます。

@autoclosure があることで、式はクロージャに包まれます。assert 関数の内部で、本当にその評価結果が必要になったとき（デバッグビルドの場合）に初めて、クロージャが実行され、式が評価されます。リリースビルドではクロージャが実行されないため、評価コストはゼロになります。

独自のロギング関数などでも活用できます。

“`swift
// 高コストなデバッグメッセージを生成する関数
func complexDebugMessage() -> String {
print(“メッセージ生成中…”)
// 重い処理をシミュレート
var result = “”
for i in 0…1_000_000 { result += String(i).first! }
return “複雑なメッセージ”
}

// @autoclosure を使ったロギング関数
var isLoggingEnabled = false

func logIfEnabled(_ message: @autoclosure () -> String) {
if isLoggingEnabled {
print(message()) // ここで初めて message クロージャが実行される
}
}

// ログが無効の場合
isLoggingEnabled = false
logIfEnabled(complexDebugMessage()) // “メッセージ生成中…” は出力されない！

// ログが有効の場合
isLoggingEnabled = true
logIfEnabled(complexDebugMessage())
// 出力:
// メッセージ生成中…
// 複雑なメッセージ
``logIfEnabledを呼び出す際、complexDebugMessage()はまだ実行されません。isLoggingEnabledがtrueのときだけ、message()` としてクロージャが実行され、中の重い処理が走ります。

ただし、@autoclosure はコードの意図を不明瞭にする可能性があるため、乱用は避けるべきです。遅延評価に明確なメリットがある場合に限定して使用するのが良いでしょう。

第4章: 実践！クロージャの活用例

理論を学んだところで、実際の開発現場でクロージャがどのように活躍しているかを見ていきましょう。

4-1. 高階関数との組み合わせ

クロージャの能力が最も発揮される場面の一つが、map, filter, reduce といったコレクション型の高階関数との組み合わせです。これらを使うと、従来の for ループを使った命令的なコードを、簡潔で宣言的なコードに書き換えることができます。

map: 配列の各要素に、クロージャで定義した変換処理を適用し、新しい配列を返します。

“`swift
let numbers = [1, 2, 3, 4, 5]

// forループの場合
var squaredNumbers: [Int] = []
for number in numbers {
squaredNumbers.append(number * number)
}
// squaredNumbers は [1, 4, 9, 16, 25]

// map とクロージャの場合
let squaredWithMap = numbers.map { $0 * $0 }
// squaredWithMap は [1, 4, 9, 16, 25]
“`

filter: 配列の各要素に対して、クロージャで定義した条件（Boolを返す）を適用し、true になった要素だけを集めた新しい配列を返します。

“`swift
// forループの場合
var evenNumbers: [Int] = []
for number in numbers {
if number % 2 == 0 {
evenNumbers.append(number)
}
}
// evenNumbers は [2, 4]

// filter とクロージャの場合
let evenWithFilter = numbers.filter { $0 % 2 == 0 }
// evenWithFilter は [2, 4]
“`

reduce: 配列の全要素を、クロージャで定義した処理を使って一つの値にまとめ上げます。

“`swift
// forループの場合
var sum = 0
for number in numbers {
sum += number
}
// sum は 15

// reduce とクロージャの場合
// 0は初期値、$0はこれまでの合計値、$1は現在の要素
let sumWithReduce = numbers.reduce(0) { $0 + $1 }
// さらに演算子メソッドで簡略化
let sumWithReduceSimple = numbers.reduce(0, +)
// sumWithReduce, sumWithReduceSimple はどちらも 15
“`

これらの高階関数はチェーン（連結）することもでき、複雑なデータ処理を非常にエレガントに記述できます。

“`swift
// 1から10の数字の中から、奇数だけを取り出し、それぞれを2乗し、その合計を求める
let result = (1…10)
.filter { $0 % 2 != 0 } // [1, 3, 5, 7, 9]
.map { $0 * $0 } // [1, 9, 25, 49, 81]
.reduce(0, +) // 165

print(result) // 出力: 165
“`

4-2. 非同期処理と完了ハンドラ

URLSession を使ったネットワーク通信は、非同期処理の典型例です。リクエストを送信してからレスポンスが返ってくるまでには時間がかかります。その結果を「完了ハンドラ（Completion Handler）」というエスケープクロージャで受け取ります。

“`swift
import Foundation

enum NetworkError: Error {
case badURL
case requestFailed
case invalidData
}

func fetchUsers(completion: @escaping (Result<[User], NetworkError>) -> Void) {
guard let url = URL(string: “https://api.example.com/users”) else {
completion(.failure(.badURL))
return
}

URLSession.shared.dataTask(with: url) { data, response, error in
    // このクロージャはバックグラウンドスレッドで実行される

    if error != nil {
        completion(.failure(.requestFailed))
        return
    }

    guard let data = data else {
        completion(.failure(.invalidData))
        return
    }

    // JSONのデコード処理 (成功したと仮定)
    // let users = try? JSONDecoder().decode([User].self, from: data)
    let users: [User] = [] // 仮のデータ

    // 成功結果を完了ハンドラで返す
    completion(.success(users))

}.resume() // タスクを開始

}

// 呼び出し側
fetchUsers { result in
// UIの更新はメインスレッドで行う
DispatchQueue.main.async {
switch result {
case .success(let users):
print(“ユーザーを(users.count)人取得しました。”)
// tableView.reloadData() など
case .failure(let error):
print(“エラーが発生しました: (error)”)
}
}
}

// User構造体のダミー定義
struct User: Codable {}
``fetchUsers関数は、結果をResult型でラップした完了ハンドラcompletionを引数に取ります。通信が完了した時点で、成功（.success）または失敗（.failure`）がこのクロージャを通じて呼び出し元に通知されます。

4-3. SwiftUIにおけるクロージャ

SwiftUIは、その構造全体がクロージャ、特にトレーリングクロージャと @ViewBuilder という特殊な属性（内部でクロージャを利用）の上に成り立っています。

Buttonのアクション
Button の初期化子は、ボタンがタップされたときのアクションをトレーリングクロージャで受け取ります。

“`swift
import SwiftUI

struct ContentView: View {
var body: some View {
VStack {
Button(“タップしてください”) {
// このブロックがアクションクロージャ
print(“ボタンがタップされました！”)
}
}
}
}
“`

ListやForEachのコンテンツ
List や ForEach は、データコレクションを元にViewを繰り返し生成します。その「何を生成するか」を定義する部分がクロージャです。

“`swift
struct TaskListView: View {
let tasks = [“UIデザイン”, “API実装”, “テスト”]

var body: some View {
    List(tasks, id: \.self) { task in
        // このブロックがコンテンツ生成クロージャ
        Text(task)
    }
}

}
“`

これらの構文は、Swiftのトレーリングクロージャのおかげで、非常に宣言的で直感的な見た目を実現しています。

4-4. Delegateパターンの代替

従来、オブジェクト間のコミュニケーションにはDelegateパターンがよく使われてきました。しかし、簡単な一方向の通知であれば、クロージャを使うことでよりシンプルに実装できます。

Delegateパターンの場合:

“`swift
// 1. プロトコルを定義
protocol MyViewControllerDelegate: AnyObject {
func didFinishTask(sender: MyViewController)
}

// 2. 移譲元クラス
class MyViewController {
weak var delegate: MyViewControllerDelegate?
func onButtonTap() {
delegate?.didFinishTask(sender: self)
}
}
``
呼び出し側は、プロトコルに準拠し、delegate` プロパティに自身をセットする必要があります。

クロージャで代替する場合:

“`swift
class MyViewControllerWithClosure {
// 完了ハンドラをプロパティとして持つ
var onFinish: (() -> Void)?

func onButtonTap() {
    onFinish?()
}

}

// 呼び出し側
let vc = MyViewControllerWithClosure()
vc.onFinish = {
print(“タスクが完了しました！”)
}
“`
クロージャを使うことで、プロトコルの定義が不要になり、関連する処理を呼び出し元の一箇所にまとめることができます。コードが簡潔になり、見通しが良くなるというメリットがあります。

まとめ

この記事では、Swiftのクロージャについて、その基本から応用までを網羅的に解説してきました。

  • クロージャの基本: 名前を持たないコードブロックであり、変数に代入したり、関数の引数/戻り値として使えることを学びました。
  • 構文の簡略化: 型推論、暗黙的なリターン、引数名の省略 ($0)、演算子メソッド、そして可読性を劇的に向上させるトレーリングクロージャといったテクニックを見てきました。
  • 強力な機能:
    • 値のキャプチャ: クロージャが状態を保持する仕組みを理解しました。
    • 循環参照: キャプチャに伴うメモリリークの危険性と、それを回避するためのキャプチャリスト [weak self] の重要性を学びました。これはSwift開発者にとって必須の知識です。
    • @escaping: 非同期処理など、クロージャが関数のスコープを「脱出」する際に必要な属性の役割を理解しました。
    • @autoclosure: 遅延評価を実現し、不要な計算コストを削減するテクニックを学びました。
  • 実践的な活用例: 高階関数、非同期処理、SwiftUI、Delegateパターンの代替など、実際のコードでクロージャがいかに強力で便利かを確認しました。

クロージャは、現代のSwiftプログラミングの根幹をなす機能です。最初は複雑に感じるかもしれませんが、この記事で解説した概念を一つ一つ理解し、実際にコードを書いて試すことで、必ずあなたの武器になります。

クロージャをマスターすれば、より簡潔で、より安全で、より表現力豊かなSwiftコードを書くことができるようになるでしょう。今後の学習ステップとしては、クロージャを多用するCombineフレームワークや、非同期処理をさらに進化させたasync/await構文へと進んでいくことをお勧めします。

この長いガイドが、あなたのSwift学習の旅の一助となれば幸いです。Happy Coding

コメントする

メールアドレスが公開されることはありません。 ※ が付いている欄は必須項目です

上部へスクロール