MENU
  1. ホーム
  2. JavaScript
  3. JavaScriptのAsync/Awaitでエラーハンドリングをマスターする方法

JavaScriptのAsync/Awaitでエラーハンドリングをマスターする方法

JavaScript

JavaScriptの非同期処理は、コールバック関数やPromiseを使って行うことが一般的です。しかし、複雑な非同期操作が増えると、コードが読みづらくなり、エラーハンドリングも困難になります。そこで登場するのがAsync/Awaitです。Async/Awaitは、非同期処理を同期処理のように書くことができる強力な機能で、コードの可読性と保守性を向上させます。本記事では、Async/Awaitを使った非同期処理の基本から、エラーハンドリングの方法、そして実際のプロジェクトでの応用例までを詳細に解説します。これにより、JavaScriptでの非同期処理におけるエラーハンドリングのスキルを高め、安定したコードを書くための知識を習得できます。

目次

Async/Awaitとは

Async/Awaitは、JavaScriptにおける非同期処理をより直感的に書くための構文です。ES2017で導入され、Promiseをベースにして動作します。Async関数は常にPromiseを返し、Awaitキーワードを使用すると、Promiseの解決を待ってから次のコードを実行します。この構文により、非同期コードがまるで同期処理のように見えるため、可読性が大幅に向上します。Async/Awaitを使うことで、非同期処理のフローがシンプルになり、エラーハンドリングも容易になります。

非同期処理の問題点

JavaScriptにおける非同期処理には、いくつかの問題点があります。これらの問題を理解することは、Async/Awaitの利点を最大限に活用するために重要です。

コールバック地獄

コールバック関数を使った非同期処理は、入れ子構造が深くなりやすく、「コールバック地獄」と呼ばれる状態に陥ることがあります。この状態になると、コードの可読性が低下し、デバッグや保守が非常に困難になります。

Promiseチェーンの複雑化

Promiseを使うことでコールバック地獄はある程度解消されましたが、複数の非同期操作を連続して行う場合、Promiseチェーンが複雑化し、エラーハンドリングも煩雑になります。特に、各Promiseの中でエラーハンドリングを行う必要がある場合、コードが冗長になりやすいです。

エラーハンドリングの難しさ

非同期処理では、エラーが発生する箇所が分散しているため、適切なエラーハンドリングが難しくなります。コールバックやPromiseでは、エラーをキャッチするために多くのtry…catchブロックやcatchメソッドを使用する必要があり、コードの見通しが悪くなります。

Async/Awaitは、これらの問題を解決し、非同期処理のコードをより簡潔で読みやすくするための強力なツールです。次のセクションでは、Async/Awaitの基本的な使い方について詳しく解説します。

基本的な使い方

Async/Awaitを使用すると、非同期処理をより直感的に記述することができます。ここでは、Async/Awaitの基本的な使い方を具体的なコード例を交えて解説します。

Async関数の定義

Async関数は、asyncキーワードを関数定義の前に付けることで作成できます。この関数は必ずPromiseを返します。

async function fetchData() {
  return 'データを取得しました';
}

この関数は呼び出されると、Promiseを返し、そのPromiseはすぐに解決されます。

Awaitの使用

Awaitキーワードを使うことで、Promiseの解決を待ってから次の処理を実行できます。AwaitはAsync関数内でしか使用できません。

async function fetchData() {
  let response = await fetch('https://api.example.com/data');
  let data = await response.json();
  console.log(data);
}

この例では、fetch関数が解決するまで待ち、その後にresponse.jsonの結果を待ちます。これにより、非同期処理が同期処理のように見えるため、コードが非常に読みやすくなります。

Async/Awaitとエラーハンドリング

Async/Awaitを使用する際には、try…catch構文を使ってエラーハンドリングを行います。これにより、エラーが発生した場合でも、簡潔にエラーハンドリングを行うことができます。

async function fetchData() {
  try {
    let response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error('ネットワークエラー');
    }
    let data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('エラーが発生しました:', error);
  }
}

この例では、fetchが失敗した場合やレスポンスが正常でない場合にエラーがスローされ、catchブロックで処理されます。これにより、非同期処理中のエラーを一箇所で処理でき、コードの可読性と保守性が向上します。

次のセクションでは、非同期処理におけるエラーハンドリングの重要性について詳しく説明します。

エラーハンドリングの重要性

非同期処理において、エラーハンドリングは極めて重要です。適切なエラーハンドリングを行わないと、アプリケーションが予期しない動作をしたり、ユーザーにとって不快な体験を引き起こしたりする可能性があります。

安定性の向上

エラーハンドリングを適切に行うことで、アプリケーションの安定性が向上します。エラーが発生してもアプリケーション全体がクラッシュすることなく、問題箇所を特定して適切に対処することができます。これにより、ユーザーに安定した体験を提供できます。

デバッグの容易さ

エラーハンドリングを適切に実装することで、デバッグが容易になります。エラーが発生した際に、詳細なエラーメッセージやスタックトレースを記録することで、問題の原因を迅速に特定することができます。

ユーザーエクスペリエンスの向上

エラーハンドリングを適切に行うことで、ユーザーエクスペリエンスも向上します。エラーが発生した際に、ユーザーに適切なフィードバックを提供し、次のアクションを案内することで、ユーザーが混乱することなく操作を続けることができます。

セキュリティの向上

エラーハンドリングはセキュリティにも寄与します。エラーが適切に処理されないと、攻撃者にとってアプリケーションの脆弱性を突く手がかりとなる情報を提供してしまう可能性があります。適切なエラーハンドリングにより、こうした情報漏洩を防ぐことができます。

これらの理由から、非同期処理におけるエラーハンドリングは非常に重要です。次のセクションでは、Async/Awaitとtry…catch構文を用いたエラーハンドリングの基本について詳しく説明します。

try…catch構文の利用

Async/Awaitとtry…catch構文を組み合わせることで、非同期処理中に発生するエラーを簡単に管理することができます。このセクションでは、Async/Awaitとtry…catch構文を使ったエラーハンドリングの基本を解説します。

基本的な使い方

Async関数内でAwaitを使用する際、エラーが発生する可能性のあるコードをtryブロック内に配置し、catchブロックでそのエラーをキャッチします。

async function fetchData() {
  try {
    let response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error('ネットワークエラー');
    }
    let data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('エラーが発生しました:', error);
  }
}

この例では、fetch関数が成功するまで待ちますが、エラーが発生した場合、catchブロックでエラーメッセージをログに記録します。

非同期処理の連鎖におけるエラーハンドリング

複数の非同期処理が連鎖する場合、それぞれのAwaitがエラーをスローする可能性があります。この場合、try…catchブロックを使用して一箇所でエラーをキャッチすることができます。

async function processMultipleRequests() {
  try {
    let [response1, response2] = await Promise.all([
      fetch('https://api.example.com/data1'),
      fetch('https://api.example.com/data2')
    ]);

    if (!response1.ok || !response2.ok) {
      throw new Error('一つ以上のリクエストが失敗しました');
    }

    let data1 = await response1.json();
    let data2 = await response2.json();
    console.log(data1, data2);
  } catch (error) {
    console.error('エラーが発生しました:', error);
  }
}

この例では、Promise.allを使用して複数の非同期リクエストを並行して実行し、いずれかのリクエストが失敗した場合にエラーをキャッチします。

エラーの再スロー

場合によっては、エラーをキャッチした後に再度スローすることで、エラー処理を上位の関数に委ねることが有効です。

async function fetchData() {
  try {
    let response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error('ネットワークエラー');
    }
    let data = await response.json();
    return data;
  } catch (error) {
    console.error('fetchData内でエラー:', error);
    throw error;  // エラーを再スロー
  }
}

async function main() {
  try {
    let data = await fetchData();
    console.log('データ:', data);
  } catch (error) {
    console.error('main内でエラー:', error);
  }
}

main();

この例では、fetchData関数内でキャッチしたエラーを再スローし、main関数内で最終的にエラーをキャッチして処理しています。これにより、エラーハンドリングを柔軟に管理できます。

次のセクションでは、複数の非同期処理を効率的に管理する方法について紹介します。

複数の非同期処理の管理

複数の非同期処理を効率的に管理することは、JavaScript開発において重要です。Async/Awaitを使用すると、これらの非同期処理をわかりやすく書くことができます。このセクションでは、複数の非同期処理をどのように管理するかについて解説します。

順次実行

複数の非同期処理を順次実行する場合、Awaitを使用して次の処理が前の処理の完了を待つようにします。

async function fetchSequentialData() {
  try {
    let response1 = await fetch('https://api.example.com/data1');
    let data1 = await response1.json();
    console.log('データ1:', data1);

    let response2 = await fetch('https://api.example.com/data2');
    let data2 = await response2.json();
    console.log('データ2:', data2);
  } catch (error) {
    console.error('エラーが発生しました:', error);
  }
}

fetchSequentialData();

この例では、data1の取得が完了してからdata2の取得が開始されます。これにより、順次非同期処理を直感的に管理できます。

並行実行

非同期処理を並行して実行する場合、Promise.allを使用すると効率的です。Promise.allは、すべてのPromiseが解決するまで待ち、すべてが成功した場合に結果を配列として返します。

async function fetchParallelData() {
  try {
    let [response1, response2] = await Promise.all([
      fetch('https://api.example.com/data1'),
      fetch('https://api.example.com/data2')
    ]);

    let data1 = await response1.json();
    let data2 = await response2.json();

    console.log('データ1:', data1);
    console.log('データ2:', data2);
  } catch (error) {
    console.error('エラーが発生しました:', error);
  }
}

fetchParallelData();

この例では、data1とdata2の取得が同時に行われ、両方のリクエストが完了するまで待ちます。これにより、時間を節約し効率的に非同期処理を行えます。

競争条件の管理

Promise.raceを使用すると、最初に解決または拒否されたPromiseの結果を取得できます。これを利用して、最も早く完了する非同期処理の結果を使用することができます。

async function fetchFastestData() {
  try {
    let response = await Promise.race([
      fetch('https://api.example.com/data1'),
      fetch('https://api.example.com/data2')
    ]);

    let data = await response.json();
    console.log('最速のデータ:', data);
  } catch (error) {
    console.error('エラーが発生しました:', error);
  }
}

fetchFastestData();

この例では、data1とdata2のうち、どちらかが最初に解決されるのを待ち、その結果を取得します。競争条件の管理が必要な場合に有効です。

次のセクションでは、エラーの再スローについて、その使い方と利点を解説します。

エラーの再スロー

エラーハンドリングの際、キャッチしたエラーを再度スローすることで、エラーハンドリングを上位の関数に委ねることができます。これにより、エラーハンドリングをより柔軟かつ体系的に行うことが可能になります。このセクションでは、エラーの再スローについて解説します。

基本的な再スローの使い方

エラーを再スローする基本的な方法は、try…catchブロック内でエラーをキャッチし、その後にthrowキーワードを使ってエラーを再度スローすることです。

async function fetchData() {
  try {
    let response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error('ネットワークエラー');
    }
    let data = await response.json();
    return data;
  } catch (error) {
    console.error('fetchData内でエラー:', error);
    throw error;  // エラーを再スロー
  }
}

async function main() {
  try {
    let data = await fetchData();
    console.log('データ:', data);
  } catch (error) {
    console.error('main内でエラー:', error);
  }
}

main();

この例では、fetchData関数内で発生したエラーをキャッチし、エラーメッセージをログに記録した後に再スローしています。main関数で再度このエラーをキャッチし、最終的なエラーハンドリングを行います。

特定のエラーのみ再スロー

場合によっては、特定のエラーのみを再スローし、他のエラーはローカルで処理することが必要になることがあります。これを実現するためには、エラーの種類をチェックしてから再スローするかどうかを決定します。

async function fetchData() {
  try {
    let response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error('ネットワークエラー');
    }
    let data = await response.json();
    return data;
  } catch (error) {
    if (error.message === 'ネットワークエラー') {
      console.error('fetchData内でネットワークエラー:', error);
      throw error;  // 特定のエラーを再スロー
    } else {
      console.error('fetchData内で他のエラー:', error);
    }
  }
}

async function main() {
  try {
    let data = await fetchData();
    console.log('データ:', data);
  } catch (error) {
    console.error('main内でキャッチされたエラー:', error);
  }
}

main();

この例では、「ネットワークエラー」の場合のみエラーを再スローし、それ以外のエラーはfetchData関数内で処理しています。これにより、エラーハンドリングをより細かく制御することができます。

再スローの利点

エラーを再スローすることにはいくつかの利点があります。

  1. エラーハンドリングの一元化：上位の関数でエラーを一括して処理することで、エラーハンドリングのロジックを一元化できます。
  2. コードの簡潔化：各関数内で詳細なエラーハンドリングを行う代わりに、再スローを使うことでコードを簡潔に保つことができます。
  3. 柔軟性の向上：エラーを再スローすることで、特定のエラー処理を上位のコンテキストで行うことが可能になり、エラーハンドリングの柔軟性が向上します。

次のセクションでは、非同期関数のテスト手法とその重要性について説明します。

非同期関数のテスト

非同期関数のテストは、アプリケーションの信頼性と品質を確保するために重要です。非同期処理は通常の処理よりも複雑であるため、適切なテスト手法を用いることが求められます。このセクションでは、非同期関数のテスト方法とその重要性について説明します。

非同期関数のテストの基本

非同期関数をテストする際には、テストフレームワークが提供する非同期テスト機能を活用します。ここでは、Jestを使用した例を紹介します。

// 非同期関数の例
async function fetchData() {
  let response = await fetch('https://api.example.com/data');
  if (!response.ok) {
    throw new Error('ネットワークエラー');
  }
  let data = await response.json();
  return data;
}

// Jestを使ったテスト
test('fetchData関数はデータを返す', async () => {
  const data = await fetchData();
  expect(data).toBeDefined();
});

このテストでは、fetchData関数がデータを返すことを確認しています。Jestのtest関数内でawaitを使用することで、非同期関数のテストが簡単に行えます。

モックを使用した非同期テスト

外部のAPI呼び出しを含む非同期関数をテストする場合、実際のAPI呼び出しをモックに置き換えることでテストの信頼性と速度を向上させることができます。

// Jestを使ったモックの例
global.fetch = jest.fn(() =>
  Promise.resolve({
    ok: true,
    json: () => Promise.resolve({ data: 'テストデータ' })
  })
);

test('fetchData関数はモックデータを返す', async () => {
  const data = await fetchData();
  expect(data).toEqual({ data: 'テストデータ' });
});

この例では、fetch関数をモックに置き換え、常にテストデータを返すようにしています。これにより、ネットワーク環境に依存しない安定したテストが可能になります。

エラーハンドリングのテスト

非同期関数のエラーハンドリングが正しく機能することを確認するためには、エラーをシミュレートしてテストすることが重要です。

// エラーハンドリングのモック
global.fetch = jest.fn(() =>
  Promise.resolve({
    ok: false,
    statusText: 'Internal Server Error'
  })
);

test('fetchData関数はエラーをスローする', async () => {
  await expect(fetchData()).rejects.toThrow('ネットワークエラー');
});

この例では、fetch関数が失敗するようにモックし、fetchData関数が正しくエラーをスローすることをテストしています。

テストの重要性

非同期関数のテストは、以下の理由から重要です。

  1. 信頼性の向上：非同期処理は失敗しやすいため、テストを行うことで信頼性を向上させます。
  2. バグの早期発見：テストを通じて、非同期処理に関連するバグを早期に発見し、修正することができます。
  3. コードの品質確保：継続的なテストにより、コードの品質を維持し、リファクタリングや機能追加の際にエラーが発生しないことを確認できます。

次のセクションでは、エラーハンドリングのベストプラクティスについて紹介します。

エラーハンドリングのベストプラクティス

非同期処理におけるエラーハンドリングは、アプリケーションの信頼性とユーザーエクスペリエンスを向上させるために不可欠です。ここでは、効果的なエラーハンドリングのためのベストプラクティスを紹介します。

明確なエラーメッセージの提供

エラーが発生した場合、明確で具体的なエラーメッセージを提供することが重要です。これにより、開発者は問題を迅速に特定し、解決することができます。

async function fetchData() {
  try {
    let response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error(`ネットワークエラー: ${response.statusText}`);
    }
    let data = await response.json();
    return data;
  } catch (error) {
    console.error('fetchDataでエラーが発生しました:', error);
    throw error;
  }
}

この例では、エラーメッセージにレスポンスのステータス情報を含めることで、問題の特定が容易になります。

エラーログの記録

エラーが発生した際に、適切なログを記録することで、後から問題を追跡しやすくなります。エラーログには、エラーメッセージやスタックトレースを含めると効果的です。

async function fetchData() {
  try {
    let response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error(`ネットワークエラー: ${response.statusText}`);
    }
    let data = await response.json();
    return data;
  } catch (error) {
    console.error('エラーログ:', {
      message: error.message,
      stack: error.stack
    });
    throw error;
  }
}

この例では、エラーログにエラーメッセージとスタックトレースを記録しています。

ユーザーへのフィードバック提供

エラーが発生した場合、ユーザーに適切なフィードバックを提供することが重要です。これにより、ユーザーは何が起こったのかを理解し、次の行動を取ることができます。

async function fetchData() {
  try {
    let response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error('データの取得に失敗しました。再試行してください。');
    }
    let data = await response.json();
    return data;
  } catch (error) {
    alert(error.message);  // ユーザーにエラーメッセージを表示
    throw error;
  }
}

この例では、エラーが発生した場合にユーザーにアラートを表示し、エラーメッセージを伝えています。

フォールバックの実装

エラーが発生した場合に備えて、フォールバック（代替処理）を実装することも有効です。これにより、アプリケーションの耐障害性が向上します。

async function fetchData() {
  try {
    let response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error('ネットワークエラー');
    }
    let data = await response.json();
    return data;
  } catch (error) {
    console.error('エラーが発生しました:', error);
    // フォールバックデータを返す
    return { data: 'フォールバックデータ' };
  }
}

この例では、エラーが発生した場合にフォールバックデータを返すようにしています。

再試行メカニズムの実装

ネットワークエラーなど、一時的な問題に対しては、再試行メカニズムを実装することが有効です。

async function fetchDataWithRetry(url, retries = 3) {
  for (let i = 0; i < retries; i++) {
    try {
      let response = await fetch(url);
      if (!response.ok) {
        throw new Error('ネットワークエラー');
      }
      return await response.json();
    } catch (error) {
      console.error(`試行 ${i + 1} でエラーが発生しました:`, error);
      if (i === retries - 1) throw error;  // 最後の試行でも失敗した場合はエラーをスロー
    }
  }
}

fetchDataWithRetry('https://api.example.com/data');

この例では、指定された回数だけ再試行を行い、最終的に成功しなければエラーをスローします。

次のセクションでは、実際のプロジェクトにおけるAsync/Awaitとエラーハンドリングの応用例を解説します。

応用例

実際のプロジェクトでAsync/Awaitとエラーハンドリングをどのように応用できるかを具体例を交えて解説します。ここでは、データの取得、ユーザーインターフェイスの更新、およびエラーログの保存を含むリアルなシナリオを紹介します。

APIからデータを取得し、UIを更新する

例えば、APIからユーザーデータを取得して、取得したデータをUIに表示するシナリオを考えてみます。この場合、Async/Awaitを使って非同期データの取得を行い、エラーハンドリングを実装することで、ユーザーに適切なフィードバックを提供します。

async function loadUserData(userId) {
  try {
    let response = await fetch(`https://api.example.com/users/${userId}`);
    if (!response.ok) {
      throw new Error('ユーザーデータの取得に失敗しました。');
    }
    let userData = await response.json();
    updateUI(userData);
  } catch (error) {
    console.error('loadUserData内でエラーが発生しました:', error);
    alert('ユーザーデータの取得中にエラーが発生しました。再試行してください。');
  }
}

function updateUI(userData) {
  document.getElementById('userName').textContent = userData.name;
  document.getElementById('userEmail').textContent = userData.email;
}

loadUserData(1);

この例では、loadUserData関数がユーザーデータを取得し、updateUI関数が取得したデータをUIに反映します。エラーが発生した場合は、ユーザーにアラートで通知し、開発者にはコンソールにエラーメッセージを記録します。

エラーログをサーバーに送信する

エラーが発生した際に、エラーログをサーバーに送信して、後から分析できるようにすることも重要です。

async function logErrorToServer(error) {
  try {
    await fetch('https://api.example.com/log', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        message: error.message,
        stack: error.stack,
        time: new Date().toISOString()
      })
    });
  } catch (logError) {
    console.error('エラーログの送信に失敗しました:', logError);
  }
}

async function loadUserData(userId) {
  try {
    let response = await fetch(`https://api.example.com/users/${userId}`);
    if (!response.ok) {
      throw new Error('ユーザーデータの取得に失敗しました。');
    }
    let userData = await response.json();
    updateUI(userData);
  } catch (error) {
    console.error('loadUserData内でエラーが発生しました:', error);
    alert('ユーザーデータの取得中にエラーが発生しました。再試行してください。');
    await logErrorToServer(error);
  }
}

loadUserData(1);

この例では、logErrorToServer関数がエラーログをサーバーに送信します。loadUserData関数でエラーが発生した際に、この関数を呼び出してエラーログを送信します。

非同期操作の連鎖処理

複数の非同期操作を連鎖的に処理するシナリオを考えます。例えば、ユーザー情報を取得した後、そのユーザーの投稿を取得して表示する場合です。

async function loadUserAndPosts(userId) {
  try {
    let userResponse = await fetch(`https://api.example.com/users/${userId}`);
    if (!userResponse.ok) {
      throw new Error('ユーザーデータの取得に失敗しました。');
    }
    let userData = await userResponse.json();
    updateUserUI(userData);

    let postsResponse = await fetch(`https://api.example.com/users/${userId}/posts`);
    if (!postsResponse.ok) {
      throw new Error('ユーザーポストの取得に失敗しました。');
    }
    let postsData = await postsResponse.json();
    updatePostsUI(postsData);
  } catch (error) {
    console.error('loadUserAndPosts内でエラーが発生しました:', error);
    alert('データの取得中にエラーが発生しました。再試行してください。');
    await logErrorToServer(error);
  }
}

function updateUserUI(userData) {
  document.getElementById('userName').textContent = userData.name;
  document.getElementById('userEmail').textContent = userData.email;
}

function updatePostsUI(postsData) {
  let postsList = document.getElementById('userPosts');
  postsList.innerHTML = '';
  postsData.forEach(post => {
    let listItem = document.createElement('li');
    listItem.textContent = post.title;
    postsList.appendChild(listItem);
  });
}

loadUserAndPosts(1);

この例では、ユーザーデータとユーザーポストを順次取得し、それぞれをUIに表示します。エラーが発生した場合には、適切にハンドリングし、エラーログをサーバーに送信します。

これらの応用例により、実際のプロジェクトでAsync/Awaitとエラーハンドリングを効果的に活用する方法を学ぶことができます。次のセクションでは、本記事の内容をまとめます。

まとめ

本記事では、JavaScriptのAsync/Awaitを使ったエラーハンドリングの重要性と具体的な方法について詳しく解説しました。Async/Awaitは、非同期処理をより直感的に記述できる強力なツールであり、try…catch構文を使うことで効果的なエラーハンドリングが可能です。

基本的な使い方から始まり、複数の非同期処理の管理、エラーの再スロー、非同期関数のテスト、エラーハンドリングのベストプラクティス、そして実際のプロジェクトでの応用例まで、多岐にわたるトピックをカバーしました。特に、エラーメッセージの明確化、エラーログの記録、ユーザーへのフィードバック提供、フォールバックと再試行メカニズムの実装など、実践的なテクニックを学びました。

これにより、JavaScriptでの非同期処理におけるエラーハンドリングのスキルを向上させ、安定した高品質なコードを書くための知識を習得できたと思います。非同期処理を適切に管理し、エラーハンドリングをしっかりと実装することで、信頼性の高いアプリケーションを構築しましょう。

JavaScript
エラーハンドリング JavaScript async/await

コメント

コメントする

目次