フロントエンドフレームワークの本質
💡 学習ガイド：この記事は一つの根本的な疑問に答えます——フロントエンドフレームワーク（Vue、React、Svelte など）は一体何をしているのか？ もしあなたが HTML、CSS と少しの JavaScript しか学んだことがなくても、まったく問題ありません。最初から丁寧に説明します。
始める前に、次の二つの基本概念を理解していることを確認してください。不安な場合は、該当する章を先にご覧ください：
- HTML：ウェブページの骨格であり、ページ上にどの要素（見出し、段落、ボタン、画像……）があるかを定義します。HTML と CSS レイアウトを参照してください。
- JavaScript：ウェブページを「動的にする」プログラミング言語で、ページの内容を変更したり、ユーザーの操作に応答したりできます。JavaScript 深掘りガイドを参照してください。
もう一つ、後で頻繁に出てくる概念がありますので、ここで完全に説明しておきます。
DOM とは何か？
DOM の正式名称は Document Object Model（ドキュメントオブジェクトモデル）です。
ブラウザでウェブページを開くと、ブラウザが最初に行うのは HTML コードの読み込みです。読み込みが終わると、ブラウザは HTML テキストをそのまま表示するのではなく、まず HTML コードをツリー構造に変換し、メモリに格納します。このツリーが DOM ツリーです。
ツリー上の各ノード（Node）は、HTML の一つのタグに対応します。タグ間の入れ子関係は、DOM ツリーでは親ノードと子ノードの関係になります。
👇 試してみましょう： 左側の HTML コードにマウスを合わせると、右側の DOM ツリー内の対応するノードがハイライトされます。逆も同様です。HTML の各行が DOM ツリー上の一つのノードに対応していることがわかります。
<h1> or <p>, maps to one node.なぜ DOM を理解する必要があるのか？ JavaScript がページを変更する方法は、まさにこの DOM ツリーを操作すること——ノードの追加、削除、内容の変更——だからです。そして、フロントエンドフレームワークが行う核心的な作業は、これらの DOM 操作を自動化することです。以降、DOM という言葉を何度も使いますので、DOM を理解することはフレームワークの原理を理解する基盤となります。
0. 導入：「フロントエンドフレームワーク」とは何か？
まず「フレームワーク」という言葉を説明しましょう。プログラミングにおいて、フレームワーク（Framework）とは、すでに書かれたコードとルールの集合体であり、あなたのコードをどのように組織し、どのように実行すべきかを規定します。あなたはそのルールに従ってコードを書くだけで、フレームが大量の重複的で煩雑な低レベルの作業を処理してくれます。
フロントエンドフレームワークとは、あなたがウェブページのインターフェースを構築するのを専門に支援するフレームワークです。現在、最もよく使われているのは Vue、React、Svelte、Angular のいずれかです。
では、具体的にどんな問題を解決してくれるのでしょうか？次の 3 枚のカードが核心的な論理を要約しています：
- When data changes, manual DOM updates are easy to miss.
- The more complex a page becomes, the more places need synchronization.
- In team work, scattered DOM operations become hard to maintain.
- The browser does not know the relationship between data and UI.
- Native DOM APIs are low-level operations, not automatic UI synchronization.
- Developers are forced to act as manual synchronizers.
- Build a mapping from data to UI: UI = f(State).
- Detect data changes automatically with reactivity.
- Compute minimal DOM updates with virtual DOM or compiler optimization.
それでは、最も基本的な問題から順を追って説明していきます。
1. 核心的な問題：データが変わったら、画面はどうする？
1.1 まず「データ」と「画面」をはっきりさせよう
どのようなウェブアプリケーションにも、常に二つのものが存在しています：
- データ（Data / State）：プログラム内部に保存されている情報。例えば「ショッピングカートに 3 つの商品がある」「ユーザー名は山田太郎」「現在選択されているのは 2 番目のタブ」。これらのデータは JavaScript の変数に格納されており、ユーザーには見えません。
- 画面（UI）：ユーザーが画面上に目にするもの。例えば、ページ上に「カート(3)」と表示され、「ようこそ、山田太郎さん」と表示され、2 番目のタブがハイライトされている。これらは HTML 要素が表現する視覚効果です。
データと画面の間には対応関係があります：データが「3 つの商品」であれば、画面にも「3」と表示されるべきです。データが「4 つの商品」に変われば、画面も「4」に変わるべきです。
問題は：この「追従して変わる」プロセスを、誰が担当するのか？ ということです。
👇 試してみましょう： 「商品を追加」ボタンをクリックし、注意深く観察してください。データ（左側）はすでに変わりましたが、画面（右側）は更新されていません——両者の間が「切断」されています。「画面を同期」をクリックして手動で修復してください。
1.2 なぜ JavaScript の変数が変わっても、画面は自動で変わらないのか？
これは初心者が最もつまずきやすいポイントです。基礎原理を順を追って説明しましょう。
JavaScript において、変数とはデータを格納するためのメモリ空間です。あなたが count = count + 1 を実行するとき、JavaScript エンジンが行うことは非常にシンプルです。メモリ内の count の位置にある値を 3 から 4 に変更する。この操作が終わると、それでおしまいです。それ以上のことは一切起こりません。
一方、ページ上に表示されている内容（例えば <span>3</span> という DOM ノード）は、まったく別のメモリ空間に格納されています。JavaScript エンジンが変数を変更する際、ページ上にこの変数の値を表示している DOM ノードがあることなど全く知りませんし、それを確認する仕組みもありません。
したがって、根本的な原因は次の通りです：JavaScript の変数と DOM ノードは二つの独立したメモリであり、それらの間には自動的な連動メカニズムが一切存在しません。 変数を変更しても、変数のメモリが変わるだけで、DOM ノードのメモリには何の影響も与えません。
let count = 3
// ページ上に count の値を表示している DOM ノードがある：
// <span id="counter">3</span>
count = 4
// JavaScript エンジンは何をしたか？
// → 変数 count のメモリ内の値を 3 から 4 に変更した
// → 終わり。以上。
// ページ上の <span> に表示されているのはまだ "3"ページ上の表示も「4」に変えたい場合、あなたは追加のコードを書き、手動でその DOM ノードを見つけて、その内容を変更しなければなりません：
count = 4 // 第 1 ステップ：変数を変更する
// 第 2 ステップ：自分で書く必要がある——DOM ノードを見つけて、そのテキストを新しい値に変更する
document.getElementById('counter').textContent = countもしページ上に count の値を表示している場所が 5 つあるなら（カートの数、商品リスト、合計金額、小計、ステータス表示）、あなたはこのようなコードを 5 つ書く必要があります。一つでも漏らせば、その場所には古い値が表示されたままとなり、ユーザーには誤った情報が表示されます。
1.3 フレームワークは何をしたのか？二つのステップで自動接続を確立
フレームワークが自動同期を実現できるのは、二つのステップの連携——どちらも欠かせません。
第 1 ステップ：テンプレートで「どこにこの変数を表示するか」を「登録」する
フレームワークの HTML テンプレートでは、 という構文を使って「ここに count の値を表示する」とマークします：
<!-- Vue テンプレート -->
<span>カート：{{ count }} 点</span> <!-- 位置 A：count を表示したい -->
<span>合計：¥{{ count * 99 }}</span> <!-- 位置 B：count も使っている -->
<span>{{ count > 5 ? '多すぎ' : '正常' }}</span> <!-- 位置 C：count も使っている -->フレームワークが最初にページをレンダリングするとき、この「登録関係」を記録します：位置 A、B、C はすべて count に依存している。
第 2 ステップ：フレームワークが変数を監視し、変更されれば登録表を確認して自動更新する
フレームワークは JavaScript に内蔵された Proxy（プロキシ）を使って、あなたの変数を「包み込み」、「監視された変数」に変えます。あなたがこの変数を変更すると、Proxy は値の代入と同時に、こっそりもう一つのことを行います。フレームワークに「count が変わった」と通知するのです。フレームワークは通知を受け取ると、第 1 ステップの登録表を確認し、A、B、C の 3 つの位置をすべて更新します。
ネイティブ JS：
HTML を書く → <span id="counter">3</span>（変数との接続は一切ない）
変数を変更する → count = 4 → 終わり、画面は無反応
手動で補う → document.getElementById('counter').textContent = 4 → やっと画面が更新
Vue フレームワーク：
テンプレートを書く → <span>{{ count }}</span>（フレームワークが記憶：ここは count に依存）
変数を変更する → count = 4 → Proxy が傍受 → フレームワークに通知 → フレームワークが登録表を確認 → A/B/C を自動更新これが「フレームワークでしか自動同期ができない」理由です——ネイティブ HTML の <span> と JS 変数の間には接続が一切なく、フレームワークのテンプレート構文（）こそがこの接続を確立する鍵なのです。あなたが と書くことで、フレームワークはここに count を表示することを知り、count が変化したときに、ここを正確に見つけて更新できるのです。
👇 試してみましょう： まず「ネイティブ JavaScript」を選び、「実行」をクリックして観察してください——変数は変わりましたが画面はピクリとも動きません。一つ一つ手動で同期する必要があります。次に「フレームワークを使用」に切り替えて、同様に「実行」をクリックしてください——変数が変わると、フレームワークがすべてのステップを自動的に完了し、画面がすぐに追いつきます。
count = 4, the engine only changes the value in memory. It does not notify anyone, trigger a callback, or check where count is displayed on the page. The UI will not change unless you update the DOM yourself.1.4 比較：手動同期 vs 自動同期の実際の効果
原理を理解したところで、もう少し複雑な場面で、手動同期と自動同期の違いがどれほど大きいかを見てみましょう。
👇 試してみましょう： 左側はフレームワークがない場合の「手動同期」方式です——各表示エリアごとに「同期」ボタンを個別にクリックして更新する必要があります。右側はフレームワークがある場合の「自動同期」方式です——「商品を追加」をクリックするだけで、すべての表示エリアが自動的に更新されます。左側であえてどこか一つ同期しないでみて、何が起こるか確認してみてください。
これこそがフロントエンドフレームワークが存在する根本的な理由です：JavaScript 変数に「変更されたときに自動的に画面の更新を通知する」能力を与え、手動同期によるエラーをなくすこと。
2. フレームワークの核心思想：データで画面を記述する
2.1 二つの書き方の違い
「自動同期」の価値を理解したところで、フレームワークが具体的にどのように実現しているかを見ていきましょう。
フレームワークがない時代（例えば jQuery を使っていた頃）、コードは次のように書かれていました——あなたがブラウザに一歩ずつ何をすべきかを指示していました：
// 第 1 ステップ：ページ上の id が counter の要素を見つける
var element = document.getElementById('counter')
// 第 2 ステップ：この要素のテキスト内容を新しい値に変更する
element.textContent = '4'
// 第 3 ステップ：別の要素を見つけて、それも変更する
document.getElementById('total').textContent = '¥396'
// 第 4 ステップ：もし数量が 5 より大きければ、ステータス表示も変更する必要が……この書き方は命令型（Imperative）と呼ばれます——あなたがブラウザに一歩ずつ操作を実行するよう「命令」しています。
フレームワークが登場すると、コードは次のように変わります——あなたは「画面がどのような見た目であるべきか」だけを記述します：
<!-- この値がどうやってページに更新されるかは気にしない -->
<!-- ただ「ここには count の値を表示する」とだけ言う -->
<span>{{ count }}</span>
<span>合計：¥{{ count * 99 }}</span>
<span v-if="count > 5">商品が多すぎます！</span>この書き方は宣言型（Declarative）と呼ばれます——あなたは画面の最終状態を「宣言」し、その状態にどう到達するかはフレームワークが処理します。
2.2 核心の公式：UI = f(State)
すべてのモダンなフロントエンドフレームワーク——Vue、React、Svelte のいずれであっても——は同じ核心思想に従っており、一つの公式で表現できます：
UI = f(State)
この公式の意味は：
- State（状態）：あなたのアプリケーションデータ。JavaScript 内の変数のことです。カートに商品がいくつあるか、ユーザーがログインしているか、現在のページはどれか……
- f（関数）：フレームワークのレンダリングメカニズム。データを画面に変換する方法を知っています。
- UI（画面）：ユーザーが画面上に目にする最終結果。
意味：あるデータ（State）が与えられ、フレームワークの処理（f）を経ることで、確定的に対応する画面（UI）が得られます。データが変われば、画面もそれに伴って変わります。開発者はデータだけを気にすればよく、画面がどう更新されるかを気にする必要はありません。
👇 試してみましょう： 左側でデータ（State）を変更し、右側の画面（UI）がどのように自動的に変化するかを観察してください。これが UI = f(State) の直観的な表現です。
{
"username": "(empty)",
"count": 2,
"darkMode": false
}2.3 なぜ宣言型は命令型より優れているのか？
宣言型の書き方の利点は次の通りです：
| 比較項目 | 命令型（フレームワークなし） | 宣言型（フレームワークあり） |
|---|---|---|
| コード量 | 各更新ごとに具体的な操作コードを書く必要がある | テンプレートを一度書くだけで、フレームワークが自動処理 |
| エラー発生率 | どこかの更新を忘れやすい | フレームワークがすべての場所の更新を保証 |
| 可読性 | コード内に大量の DOM 操作が混在 | コードが画面構造を明確に記述 |
| 保守コスト | 一つの機能を変更するのに多くの場所を修正する必要がある | データロジックを変更するだけで、画面は自動的に追従 |
要するに：宣言型はあなたの精力を「ビジネスロジック」（データがどう変化するか）に集中させ、「画面をどう更新するか」という重複的で間違いやすい作業から解放してくれます。
3. リアクティブシステム：フレームワークはどうやってデータの変化を知るのか？
3.1 「リアクティブ」とは何か？
前述の「データが変わると、画面が自動更新される」という仕組み。しかしここには一つの技術的な問題があります：JavaScript 自体には「変数が変更されたときに自動的に他に通知する」能力がありません。
あなたが count = 4 と書いても、JavaScript は単に count の値を 3 から 4 に変更するだけで、誰にも自動的に通知しません。フレームワークには、あなたがデータを変更したことを「発見」するためのメカニズムが必要です。
リアクティブ（Reactivity）とは、このようなメカニズムの総称です。データが変化したとき、システムがその変化を自動的に感知し、対応する更新操作を実行することを指します。
3.2 三つの異なる実装方式
異なるフレームワークは、リアクティブを実現するために異なる技術的アプローチを採用しています。これが Vue、React、Svelte 間の最も根本的な違いでもあります。
方式 1：プロキシによる傍受（Vue のアプローチ）
Vue は JavaScript に内蔵された Proxy（プロキシ）メカニズムを使用しています。Proxy は、あなたがオブジェクトのプロパティを読み取ったり変更したりするときに、指定したコードを自動的に実行できます。
Vue はデータオブジェクトを Proxy で包み込みます。あなたが count = 4 を実行すると、Proxy はこの書き込み操作を傍受し、Vue に「count の値が変わった」と通知し、その後 Vue は count を使っているすべての画面部分を更新します。
開発者として追加の操作は一切不要——直接代入するだけで、Vue が自動的に感知します。
方式 2：明示的な呼び出し（React のアプローチ）
React は Proxy を使用しません。React は、データを変更する際に専用の関数を通すことを要求します：
// React の書き方
const [count, setCount] = useState(0)
// 直接 count = 4 と書いてはいけない（React は感知できない）
// setCount を呼び出さなければならない：
setCount(4)あなたが setCount() を呼び出したときだけ、React はデータが変わったことを知り、画面を更新します。もし直接 count = 4 と書いた場合、React はまったく気づかず、画面は更新されません。
この方式はより「明示的」です——データの変化はすべてあなたがフレームワークに能動的に伝えるものであり、意図しない更新が起こりません。
方式 3：コンパイラによる分析（Svelte のアプローチ）
Svelte は全く異なるアプローチを採用しています。Svelte にはコンパイラ（Compiler）があり、コードが実行される前に、コンパイラがソースコードを分析します。
コンパイラが count += 1 のような代入文を見つけると、その行の後に「画面の更新を通知する」コードを自動的に挿入します。つまり、コードが実行される時点では、「通知」というアクションはすでにコンパイラによって事前に組み込まれているのです。
あなたのコードは普通の JavaScript の代入に見えますが、コンパイル後のコードには画面更新のロジックが追加されています。
👇 試してみましょう： 異なるフレームワークのタブを選択し、「データを変更」をクリックして、各フレームワークが「フードの下」でどのようなステップを経てデータ変化の検出と画面更新を行っているかを観察してください。
3.3 三つの方式の比較
| 比較項目 | Vue（Proxy プロキシ） | React（明示的呼び出し） | Svelte（コンパイラ） |
|---|---|---|---|
| 開発者の書き方 | 直接代入 count = 4 | setCount(4) を使う必要がある | 直接代入 count = 4 |
| 変化を感知するタイミング | 実行時に自動的に傍受 | 開発者が能動的に通知 | コンパイル時に事前に通知コードを挿入 |
| 実行時のパフォーマンスオーバーヘッド | Proxy の傍受にわずかなオーバーヘッド | setState のスケジューリングにわずかなオーバーヘッド | ほぼ追加のオーバーヘッドなし |
| デバッグの難しさ | 中程度 | データフローが明確で比較的容易 | コンパイル後のコードを理解する必要がある |
| 適したシーン | 開発効率と自然な書き方を追求 | 予測可能なデータフローを追求 | 極限の実行パフォーマンスを追求 |
三つの方式に絶対的な優劣はありません。Vue は最も自然に書け、React はデータフローが最も制御しやすく、Svelte は実行時のパフォーマンスが最も高いです。どれを選ぶかは、プロジェクトの具体的な要件によって決まります。
4. コンポーネント：画面を再利用可能な小さなブロックに分割する
4.1 なぜ分割するのか？
一つの完全なウェブページには、ナビゲーションバー、サイドバー、コンテンツエリア、検索ボックス、ユーザーアバター、各種ボタン……があるかもしれません。すべてのコードを一つのファイルに書くと、そのファイルは非常に長くなり、保守が非常に困難になります。
コンポーネント（Component）とは、画面を独立した小さなブロックに分割し、それぞれのブロックが自分のデータ、自分の画面、自分のロジックを管理する仕組みです。
例えば、EC サイトのページは次のようなコンポーネントに分割できます：
NavBarコンポーネント：上部ナビゲーションバーを担当SearchBoxコンポーネント：検索ボックスを担当ProductCardコンポーネント：一つの商品カードを担当ShoppingCartコンポーネント：カートを担当
各コンポーネントは独立しています。ProductCard は NavBar の中にどんなコードが書かれているかを知る必要がなく、自分自身のことだけを管理すればよいのです。
4.2 コンポーネントの三つの利点
利点 1：再利用。 一つの ProductCard コンポーネントを書けば、ページ上で 100 回使えます——そのたびに異なる商品データを渡すだけで、異なる商品カードがレンダリングされます。HTML コードを 100 回コピー＆ペーストする必要はありません。
利点 2：カプセル化。 コンポーネント内部のデータとロジックは独立しています。SearchBox コンポーネントのコードを変更しても、ProductCard コンポーネントには影響しません。複数人での協力時には、異なる人が同時に異なるコンポーネントを開発でき、互いに干渉しません。
利点 3：保守性。 ある機能に問題が発生した場合、対応するコンポーネントを直接見つけて修正でき、数千行の大きなファイルの中を探し回る必要がありません。
👇 試してみましょう： 左側のコンポーネント名をクリックして、ページ上の対応するエリアを確認してください。同じ ProductCard コンポーネントが複数回再利用され、毎回異なるデータが表示されていることに注目してください。
4.3 コンポーネントはコードではどのような見た目か？
Vue を例にすると、一つのコンポーネントは一つの .vue ファイルであり、その中には三つの部分が含まれています：
<!-- ProductCard.vue -->
<template>
<!-- ここに HTML 構造を書く —— コンポーネントの「見た目」 -->
<div class="card">
<h3>{{ name }}</h3>
<p>価格：¥{{ price }}</p>
<button @click="addToCart">カートに追加</button>
</div>
</template>
<script setup>
// ここに JavaScript ロジックを書く —— コンポーネントの「振る舞い」
const props = defineProps(['name', 'price'])
function addToCart() {
// 「カートに追加」のロジックを処理する
}
</script>
<style scoped>
/* ここに CSS スタイルを書く —— コンポーネントの「装飾」 */
.card {
border: 1px solid #ccc;
padding: 16px;
}
</style>このコンポーネントを使用するときは、カスタム HTML タグを使うような感覚です：
<!-- 他の場所で ProductCard コンポーネントを使用する -->
<ProductCard name="ワイヤレスイヤホン" price="299" />
<ProductCard name="メカニカルキーボード" price="599" />
<ProductCard name="ディスプレイ" price="1999" />わずか 3 行のコードで、3 枚の異なる商品カードがレンダリングされます。
5. DOM 操作のコスト：なぜフレームワークはこれほどの労力を費やすのか？
5.1 DOM 操作とは何か？
前述の通り、DOM とはブラウザが HTML を解析して生成するツリー構造です。DOM 操作とは、JavaScript を使ってこのツリー上のノードを変更することです。例えば、テキストの変更、要素の追加、要素の削除、スタイルの変更などです。
これらの操作自体は複雑ではありませんが、ブラウザは DOM 操作を実行した後、画面上の表示を更新するために多くの追加の作業を行う必要があります：
- スタイルの再計算：このノードとその子ノードの CSS スタイルを変更する必要があるか？
- 再レイアウト（Layout / Reflow）：ページ上のすべての要素の位置とサイズを再計算する必要がある。一つの要素の変更が他の要素の位置に影響する可能性があるため。
- 再描画（Paint）：計算された内容を画面に描画する。
この 3 つのステップにはそれぞれ計算コストがかかります。コードが頻繁に DOM 操作をトリガーすると、ブラウザはこれらのステップを繰り返し実行し、ページがカクつくようになります。
👇 試してみましょう： 直接 DOM 操作と一括 DOM 操作の所要時間を比較してみてください。変更回数が増えると、「一つずつ操作」の所要時間が急激に上昇することがわかります。
5.2 フレームワークはこの問題をどう解決するのか？
直接 DOM を操作するのはコストが高いため、フレームワークはDOM 操作の回数を減らす方法を考えます。具体的には二つの戦略があります：
戦略 1：仮想 DOM + 差分比較（Vue、React のアプローチ）
仮想 DOM（Virtual DOM）は JavaScript オブジェクトであり、その構造は実際の DOM ツリーと一対一で対応していますが、メモリ内にのみ存在し、ブラウザのレイアウトや描画をトリガーしません。
データが変化したとき、フレームワークの処理フローは次の通りです：
- JavaScript オブジェクトを使って「新しい仮想 DOM ツリー」を作成し、データが変化した後の画面の見た目を記述する
- この新しいツリーと古いツリーを比較する（このプロセスは Diff つまり差分比較と呼ばれる）、どのノードが変化したかを見つける
- 実際に変化した部分だけを実際の DOM に適用する（このプロセスは Patch つまりパッチ適用と呼ばれる）
このようにして、データがどのように変化しても、最終的に実際の DOM に対する操作は常に最小限になります。
👇 試してみましょう： 「データを変更」をクリックし、仮想 DOM が新旧二つのツリーをどのように比較し、変化したノードを見つけるかを観察してください。一番右の「実際の DOM」に注目——本当に変化した部分だけが点滅することがわかります。
- Learn Vue
- Do homework
- Play games
戦略 2：コンパイル時の正確な位置特定（Svelte のアプローチ）
Svelte は仮想 DOM を使用しません。Svelte のコンパイラは、あなたがコードを書く時点で分析を完了しています。「count が変化したとき、3 行目の <span> 要素を更新する必要がある」という具合に。実行時には直接その要素の位置を特定して更新するため、新旧のツリーの比較は完全に不要です。
このアプローチは Diff ステップをスキップするため、理論的にはパフォーマンスがより優れています。ただし、コンパイラの分析能力に依存しています——コンパイラが十分に賢くなければ、更新すべきすべての場所を正確に特定できません。
6. 実行時 vs コンパイル時：フレームワーク設計の核心的なトレードオフ
6.1 二つのフェーズ
フロントエンドのコードは、あなたが書いてから最終的にブラウザで実行されるまで、二つのフェーズを経ます：
- コンパイル時（Compile-time / Build-time）：あなたのソースコードがビルドツール（Vite、Webpack など）によって処理され、ブラウザが直接実行できるコードに変換されます。このプロセスはあなたのコンピュータ上で行われ、ユーザーがページを開く前に行われます。
- 実行時（Runtime）：変換されたコードがユーザーのブラウザ上で実行されます。フレームワークの核心的なロジック（仮想 DOM の Diff、リアクティブの追跡など）はこのフェーズで動作します。
6.2 二つのフェーズでのフレームワークの作業分担
異なるフレームワークは、これら二つのフェーズにおける作業量の配分が異なり、これがパフォーマンス特性とバンドルサイズを決定します：
- React：大部分の作業が実行時に完了する。仮想 DOM の作成、Diff、Patch はすべてブラウザ上で発生する。利点は高い柔軟性。代償はフレームワークのランタイムコード全体（約 40KB）をブラウザに送信する必要があること。
- Vue：ハイブリッド方式。テンプレートはコンパイル時に最適化される（コンパイラが静的で変化しないノードをマークする）が、最終的な画面更新は依然として実行時の仮想 DOM によって行われる。ランタイムコードは約 30KB。
- Svelte：大部分の作業がコンパイル時に完了する。コンパイラがあなたのコードを分析し、正確な DOM 更新命令を直接生成する。実行時にはほぼフレームワークのコードがなく——最終的なバンドルにはあなた自身のビジネスコードのみが含まれる。バンドルサイズは最小。
👇 試してみましょう： 異なるフレームワークのタブをクリックし、「実行時 ↔ コンパイル時」スペクトル上での位置と、バンドルサイズ、実行時パフォーマンス、開発体験におけるそれぞれのトレードオフを確認してください。
6.3 業界のトレンド
近年のフレームワークの発展方向は明確です：できるだけ多くの作業を実行時からコンパイル時に移すこと。 コンパイル時の計算はユーザーのデバイスのリソースを消費せず、ページの読み込み速度に影響しないからです。
- Vue は Vapor Mode（ベイパーモード）を開発中で、仮想 DOM をスキップし、コンパイル時に直接 DOM 操作コードを生成できるようにする
- React は React Compiler をリリースし、コンパイル時にコンポーネントの再レンダリング動作を自動的に最適化する
- Svelte 5 は Runes システムを導入し、コンパイル時の分析能力をさらに強化した
7. まとめ
この記事の核心的なポイントを振り返りましょう：
フロントエンドフレームワークが解決する根本的な問題：アプリケーション内のデータが変化したとき、自動的に、効率的に、確実に画面を更新すること。開発者が手動で DOM を操作する必要をなくす。
すべてのフレームワークが共通して従う核心思想：UI = f(State)——画面はデータの関数であり、開発者はデータの変化にだけ注目すればよく、フレームワークがデータの変化を画面に反映させる責任を負う。
フレームワーク間の技術的な違い：
| 技術ポイント | 意味 |
|---|---|
| リアクティブシステム | フレームワークがデータ変化を検出する方法。Vue は Proxy の傍受、React は明示的な setState、Svelte はコンパイラの分析を使用。 |
| 仮想 DOM | Vue と React は JavaScript オブジェクトを使って DOM ツリーをシミュレートし、新旧二つのツリーの比較（Diff）を通じて最小の更新量を見つけ出し、実際の DOM 操作を減らす。 |
| コンポーネント化 | 画面を独立した、再利用可能な小さなブロックに分割し、各コンポーネントが自分のデータと画面を管理する。 |
| コンパイル時の最適化 | コードのビルド段階で事前に分析と最適化を行い、実行時の計算量を減らす。Svelte がこの分野で最も進んでいる。 |
一言で言えば：フロントエンドフレームワークの本質的な仕事とは——「データから画面へ」の同期プロセスを引き受け、開発者がデータのロジックだけを考えればよいようにし、手動での画面操作を不要にすることです。
用語対照表
| 英語の用語 | 日本語の訳 | 説明 |
|---|---|---|
| Framework | フレームワーク | あらかじめ書かれたコードとルールの集合体であり、開発者にアプリケーションの基盤構造と一般的な機能を提供する。 |
| DOM | ドキュメントオブジェクトモデル | ブラウザが HTML を解析して生成するツリー状のデータ構造であり、JavaScript はこれを操作してページを変更する。 |
| Virtual DOM | 仮想 DOM | JavaScript オブジェクトで DOM ツリーをシミュレートし、Diff アルゴリズムで最小の更新経路を見つけ出し、実際の DOM 操作回数を減らす。 |
| State | 状態 | アプリケーション内のデータ。ユーザー情報、カートの内容、ページの現在の状態など。 |
| Reactivity | リアクティブ | データが変化したとき、システムが自動的にそれを感知し、対応する画面更新操作を実行すること。 |
| Proxy | プロキシ | JavaScript に内蔵されたメカニズムであり、オブジェクトの読み取りと書き込み操作を傍受できる。Vue 3 はこれを使ってリアクティブを実現している。 |
| Component | コンポーネント | 独立した再利用可能な画面コードであり、独自の HTML 構造、JavaScript ロジック、CSS スタイルを含む。 |
| Declarative | 宣言型 | 一つのプログラミングのアプローチ：あなたは「最終的に何が欲しいか」を記述し、どう実現するかはフレームワークが決める。 |
| Imperative | 命令型 | 一つのプログラミングのアプローチ：あなたがプログラムに「具体的にどうするか」を一歩ずつ指示する。 |
| Diff | 差分比較 | 新旧二つの仮想 DOM ツリーを比較し、どのノードが変化したかを見つけ出すこと。 |
| Patch | パッチ適用 | Diff で見つかった変化部分を、実際の DOM に適用すること。 |
| Compile-time | コンパイル時 | コードがビルド段階で処理される期間であり、ユーザーがページを開く前に発生する。 |
| Runtime | 実行時 | コードがユーザーのブラウザ上で実行される期間。 |
| Compiler | コンパイラ | ソースコードを別の形式のコードに変換するプログラム。Svelte のコンパイラは .svelte ファイルを効率的な JavaScript に変換する。 |