MENU
  1. ホーム
  2. React
  3. Reactイベントハンドラーの登録と解除：addEventListenerとの違いを徹底解説

Reactイベントハンドラーの登録と解除：addEventListenerとの違いを徹底解説

React

Reactは、モダンなフロントエンド開発において、ユーザーインタラクションを効率的に管理するための強力なライブラリです。その中でも、イベントハンドラーの登録と解除は、Reactのコンポーネントが動的に動作する上で欠かせない要素です。しかし、Reactのイベントハンドリングの仕組みは、従来のDOM操作で使用されるaddEventListenerやremoveEventListenerとは大きく異なります。本記事では、Reactにおけるイベントハンドラーの基本的な仕組みから、具体的な登録・解除方法、従来のDOM APIとの違い、さらに応用的なイベント管理のベストプラクティスまでを詳しく解説します。Reactを使ったアプリケーション開発で、イベント管理をより効果的に行うための知識を習得しましょう。

目次

Reactのイベントハンドラーの基本

Reactのイベントハンドラーは、Reactの独自イベントシステムであるSyntheticEventを通じて処理されます。この仕組みは、ブラウザのネイティブイベントを抽象化し、一貫性のあるAPIを提供することで、さまざまなブラウザ間の違いを吸収します。

イベントハンドラーの特長

  1. SyntheticEventによる統一管理
    Reactは、ブラウザごとに異なるイベント仕様を統一するため、SyntheticEventオブジェクトを使用します。このオブジェクトは、ネイティブイベントと同じように扱えますが、追加の機能や最適化が含まれています。
  2. 宣言的なアプローチ
    イベントハンドラーは、コンポーネントのJSX内で直接宣言します。これにより、コードの可読性が向上し、ビューとロジックを明確に分離できます。
  3. パフォーマンスの最適化
    Reactは、イベントリスナーをコンポーネントごとにではなく、仮想DOM全体にまとめて登録します。これにより、パフォーマンスが向上します。

基本的な使用例

以下は、Reactでボタンのクリックイベントを処理するシンプルな例です。

import React from 'react';

function App() {
  const handleClick = () => {
    alert('ボタンがクリックされました！');
  };

  return (
    <button onClick={handleClick}>クリックしてください</button>
  );
}

export default App;

注意点

  • Reactでは、キャメルケースでイベントを指定します（例: onClick）。
  • イベントハンドラーは、JavaScriptの関数を直接参照します。
  • SyntheticEventオブジェクトはイベント処理後に破棄されるため、非同期処理で使用する場合はイベントを保存する必要があります。

Reactのイベントハンドラーの基本を理解することで、Reactの動的なインタラクションを効果的に実装できます。

イベントハンドラーの登録方法

Reactでは、イベントハンドラーをJSX内で宣言的に設定します。このアプローチにより、ビューのロジックがコンポーネントの中にまとまり、コードの可読性とメンテナンス性が向上します。

基本的な登録方法

イベントハンドラーの設定は、以下の手順で行います。

  1. イベント名はキャメルケースで記述（例: onClick、onChange）。
  2. 関数を直接渡すか、関数定義を使用。

以下に、基本的な使用例を示します。

import React from 'react';

function App() {
  const handleInputChange = (event) => {
    console.log('入力内容:', event.target.value);
  };

  return (
    <div>
      <input type="text" onChange={handleInputChange} placeholder="テキストを入力" />
    </div>
  );
}

export default App;

イベントハンドラーのクラスコンポーネントでの使用例

クラスコンポーネントを使用する場合、イベントハンドラーは通常メソッドとして定義されます。また、thisのコンテキストをバインドする必要があります。

import React, { Component } from 'react';

class App extends Component {
  constructor(props) {
    super(props);
    this.state = { count: 0 };
    this.handleButtonClick = this.handleButtonClick.bind(this);
  }

  handleButtonClick() {
    this.setState((prevState) => ({ count: prevState.count + 1 }));
  }

  render() {
    return (
      <div>
        <button onClick={this.handleButtonClick}>カウント: {this.state.count}</button>
      </div>
    );
  }
}

export default App;

イベントハンドラーを匿名関数で渡す場合

JSX内で匿名関数を使用することもできますが、レンダリングごとに新しい関数が生成されるため、パフォーマンスに影響を与える可能性があります。

<button onClick={() => console.log('クリックされました！')}>クリック</button>

注意点

  1. イベントハンドラーのバインド
    クラスコンポーネントでは、関数を渡す際にbindやアロー関数でコンテキストを固定する必要があります。
  2. 関数の参照
    毎回新しい関数を作成すると、子コンポーネントの不要な再レンダリングを引き起こす場合があります。可能であれば、関数を変数として宣言し、再利用を心がけましょう。

Reactのイベントハンドラーの登録方法を正しく理解することで、意図した通りの動作を簡単に実現できます。

イベントハンドラーの解除方法

Reactでは、通常、イベントハンドラーの解除は不要です。これは、Reactがコンポーネントのライフサイクルを管理し、不要になったイベントリスナーを自動的にクリーンアップするためです。しかし、特定の状況では手動でイベントハンドラーを解除する必要がある場合があります。

Reactでのイベントハンドラー解除の基本

Reactの独自のイベントシステム（SyntheticEvent）は、コンポーネントがアンマウントされる際に関連するイベントリスナーを自動的に解除します。そのため、基本的には開発者が手動で解除を行う必要はありません。

ただし、以下の場合には手動で解除を行う必要があります。

  • ブラウザのネイティブイベントをaddEventListenerで直接登録した場合
  • カスタムイベントリスナーを使用した場合

addEventListenerを使用したイベントハンドラーの解除

Reactの外でブラウザのネイティブイベントを登録した場合は、removeEventListenerを使って明示的に解除する必要があります。

以下は、スクロールイベントの登録と解除を行う例です。

import React, { useEffect } from 'react';

function App() {
  useEffect(() => {
    const handleScroll = () => {
      console.log('スクロール中');
    };

    // イベントを登録
    window.addEventListener('scroll', handleScroll);

    // クリーンアップ関数でイベントを解除
    return () => {
      window.removeEventListener('scroll', handleScroll);
    };
  }, []); // 空の依存配列により、マウント時とアンマウント時のみ実行される

  return <div style={{ height: '200vh' }}>スクロールしてみてください</div>;
}

export default App;

クラスコンポーネントでの解除例

クラスコンポーネントでは、componentDidMountとcomponentWillUnmountライフサイクルメソッドを使用します。

import React, { Component } from 'react';

class App extends Component {
  handleScroll = () => {
    console.log('スクロール中');
  };

  componentDidMount() {
    window.addEventListener('scroll', this.handleScroll);
  }

  componentWillUnmount() {
    window.removeEventListener('scroll', this.handleScroll);
  }

  render() {
    return <div style={{ height: '200vh' }}>スクロールしてみてください</div>;
  }
}

export default App;

注意点

  1. 同一の関数参照が必要
    removeEventListenerでは、addEventListenerで登録したのと同じ関数を渡す必要があります。匿名関数を使用すると、解除が正しく行われないので注意してください。
  2. クリーンアップのタイミング
    useEffectやcomponentWillUnmountを使用して、イベントリスナーを適切なタイミングで解除することが重要です。

Reactの基本的な設計ではイベント解除が不要なケースが多いですが、特定の状況では正しく解除を行うことで、メモリリークや予期しない動作を防ぐことができます。

addEventListenerとremoveEventListenerの基本

従来のJavaScriptでは、DOM要素にイベントリスナーを登録するためにaddEventListenerとremoveEventListenerを使用します。これらは、イベントの登録と解除を手動で制御できる柔軟な仕組みを提供しますが、適切に使用しないと問題を引き起こす場合があります。

addEventListenerの仕組み

addEventListenerは、指定したイベントタイプ（例: click, scroll）に対してコールバック関数を登録します。この関数はイベントが発生した際に実行されます。

以下は基本的な使用例です。

const button = document.querySelector('button');

const handleClick = () => {
  console.log('ボタンがクリックされました！');
};

button.addEventListener('click', handleClick);

オプションパラメータ

addEventListenerには、第三引数としてオプションを渡すことができます。例:

  • capture: イベントがキャプチャフェーズで発生するかどうかを指定。
  • once: イベントが一度だけ実行されるように設定。
  • passive: デフォルト動作（例: スクロール）を妨げないようにする。
button.addEventListener('click', handleClick, { once: true });

removeEventListenerの仕組み

removeEventListenerは、addEventListenerで登録したイベントリスナーを解除します。ただし、解除するためには、以下の条件が満たされている必要があります。

  1. 同じイベントタイプを指定すること。
  2. 同じ関数参照を渡すこと。
  3. 同じオプションを使用すること。
button.removeEventListener('click', handleClick);

匿名関数を使用すると解除ができないため、必ず名前付き関数を使用してください。

// 匿名関数は解除不可
button.addEventListener('click', () => console.log('クリック'));
button.removeEventListener('click', () => console.log('クリック')); // 無効

手動管理の課題

  1. イベントリスナーの漏れ
    登録したリスナーを解除しないと、不要なイベント処理が続き、メモリリークを引き起こす可能性があります。
  2. 複数のリスナーの競合
    同じイベントに対して複数のリスナーが登録されていると、意図しない動作を引き起こす場合があります。

実用例: スクロールイベントの登録と解除

以下は、ページのスクロール時にイベントリスナーを動的に管理する例です。

const handleScroll = () => {
  console.log('スクロール中');
};

// イベント登録
window.addEventListener('scroll', handleScroll);

// イベント解除
window.removeEventListener('scroll', handleScroll);

Reactではどう違うのか

従来のDOM操作におけるイベントリスナーは柔軟性がありますが、Reactではこれらを直接使用するのではなく、JSX内で宣言的にイベントを管理します。ReactのイベントハンドリングはSyntheticEventにより最適化され、基本的に手動での解除を行う必要がありません。

次のセクションでは、ReactとaddEventListenerの違いを深掘りしていきます。

ReactとaddEventListenerの違い

Reactのイベントハンドリングと従来のDOM操作で使用されるaddEventListenerには、基本的な動作や設計思想において大きな違いがあります。これらの違いを理解することで、Reactのイベント管理をより効率的に活用できます。

1. イベントリスナーの登録方法

Reactでは、イベントリスナーはJSX内で直接宣言します。一方、addEventListenerでは、JavaScriptで明示的に登録を行う必要があります。

  • Reactの例:
<button onClick={() => console.log('クリックされました！')}>クリック</button>
  • addEventListenerの例:
const button = document.querySelector('button');
button.addEventListener('click', () => console.log('クリックされました！'));

Reactは宣言的な記述を採用しているため、ビューとロジックが統一され、コードの可読性が向上します。

2. イベントシステム

ReactはSyntheticEventという独自のイベントシステムを採用しており、これにより以下のメリットを得ています。

  • ブラウザ間の互換性: Reactはブラウザごとのイベントの違いを抽象化し、一貫性のあるAPIを提供します。
  • パフォーマンス最適化: Reactは、1つのグローバルイベントリスナーで全てのイベントを管理し、必要な場合のみリスナーを呼び出します。
  • ネイティブのaddEventListenerは、登録する要素ごとにリスナーが作成され、メモリ使用量やパフォーマンスに影響を与える可能性があります。

3. イベントハンドラーの自動クリーンアップ

  • React: Reactはコンポーネントがアンマウントされる際にイベントリスナーを自動的に解除します。そのため、手動で解除を行う必要がありません。
  • addEventListener: 明示的にremoveEventListenerを呼び出してリスナーを解除する必要があります。解除を忘れるとメモリリークが発生する可能性があります。

Reactの例（クリーンアップ不要）:

const MyComponent = () => (
  <button onClick={() => console.log('クリックされました！')}>クリック</button>
);

addEventListenerの例（手動クリーンアップが必要）:

const handleClick = () => console.log('クリックされました！');
button.addEventListener('click', handleClick);
button.removeEventListener('click', handleClick);

4. イベント伝播

Reactのイベントはすべてバブリングフェーズで発生します（キャプチャフェーズはサポートされていません）。一方、addEventListenerでは、キャプチャフェーズを指定することが可能です。

  • React:
<button onClick={(e) => console.log('バブリングのみ対応')}>クリック</button>
  • addEventListener（キャプチャフェーズ指定）:
element.addEventListener('click', handleClick, { capture: true });

5. パフォーマンス

Reactは、イベントリスナーを仮想DOMで一元管理するため、ネイティブのaddEventListenerを要素ごとに使用する場合に比べて、パフォーマンスの向上が期待できます。特に、大量の要素がある場合や頻繁にイベントリスナーを変更する場合に効果的です。

ReactでaddEventListenerを使用する場合

特殊なケースでは、ReactでaddEventListenerを使用することがあります。この場合は、Reactのライフサイクル（useEffectやcomponentDidMount）を利用して適切に管理する必要があります。

例:

import { useEffect } from 'react';

const MyComponent = () => {
  useEffect(() => {
    const handleClick = () => console.log('ネイティブイベント');
    window.addEventListener('click', handleClick);

    return () => {
      window.removeEventListener('click', handleClick); // クリーンアップ
    };
  }, []);

  return <div>クリックしてください</div>;
};

まとめ

  • Reactは宣言的なイベント管理とSyntheticEventにより、イベント処理を効率化します。
  • addEventListenerは細かい制御が可能ですが、手動での管理が必要です。
  • Reactの仕組みを理解しつつ、必要に応じてaddEventListenerを組み合わせることで、柔軟なイベント管理が可能になります。

ReactのSyntheticEventとは

ReactのSyntheticEventは、React独自のイベントシステムであり、ネイティブDOMイベントを抽象化して提供する仕組みです。これにより、ブラウザ間の違いを吸収し、一貫性のあるイベント処理を可能にします。

SyntheticEventの仕組み

Reactは、ブラウザのネイティブイベントをキャプチャし、それをラップしたSyntheticEventオブジェクトを生成します。このオブジェクトは、ネイティブイベントと同様のプロパティやメソッド（例: type, target, preventDefault）を持ちながらも、React独自の最適化が加えられています。

特徴

  1. クロスブラウザ対応
    SyntheticEventは、ブラウザごとに異なるイベントの振る舞いを統一します。これにより、コードがどのブラウザでも一貫して動作します。
  2. イベントのプーリング
    SyntheticEventはパフォーマンス向上のためにプーリング（再利用）されます。イベント処理後、SyntheticEventのプロパティはリセットされるため、非同期処理で使用する場合はデータをコピーして保存する必要があります。
  3. バブリングのみのサポート
    SyntheticEventはバブリングフェーズでのみ動作します。ネイティブイベントのキャプチャフェーズを必要とする場合は、addEventListenerを使用する必要があります。

SyntheticEventの使用例

以下の例では、SyntheticEventを利用してクリックイベントを処理します。

import React from 'react';

function App() {
  const handleClick = (event) => {
    console.log('イベントタイプ:', event.type);
    console.log('クリックされた要素:', event.target);
    event.preventDefault();
  };

  return <button onClick={handleClick}>クリック</button>;
}

export default App;

ネイティブイベントとの比較

SyntheticEventを使用する場合、プロパティやメソッドの使用感はネイティブイベントとほぼ同じです。

const handleClick = (event) => {
  console.log(event.type); // SyntheticEvent: click
  console.log(event.nativeEvent.type); // ネイティブイベント: click
};

SyntheticEventの注意点

1. イベントプーリングによる制限

SyntheticEventは再利用されるため、非同期処理でイベント情報を使用する場合、事前に必要なデータをコピーする必要があります。

例:

const handleClick = (event) => {
  event.persist(); // プーリングを無効化
  setTimeout(() => {
    console.log(event.type); // プーリングが無効化されるため参照可能
  }, 1000);
};

2. ネイティブイベントのキャプチャフェーズのサポートなし

SyntheticEventはキャプチャフェーズをサポートしていません。キャプチャフェーズを使用する必要がある場合、ネイティブのaddEventListenerを利用してください。

SyntheticEventの利点

  • 簡易性: ネイティブイベントAPIの複雑さを軽減。
  • 一貫性: すべてのブラウザで一貫した動作を保証。
  • 効率性: 仮想DOMとの連携で効率的なイベント処理を実現。

SyntheticEventの欠点

  • プーリングの理解が必要。
  • 特殊なケースではネイティブイベントに頼る必要がある。

まとめ

ReactのSyntheticEventは、ネイティブイベントAPIを抽象化し、イベント処理の簡易化と効率化を実現する強力な仕組みです。一貫性のあるイベント処理が可能な一方で、特定のケースではネイティブイベントを使用する必要があることを理解しておくと、より柔軟なアプリケーション開発が可能になります。

応用例：イベント管理のベストプラクティス

Reactでのイベント管理を効率化し、バグを防ぐためには、適切なベストプラクティスを採用することが重要です。ここでは、イベントハンドラーの効果的な使用方法やパフォーマンスを向上させるテクニックを具体例とともに紹介します。

1. イベントハンドラーの関数を再利用する

レンダリングごとに新しい関数を生成すると、不要な再レンダリングを引き起こす場合があります。特に子コンポーネントに関数を渡す際は、関数の参照が変わらないように工夫する必要があります。

対応例: useCallbackの使用

useCallbackフックを使用して、関数のメモ化を行います。

import React, { useState, useCallback } from 'react';

function App() {
  const [count, setCount] = useState(0);

  const increment = useCallback(() => {
    setCount((prev) => prev + 1);
  }, []);

  return (
    <div>
      <button onClick={increment}>カウント: {count}</button>
    </div>
  );
}

export default App;

2. イベントリスナーを動的に追加・解除する

特定の条件下でのみイベントリスナーを有効にする場合、Reactのライフサイクルを活用してイベントリスナーを適切に管理します。

例: useEffectを使ったリスナーの動的管理

import React, { useEffect, useState } from 'react';

function App() {
  const [isListening, setIsListening] = useState(false);

  useEffect(() => {
    const handleScroll = () => console.log('スクロール中');
    if (isListening) {
      window.addEventListener('scroll', handleScroll);
    } else {
      window.removeEventListener('scroll', handleScroll);
    }

    return () => {
      window.removeEventListener('scroll', handleScroll); // クリーンアップ
    };
  }, [isListening]);

  return (
    <div>
      <button onClick={() => setIsListening((prev) => !prev)}>
        {isListening ? '停止' : '開始'}
      </button>
      <div style={{ height: '200vh' }}>スクロールしてみてください</div>
    </div>
  );
}

export default App;

3. SyntheticEventとネイティブイベントの併用

Reactのイベントシステムでカバーできない特殊なシナリオでは、ネイティブのaddEventListenerを組み合わせます。

例: キーボードショートカットの実装

import React, { useEffect } from 'react';

function App() {
  useEffect(() => {
    const handleKeyDown = (event) => {
      if (event.key === 'Escape') {
        console.log('Escキーが押されました');
      }
    };

    document.addEventListener('keydown', handleKeyDown);

    return () => {
      document.removeEventListener('keydown', handleKeyDown); // クリーンアップ
    };
  }, []);

  return <div>Escキーを押してみてください</div>;
}

export default App;

4. イベントハンドラーに引数を渡す

イベントハンドラーに動的なデータを渡す場合は、関数をラップして実現します。

例: 動的な引数を使用したイベント処理

function App() {
  const handleClick = (message) => {
    console.log(message);
  };

  return (
    <div>
      <button onClick={() => handleClick('ボタン1がクリックされました')}>ボタン1</button>
      <button onClick={() => handleClick('ボタン2がクリックされました')}>ボタン2</button>
    </div>
  );
}

export default App;

5. 複数のイベント処理を統一管理する

多くのイベント処理を一箇所で管理することで、コードの簡潔性と保守性を向上させます。

例: ハンドラーの統一

function App() {
  const handleEvent = (event) => {
    switch (event.type) {
      case 'mouseenter':
        console.log('マウスが入りました');
        break;
      case 'mouseleave':
        console.log('マウスが離れました');
        break;
      default:
        break;
    }
  };

  return (
    <div
      onMouseEnter={handleEvent}
      onMouseLeave={handleEvent}
    >
      ホバーしてみてください
    </div>
  );
}

export default App;

まとめ

Reactでのイベント管理を最適化するには、再レンダリングの抑制、ライフサイクル管理、必要に応じたネイティブイベントとの併用が鍵となります。これらのベストプラクティスを活用し、効率的でバグの少ないイベント処理を実現しましょう。

問題解決：イベント重複やメモリリークの防止

イベント管理でよく発生する問題には、イベントリスナーの重複やメモリリークがあります。これらの問題は、アプリケーションのパフォーマンス低下や予期しない動作を引き起こすため、適切に対処することが重要です。

1. 問題：イベントリスナーの重複

イベントリスナーが複数回登録されると、同じイベントで複数のハンドラーが実行され、意図しない動作を引き起こす可能性があります。

原因例

以下のように、イベントが重複して登録されるケースがあります。

const handleClick = () => console.log('クリックされました');
document.querySelector('button').addEventListener('click', handleClick);
// さらに別の場所で登録
document.querySelector('button').addEventListener('click', handleClick);

このコードでは、1回のクリックで2つのログが出力されます。

解決策

イベントを登録する前に、リスナーが既に存在しているか確認するか、確実に解除するようにします。

const handleClick = () => console.log('クリックされました');
const button = document.querySelector('button');

// 登録する前に必ず解除
button.removeEventListener('click', handleClick);
button.addEventListener('click', handleClick);

Reactでは、イベントリスナーがコンポーネントの再レンダリング時に上書きされるため、通常この問題は発生しません。

2. 問題：メモリリーク

イベントリスナーを解除せずにコンポーネントがアンマウントされると、メモリリークが発生し、パフォーマンスに影響を与えます。

原因例

ネイティブのaddEventListenerを使用した場合、リスナーが解除されずに残ることがあります。

import React, { useEffect } from 'react';

function App() {
  useEffect(() => {
    const handleScroll = () => console.log('スクロール中');
    window.addEventListener('scroll', handleScroll);

    // クリーンアップがない場合、メモリリークが発生
  }, []);

  return <div>スクロールしてください</div>;
}

解決策

ReactのuseEffectフックでクリーンアップ関数を指定します。

import React, { useEffect } from 'react';

function App() {
  useEffect(() => {
    const handleScroll = () => console.log('スクロール中');
    window.addEventListener('scroll', handleScroll);

    // クリーンアップでリスナーを解除
    return () => {
      window.removeEventListener('scroll', handleScroll);
    };
  }, []);

  return <div>スクロールしてください</div>;
}

3. 問題：無効なリスナー参照

匿名関数を使用すると、リスナーを解除できなくなる場合があります。

原因例

匿名関数は参照が異なるため、removeEventListenerでは解除されません。

button.addEventListener('click', () => console.log('クリックされました'));
button.removeEventListener('click', () => console.log('クリックされました')); // 解除されない

解決策

名前付き関数を使用することで、解除が正しく行われます。

const handleClick = () => console.log('クリックされました');
button.addEventListener('click', handleClick);
button.removeEventListener('click', handleClick);

4. 問題：大量のイベントリスナー登録

大量のDOM要素に対して個別にイベントリスナーを登録すると、パフォーマンスが低下します。

解決策

イベントデリゲーションを使用して、親要素でイベントを管理します。

const list = document.querySelector('ul');

list.addEventListener('click', (event) => {
  if (event.target.tagName === 'LI') {
    console.log('リストアイテムがクリックされました:', event.target.textContent);
  }
});

Reactでは、イベントシステムが仮想DOMで一元管理されているため、これを手動で行う必要はありません。

5. 問題：不適切な依存関係管理

useEffectで依存配列を正しく指定しないと、不要なリスナーの登録や解除が繰り返されることがあります。

解決策

依存配列を正確に指定し、意図した挙動を保つようにします。

import React, { useEffect, useState } from 'react';

function App() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    const handleClick = () => console.log('カウント:', count);
    window.addEventListener('click', handleClick);

    return () => {
      window.removeEventListener('click', handleClick);
    };
  }, [count]); // 必ず最新の依存を指定

  return <button onClick={() => setCount((prev) => prev + 1)}>カウント: {count}</button>;
}

まとめ

イベントリスナーの重複やメモリリークを防ぐためには、イベント管理の基本を正しく理解し、クリーンアップや依存関係を適切に管理することが重要です。これらの問題を回避することで、アプリケーションのパフォーマンスと安定性が向上します。

まとめ

Reactにおけるイベントハンドラーの管理は、アプリケーションの動作やパフォーマンスに直接影響を与える重要な要素です。本記事では、Reactの独自イベントシステムであるSyntheticEventの仕組みから、イベントリスナーの登録や解除、従来のaddEventListenerとの違い、そして応用的な管理方法やベストプラクティスまで詳しく解説しました。

適切なイベント管理を行うことで、重複やメモリリークといった問題を防ぎ、効率的で保守性の高いコードを書くことが可能になります。Reactのイベントシステムを最大限に活用し、実用的なアプリケーション開発に役立ててください。

React
React addEventListener イベントハンドラー

コメント

コメントする

目次