MutationObserver の使い方

DOM の変化を監視して、変化が発生すればコールバック関数を呼び出すことができる MutationObserver の使い方に関する解説のような覚書です。observe() メソッドの詳細や MutationObserver の使用例などを掲載しています。

最終更新：2025年3月28日

作成日：2022年12月24日

MutationObserver とは

MutationObserver は DOM の変化（Mutation）を監視（Observe）し、DOM に変化があった場合にコールバック関数を呼び出す組み込みオブジェクト（Built-in Object）です。

MutationObserver を使用すると、指定された DOM（ノード）を監視して DOM が動的に変更された際に、その変化に応じて何らかの処理を実行する（コールバック関数を呼び出す）ことができます。

現時点では主要なブラウザのほどんどで MutationObserver を利用することができます。

MutationObserver 関連リンク

参考サイト

その他の Observer のページ

MutationObserver の使い方

大まかな使い方は以下になります。

1. コンストラクターでインスタンス（オブザーバー）を生成
  • コンストラクター MutationObserver() を使って MutationObserver のインスタンスを生成します。
  • コンストラクターには、DOM の変更（変化）を検知した際に実行するコールバック関数を渡します。
2. observe() メソッドを実行して DOM の変化を監視
  • 生成したインスタンスのメソッド observe() を実行して DOM の変化を監視します。
  • observe() の引数には監視対象の DOM とどのような変更を検知するのかを指定します。

生成した MutationObserver のインスタンス（オブザーバー）の observe() メソッドを実行すると、オブザーバーは監視対象の DOM を監視し、変更を検知するとコールバック関数を実行します。監視を停止するには disconnect() メソッドを実行します。

以下は body 及びその子孫ノードを監視して変更が発生したら、コールバック関数でその変更の内容をコンソールに出力する例です。

コールバック関数 には変更を検知したら実行する処理を記述します。

コールバック関数の第一引数には発生した変化の内容を表す MutationRecord オブジェクトの配列が渡されるので、この例では forEach() で各 MutationRecord（変化の内容）を出力しています。

コンストラクター MutationObserver() には、コールバック関数を渡して MutationObserver のインスタンス（オブザーバー ）を生成します。

observe() メソッドの第一引数には監視対象の DOM ノードを、第二引数には監視のオプションオブジェクトを指定します。この例では監視対象として body を指定し、第二引数には全ての変更を監視するように childList、attributes、characterData に true を指定しています。

また、body 及びその子孫ノードを監視するように subtree: true も指定しています。

  1. //コールバック関数
  2. const callback = (mutations) => {
  3.   //第一引数 mutations は変化の内容を表す MutationRecord オブジェクトの配列
  4.   mutations.forEach((mutation) => {
  5.     //各 MutationRecord オブジェクトを出力
  6.     console.log(mutation);
  7.   })
  8. }
  9.  
  10. //コンストラクターにコールバック関数を渡してオブザーバーを生成
  11. const observer = new MutationObserver(callback);
  12.  
  13. //監視対象の DOM（ノードや要素）この場合は body を監視
  14. const target = document.body;
  15.  
  16. //監視のオプション
  17. const config = {
  18.   childList: true, //対象ノードの子ノードに対する追加・削除の監視を有効に
  19.   attributes: true, //対象ノードの属性に対する変更の監視を有効に
  20.   characterData: true, //対象ノードのテキストデータの変更の監視を有効に
  21.   subtree: true, //対象ノードとその子孫ノードに対する変更の監視を有効に
  22. };
  23.  
  24. //observe() メソッドに監視対象と監視オプションを指定して実行（監視を開始）
  25. observer.observe(target, config);

例えば、以下のような HTML で </body> の直前に上記を script タグに記述すると

  1. <!DOCTYPE html>
  2. <html lang="ja">
  3. <!-- 中略 -->
  4. <body>
  5.   <main>
  6.     <h1>Mutation Observer</h1>
  7.     <p>Lorem ipsum dolor sit amet.</p>
  8.   </main>
  9.   <button>Change</button>
  10. <script>
  11.   //上記の記述（省略）
  12. </script>
  13. </body>
  14. </html>

この例の場合、以下のように表示されます。

変更を何もしていないのに、開発ツールのコンソールタブで確認すると2つの MutationRecord オブジェクトが出力されていますが、これは body を監視対象にしているため、</body> タグの前後の改行を変更と検知してしまうからです（タイミングの問題もあります）。

※ body より下の階層の要素を監視対象にする場合は、このようなことは発生しません。

出力された MutationRecord オブジェクトは左側の ▶ をクリックして展開すると、プロパティを確認できます。最初の MutationRecord を展開して、更に addedNodeds を展開すると data に "\n\n" とあり、改行が追加されたと検知されているのがわかります。

紛らわしいので、HTML の </body> タグの前後の改行を削除して以下のように記述するか、

  1. </script></body></html>

または、以下のように DOMContentLoaded イベントを利用すれば、不要な出力は消えます。

  1. document.addEventListener('DOMContentLoaded', ()=> {
  2.   //コールバック関数
  3.   const callback = (mutations) => {
  4.     mutations.forEach((mutation) => {
  5.       console.log(mutation);
  6.     })
  7.   }
  8.   //オブザーバーを生成
  9.   const observer = new MutationObserver(callback);
  10.   //監視対象
  11.   const target = document.body;
  12.   //監視オプション
  13.   const config = {
  14.     childList: true,
  15.     attributes: true,
  16.     characterData: true,
  17.     subtree: true,
  18.   };
  19.   //監視を開始
  20.   observer.observe(target, config);
  21. })

以下を JavaScript に追加して、ボタンをクリックしたら５つの変更を行うようにます。

  1. //ボタン要素
  2. const button = document.querySelector('button');
  3. //ボタンにクリックイベントのリスナーを設定
  4. button.addEventListener('click', ()=> {
  5.   // body の背景色を変更
  6.   document.body.style.backgroundColor = 'yellow';
  7.   // h1 要素のテキストを変更
  8.   document.querySelector('h1').textContent ='Changed Result';
  9.   // main 要素に p 要素を追加
  10.   const foo = document.createElement('p');
  11.   foo.textContent = 'this is foo!';
  12.   document.querySelector('main').appendChild(foo);
  13.   // ボタン要素に disabled 属性を追加
  14.   button.setAttribute('disabled', true);
  15.   // ボタン要素のテキストデータを変更
  16.   button.firstChild.data = 'Changed!'
  17. });

ボタンをクリックすると、上記により DOM への変更が行われ、コンソールには以下のようにそれぞれの変更に対応する５つの MutationRecord オブジェクトが出力されます。

変更の内容を表す MutationRecord の type には変更の種類（監視オプションで指定した childList、attributes、characterData に対応）、target には対象ノードがセットされます。

例えば、３つ目の MutationRecord を展開して、addedNodes を更に展開すると最初の要素 0: に p とあり、p 要素が１つ追加されたことがわかります。また、target の対象ノードは main 要素であり、変更の種類は childList であることが確認できます。

もし main 要素に対しての要素の追加の変更のみを検知したい場合は、observe() メソッドに以下のように対象に main 要素、オプションに childList: true を指定すれば良いことになります（以下のように指定した場合は、他の４つの変更は検知できなくなります）。

  1. const target = document.querySelector('main');
  2. const config = {
  3.   childList: true,
  4. };
  5. observer.observe(target, config);

コールバック関数では、第一引数に MutationRecord オブジェクトの配列を受け取るので forEach() を使って個々の MutationRecord を調べることができます。

この例では単に MutationRecord を出力しているだけですが、以下は p 要素が追加された場合は、そのテキストが空でなければ、inserted というクラスを追加し、そのテキストをコンソールに出力するコールバックの例です。

MutationRecord のプロパティにセットされる値は変更の種類（type）によって異なるので、値が有効かどうかなど（null でないか等）を確認して必要な処理を記述します。

  1. const callback = (mutations) => {
  2.   mutations.forEach((mutation) => {
  3.     // 変更の種類が childList であれば（もし childList のみを監視していれば、この判定は不要）
  4.     if ( mutation.type === 'childList' ) {
  5.       // addedNodes[0] が存在し、そのタグ名が P であれば
  6.       if(mutation.addedNodes[0] && mutation.addedNodes[0].tagName ==='P') {
  7.         // addedNodes[0] の子ノードの data プロパティが空でなければ
  8.         if(mutation.addedNodes[0].firstChild.data){
  9.           // その p 要素にクラス属性を追加
  10.           mutation.addedNodes[0].setAttribute('class', 'inserted');
  11.           // その p 要素のテキストをコンソールに出力
  12.           console.log(mutation.addedNodes[0].firstChild.data);
  13.         }
  14.       }
  15.     }
  16.     // その他の処理・・・
  17.   })
  18. }

何を監視対象にしてどのオプションを指定するかは、例えば、body や document などの上の階層のノードを監視対象にして、subtree: true を含む全ての監視オプションを有効にし、変更を発生させてコールバック関数で MutationRecord の内容（type や target など）を確認すれば判断できます。

MutationObserver のサンプル

以下は MutationObserver を使って、動的に追加された img 要素の height と width を調べて、横長の場合は landscape、縦長の場合は portrait というクラスをその img 要素に自動的に追加する例です。

この例ではボタンをクリックすると id="photos" の div 要素に画像を動的に追加します（※ この場合、MutationObserver を使わずに、画像を追加する際に縦横比を調べてクラスを追加することもできます）。

HTML 
  1. <div id="photos"></div>
  2. <button id="addImage">Add Image</button>

DOM の変更を検知した際に実行するコールバック関数を定義（2〜23行目）し、MutationObserver() コンストラクターに渡して MutationObserver のインスタンスを生成しています（26行目）。

コンストラクターに渡すコールバック関数は第一引数に DOM の変化の内容を表す MutationRecord オブジェクトの配列を受け取るので、forEach() を使って個々の MutationRecord を調べます。

MutationRecord の addedNodes プロパティには、DOM に追加されたノードの NodeList（配列のようなオブジェクト）がセットされています。

addedNodes プロパティ（にセットされた NodeList）に１つ以上のノードが入っていれば、forEach() を使って個々のノードを調べます（6行目の判定は省略可能です）。

nodeType が1で（ノードが要素の場合）、タグ名が IMG であれば追加されたノードは img 要素なので、画像の load イベントを使って読み込みが完了した時点で縦横比を調べてクラスを追加します（nodeType の判定部分は省略可能です。タグ名は大文字です）。

26行目では、定義したコールバック関数をコンストラクターに渡して、生成した MutationObserver のインスタンスを変数 mo に代入しています。

DOM の監視を開始する observe() メソッドの第一引数には監視対象となる DOM を指定し、第二引数には監視のオプション（どのような変更を検知するか）を指定します。

この例では、id="photos" の div 要素に画像が追加された場合に処理を実行するので、監視対象のノードを id="photos" の div 要素とします。

監視のオプションでは、childList: true を指定して対象ノード（id="photos" の div 要素）の子ノードに対する追加・削除を監視するようにし、また、この例では対象ノードとその子孫ノードも監視するように subtree: true を指定しています。

observe() メソッドに監視対象の DOM と監視のオプションを指定して実行すると、監視が開始され、div#photos に img 要素が追加されるとコールバック関数が実行されます。

JavaScript 
  1. // コールバック関数の定義
  2. const addImageClass = (mutations) => {
  3.   //引数の mutations は DOM の変化の内容を表す MutationRecord オブジェクトの配列
  4.   mutations.forEach( mutation => {
  5.     // MutationRecord オブジェクトの addedNodes プロパティの長さが 1 以上であれば
  6.     if (mutation.addedNodes.length >= 1) {
  7.       //addedNodes（追加されたノードの NodeList）の個々のノードを調べる
  8.       mutation.addedNodes.forEach( addedNode => {
  9.         //追加されたノード（addedNode）が img 要素であれば
  10.         if(addedNode.nodeType === 1 && addedNode.tagName==='IMG') {
  11.           //画像の load イベントで読み込みが完了した時点でクラスを追加
  12.           addedNode.addEventListener('load', () => {
  13.             let imgClass = 'landscape';
  14.             if(addedNode.height > addedNode.width) {
  15.               imgClass = 'portrait'
  16.             }
  17.             addedNode.classList.add(imgClass)
  18.           });
  19.         }
  20.       });
  21.     }
  22.   });
  23. }
  24.  
  25. // コンストラクターにコールバック関数を渡してインスタンスを生成
  26. const mo = new MutationObserver(addImageClass);
  27.  
  28. //監視対象の DOM（ノード）
  29. const moTarget = document.getElementById('photos');
  30.  
  31. // 監視のオプション
  32. const moOption = {
  33.   childList: true, //対象ノードの子ノードに対する追加・削除を監視
  34.   subtree: true  //対象ノードとその子孫ノードも監視
  35. };
  36.  
  37. // 監視対象とオプションを指定して observe() メソッドを実行（監視を開始）
  38. mo.observe(moTarget, moOption);
  39.  
  40. /* 以下はボタンをクリックして画像を動的に追加する処理  */
  41.  
  42. //画像を追加するボタン
  43. const btn = document.getElementById('addImage');
  44.  
  45. //ボタンをクリックして画像を追加
  46. btn.addEventListener('click', () => {
  47.   const img = document.createElement('img');
  48.   img.src = 'images/photo1.jpg';
  49.   moTarget.append(img);
  50. });

この例では、observe() に指定するオプションで subtree: true としているので、例えば div#photos の下に新たに div#nature を作成して、以下のようにそこへ画像を追加する場合もコールバック関数が呼び出されます。

  1. btn.addEventListener('click', () => {
  2.   const img = document.createElement('img');
  3.   img.src = 'images/photo1.jpg';
  4.   //div#nature へ追加
  5.   document.getElementById('nature').append(img);
  6. });

但し、オプションで subtree: true を指定していない場合は、div#photos の子孫ノードは監視されないので、コールバック関数は呼び出されません

また、以下のように img 要素を p 要素でラップして追加した場合は、コールバック関数は呼び出されません。これはコールバック関数の定義（10行目）で、追加されたノードが img 要素かどうかを判定しているためです。

  1. btn.addEventListener('click', () => {
  2.   const img = document.createElement('img');
  3.   img.src = 'images/photo1.jpg';
  4.   const p = document.createElement('p');
  5.   //img 要素を p 要素でラップして追加
  6.   p.append(img);
  7.   moTarget.append(p);
  8. });

img 要素が何らかの要素でラップされて追加された場合にも対応するには、以下のように追加されたノードの子孫を調べて img 要素があれば処理を適用するようにできます。

この場合、追加されたノードを基点に querySelectorAll() を実行しますが、テキストノードなどは querySelectorAll() をプロパティに持っていないので、ノードが要素であるかを確認しています。

  1. const addImageClass = (mutations) => {
  2.   mutations.forEach( mutation => {
  3.     if (mutation.addedNodes.length >= 1) {
  4.       mutation.addedNodes.forEach( addedNode => {
  5.         //ノードが要素であれば
  6.         if(addedNode.nodeType === 1){
  7.           //ノードの子要素から img 要素を取得
  8.           const imgs = addedNode.querySelectorAll('img');
  9.           //ノードの子要素に img 要素があれば
  10.           if(imgs.length >=1 ) {
  11.             imgs.forEach( img => {
  12.               img.addEventListener('load', () => {
  13.                 let imgClass = 'landscape';
  14.                 if(img.height > img.width) {
  15.                   imgClass = 'portrait'
  16.                 }
  17.                 img.classList.add(imgClass)
  18.               });
  19.             })
  20.           }
  21.           //ノードが img 要素の場合
  22.           if(addedNode.tagName==='IMG') {
  23.             addedNode.addEventListener('load', () => {
  24.               let imgClass = 'landscape';
  25.               if(addedNode.height > addedNode.width) {
  26.                 imgClass = 'portrait'
  27.               }
  28.               addedNode.classList.add(imgClass)
  29.             });
  30.           }
  31.         }
  32.       });
  33.     }
  34.   });
  35. }

画像を追加する際に縦横比を調べてクラスを追加する

本題と外れますが、上記の例の場合、MutationObserver を使わなくても、画像を追加する際に縦横比を調べてクラスを追加することができます。

画像の読み込みには、load イベントや Promise などを利用することができます。

  1. btn.addEventListener('click', () => {
  2.   const img = document.createElement('img');
  3.   img.src = 'images/photo1.jpg';
  4.   img.onload = () =>{
  5.     let imgClass = 'landscape';
  6.     if(img.height > img.width) {
  7.       imgClass = 'portrait'
  8.     }
  9.     img.classList.add(imgClass)
  10.     moTarget.append(img);
  11.   }
  12. });
  1. btn.addEventListener('click', () => {
  2.   new Promise((resolve, reject) => {
  3.     const img = document.createElement('img');
  4.     img.src = 'images/photo1.jpg';
  5.     img.onload = () => resolve(img);
  6.     img.onerror = () => reject(new Error(`Error: Image Not Found "${img.src}".`));
  7.   }).then( (img) => {
  8.     let imgClass = 'landscape';
  9.     if(img.height > img.width) {
  10.       imgClass = 'portrait'
  11.     }
  12.     img.classList.add(imgClass)
  13.     moTarget.append(img);
  14.   }).catch(
  15.     (error) => console.log(error.message)
  16.   );
  17. });

コンストラクター MutationObserver()

new 演算子を使用してコンストラクター MutationObserver() にコールバック関数を渡すと、DOM の変化を検知した際にコールバック関数を実行する MutationObserver のインスタンスを作成して返します。

コンストラクターの構文 
  1. const observer = new MutationObserver(callback);

コンストラクターの引数に、直接コールバック関数を記述することもできます。

  1. const observer = new MutationObserver((mutations, observer) => {
  2.   //コールバック関数の処理
  3. });

引数（callback）

対象となる DOM の変更が発生するたびに呼び出されるコールバック関数

戻り値（observer）

MutationObserver のインスタンス（オブザーバー）。

オブザーバー（MutationObserver インスタンス）

MutationObserver() コンストラクターで生成された MutationObserver のインスタンスをオブザーバーと呼びます。MutationObserver のインスタンスでは以下のメソッドを利用できます。

メソッド 説明
observe() 監視を開始し、指定された変更を検知するとコールバック関数を呼び出します。
disconnect() observe() が再び呼び出されるまで監視を停止します。
takeRecords() コールバック関数で処理されていない DOM の変更に一致するすべてのリスト（配列）を返し、変更キューを空にします。

コンストラクターは MutationObserver のインスタンスを返すので、MutationObserver インスタンスのメソッドをチェインして記述することができます。

以下は、コールバック関数やインスタンス、observe() の引数を別途変数に定義して記述しています。

  1. //コールバック関数
  2. const callback = (mutations) => {
  3.   mutations.forEach((mutation) => {
  4.     console.log(mutation);
  5.   })
  6. }
  7. //インスタンスを生成
  8. const observer = new MutationObserver(callback);
  9.  
  10. //監視対象のノード
  11. const target = document.getElementById('foo');
  12.  
  13. //監視のオプション
  14. const config = {
  15.   childList: true,
  16.   subtree: true,
  17. };
  18.  
  19. //監視を開始
  20. observer.observe(target, config);

上記は以下のように、コールバック関数やオプションを引数に直接指定して記述することもできます。

  1. //インスタンスを生成
  2. const observer = new MutationObserver( (mutations) => {
  3.   mutations.forEach((mutation) => {
  4.     console.log(mutation);
  5.   })
  6. });
  7. //監視を開始
  8. observer.observe( document.getElementById('foo'), {
  9.   childList: true,
  10.   subtree: true,
  11. });

コンストラクターの戻り値に observe() をチェインして以下のように記述することもできます。

  1. //インスタンスを生成して監視を開始
  2. const observer = new MutationObserver( (mutations) => {
  3.   mutations.forEach((mutation) => {
  4.     console.log(mutation);
  5.   })
  6. }).observe( document.getElementById('foo'), {
  7.   childList: true,
  8.   subtree: true,
  9. });

observe() メソッド

生成した MutationObserver のインスタンス（オブザーバー）で observe() メソッドを実行すると、DOM の変化の監視を開始し、指定された変更を検知するとコールバック関数を呼び出します。

disconnect() メソッドで停止するまで監視は続きます。停止後、再度 observe() メソッドを呼び出してオブザーバーを再利用することができます。

observe() メソッドを呼び出すには、第一引数（target）に監視対象となる DOM ノードを指定し、第二引数（options）にどのような変更を検知するかを定義したオブジェクトを指定します。

構文 
  1. mutationObserver.observe(target, options)
引数 説明
target DOM ツリー内で変更を監視する対象の DOM（ノードや要素）
options どのような変更を検知するかを真偽値で指定するオプションオブジェクト

第一引数（target）に指定したノードのみが監視されますが、第二引数（options）の subtree: true を指定することでその子孫ノードも監視対象にすることができます。

第二引数（options）には以下のようなどのような変更を検知するかを真偽値で指定するプロパティで構成されたオプションオブジェクトを指定します。

※ 任意のプロパティを指定できます（複数指定可能）が、少なくとも childList、attributes、characterData のいずれか1つは指定する必要があります（これらは MutationRecord の type プロパティの値に対応しています）。

プロパティ 説明
childList 対象ノードの子ノード（テキストノードやコメントノードを含む）に対する変更（追加・削除）の監視を有効にする。デフォルトは false
attributes 対象ノードの属性に対する変更の監視を有効にする。デフォルトは false。※ attributeOldValue:true または attributeFilter を指定する場合は true になるので attributes:true の指定を省略できます
characterData 対象ノードのテキストデータ（#text の data）の変更の監視を有効にする。デフォルトは false。※ characterDataOldValue: true を指定する場合は true になるので characterData: true の指定を省略できます
subtree 対象ノードとその子孫ノードに対する変更の監視を有効にする。デフォルトは false
attributeFilter attributes:true を指定した場合、デフォルトではすべての属性が対象になりますが、このプロパティに監視する特定の属性名の配列を指定して、監視する対象の属性を限定することができます。但し、attributeFilter:[] と空の配列を指定すると、どの属性も監視しません。
attributeOldValue 対象ノードの変更前の属性値を記録する。デフォルトは false
characterDataOldValue 対象ノードの変更前のテキストデータを記録する。デフォルトは false

target と options

observe() メソッドの引数には、どこ（target）で発生したどのような変化を検知するのか（options）を指定します。この指定が適切でないと、期待する変化を検知できない可能性があります。

以下は、引数の監視対象と options の subtree の指定方法により、異なる検知結果になる例です。

どのような変化を検知したかを確認するために、検知した変化の内容（MutationRecord オブジェクト ）をコンソールに出力する以下のようなオブザーバーを生成します。

  1. //コールバック関数
  2. const callback = (mutations) => {
  3.   //引数の mutations は DOM の変化の内容を表す MutationRecord オブジェクトの配列
  4.   mutations.forEach((mutation) => {
  5.     //各 MutationRecord をコンソールに出力
  6.     console.log(mutation);
  7.   })
  8. }
  9. //MutationObserver のインスタンス（オブザーバー）を生成
  10. const observer = new MutationObserver(callback);

以下のような HTML があり、h2 要素のテキストの変更を検出する場合、

  1. <div id="foo">
  2.   <h2>Mutation Observer</h2>
  3. </div>

以下を JavaScript に追加して変更を監視します。

監視対象を h2 要素にして、監視のオプションの childList: true を指定すると h2 要素の子ノード（この場合は Text ノード）の変更を検出することができます。

以下では textContent を使って h2 要素のテキストを変更しています。

  1. //監視対象を h2 要素に
  2. const target = document.querySelector('h2')
  3.  
  4. //監視のオプション
  5. const config = {
  6.   childList: true, //対象ノードの子ノードに対する追加・削除の監視を有効に
  7. };
  8.  
  9. //監視を開始
  10. observer.observe(target, config);
  11.  
  12. // h2 要素のテキストを変更
  13. document.querySelector('h2').textContent = 'New Title';

上記の場合、コンソールには以下が出力され、target は h2、 addedNodes（追加されたノード）が NodeList[text]、 removedNodes（削除されたノード）が NodeList[text] になっていて、上記のテキストの変更は h2 要素のテキストノードが削除・追加される変化として検知されています。

以下のように監視の対象を id="foo" の div 要素（div#foo）に変更すると、h2 要素は div#foo の子孫ノードですが、 h2 要素のテキストは h2 要素の子ノードで、div#foo の子孫ノードではないため、テキストは変更されますが、オブザーバーは変化を検知しません（コンソールには何も出力されません）。

  1. //監視対象を div#foo に変更
  2. const target = document.getElementById('foo');
  3. const config = {
  4.   childList: true,
  5. };
  6. observer.observe(target, config);
  7. // h2 要素のテキストを変更（変化は検知されない）
  8. document.querySelector('h2').textContent = 'New Title';

h2 要素のテキストを textContent で変更するのではなく、以下のように h2 要素自体を置換すると、div#foo の子ノードの変更が発生するので、オブザーバーは変化を検知します。

  1. //h2 要素の生成
  2. const newElem = document.createElement('h2');
  3. //テキストノードを生成して作成した要素に追加
  4. newElem.appendChild(document.createTextNode('New Title'));
  5. //置換対象の親ノードを取得
  6. const parentNode = document.getElementById('foo');
  7. //置換対象のノード （#foo の最初の子要素）
  8. const oldElem = parentNode.firstElementChild;
  9. //既存の h2 要素を生成した h2 要素に置換してテキストを変更
  10. parentNode.replaceChild(newElem, oldElem);

コンソールには以下が出力され、target は div#foo、 addedNodes が NodeList[h2]、 removedNodes が NodeList[h2] になっていて、上記のテキストの変更（h2 要素の置換）は h2 要素が削除・追加される変化として検知されています。

または、監視のオプションの subtree: true を追加で指定して子孫ノードに対する変更の監視を有効にすると、h2 要素も監視の対象になるので、以下の場合でもオブザーバーは変更を検知します。

  1. //監視対象は div#foo
  2. const target = document.getElementById('foo');
  3. const config = {
  4.   childList: true,
  5.   subtree: true, //対象ノードとその子孫ノードに対する変更の監視を有効に
  6. };
  7. observer.observe(target, config);
  8.  
  9. // h2 要素のテキストを変更
  10. document.querySelector('h2').textContent = 'New Title';

コンソールには以下が出力され、target は h2、 addedNodesが NodeList[text]、 removedNodes が NodeList[text] になっていて、最初の例と同じ変化として検知されています。

監視対象と subtree の指定以外にも、どのような変化を検知するかのオプション（childList、attributes、characterData ）の指定により、検知する結果が異なってきます。

文書中の全てのノードの変化を検知

監視対象を document にして、 subtree: true を含む全てのオプションを指定すれば、文書中の全てのノードの変化（ノードの追加・削除、属性の変更、テキストデータの変更）を検知できます。

  1. const observer = new MutationObserver( (mutations) => {
  2.   mutations.forEach((mutation) => {
  3.     console.log(mutation);  //各 MutationRecord をコンソールに出力
  4.   })
  5. }).observe( document, {  // 対象を document に
  6.   childList: true,
  7.   attributes: true,
  8.   characterData: true,
  9.   subtree: true,  // 子孫ノードも監視
  10. });

childList

childList を true に指定すると、対象ノードの子ノード（テキストノードを含む）に対する変更（追加・削除）の監視を有効にします。

先の例同様、どのような変化を検知したかを確認するために、検知した変化の内容（MutationRecord オブジェクト）をコンソールに出力する以下のようなオブザーバーを生成します。

  1. //コールバック関数
  2. const callback = (mutations) => {
  3.   mutations.forEach((mutation) => {
  4.     //各 MutationRecord をコンソールに出力
  5.     console.log(mutation);
  6.   })
  7. }
  8. //MutationObserver のインスタンス（オブザーバー）を生成
  9. const observer = new MutationObserver(callback);

以下のような HTML がある場合、

  1. <div id="foo">
  2.   <h2>Mutation Observer</h2>
  3. </div>

以下を JavaScript に追加して変更を監視します。

監視対象を id="foo" の div 要素にして、監視のオプションの childList: true を指定すると div#foo の子ノードの変更（追加・削除）を検出することができます。

  1. //監視対象のノード
  2. const target = document.getElementById('foo');
  3.  
  4. //監視のオプション
  5. const config = {
  6.   childList: true, //対象ノードの子ノードに対する追加・削除の監視を有効に
  7. };
  8. //監視を開始
  9. observer.observe(target, config);

上記の後に以下のような変更を追加します。

  • p 要素を生成して、div#foo の子ノードとして追加（1〜10行目）
  • div#foo に追加した p 要素のテキスト（子ノード）を変更（13行目）
  • h2 要素のテキスト（子ノード）を変更（18行目）
  • p 要素のスタイル属性を変更（21行目）
  • h2 要素のテキストデータ（子ノードの data プロパティ）を変更（24行目）
  1. //p 要素を生成
  2. const p = document.createElement('p');
  3. //生成した p 要素に id を指定
  4. p.id = 'bar';
  5. //テキストノードを生成（表示するテキスト）
  6. const text = document.createTextNode('Hello from Bar!');
  7. //要素ノード（p 要素）の直下にテキストノードを追加
  8. p.appendChild(text);
  9. //div#foo（監視対象のノード）に生成したノードを追加（※ この変化は検知される）
  10. document.getElementById('foo').appendChild(p);
  11.  
  12. // div#foo に追加した p 要素のテキストを変更
  13. p.textContent = 'Text changed!'
  14.  
  15. //h2 要素
  16. const h2 = document.querySelector('h2');
  17. //h2 要素のテキストを変更
  18. h2.textContent = 'Title changed!'
  19.  
  20. //p 要素のスタイル属性を変更
  21. p.style.color = 'red';
  22.  
  23. //h2 要素のテキストデータ（firstChild.data）を変更
  24. h2.firstChild.data = 'Title changed again!'

この場合、observe() の引数で、監視対象を div#foo、監視オプションを childList: true としているので、div#foo に p 要素を子ノードとして追加した変更（10行目）のみが検知され、以下がコンソールに出力されます。

  • addedNodeds: NodeList[p#bar] 追加されたノード（p 要素）
  • removedNodes: NodeList[] 削除されたノード（削除されていないので空のノードリスト）
  • target: div#foo 監視対象
  • type: "childList" 発生した変更のタイプ

監視のオプションに subtree: true を追加して、対象ノードとその子孫ノードに対する変更の監視を有効にすると、

  1. //監視のオプション
  2. const config = {
  3.   childList: true,
  4.   subtree: true, //追加
  5. };

子孫ノードも監視されるので、p 要素のテキストの変更と、h2 要素のテキストの変更も検知されます。

この場合、テキストの変更はテキストノード（対象ノードの子ノード）の削除と追加の変化として検知されています。以下は p 要素の例ですが、h2 要素の場合も同じです。

  • addedNodeds: NodeList[text] 追加されたノード（テキストノード）
  • removedNodes: NodeList[text] 削除されたノード（テキストノード）
  • target: p#bar 監視対象
  • type: "childList" 発生した変更のタイプ

監視のオプションに attributes: true と characterData: true を追加して、対象ノードの属性に対する変更と対象ノードのテキストデータの変更の監視を有効にすると、

  1. //監視のオプション
  2. const config = {
  3.   childList: true,
  4.   subtree: true,
  5.   attributes: true, //追加
  6.   characterData: true, //追加
  7. };

p 要素のスタイル属性の変更と h2 要素のテキストデータの変更も検知されます。

p 要素のスタイル属性の変更

  • attributeName: style 変更された属性（style）
  • target: p#bar 監視対象
  • type: "attributes" 発生した変更のタイプ

h2 要素のテキストデータの変更

  • target: text 監視対象（テキストデータ）
  • type: "characterData" 発生した変更のタイプ

発生した変更のタイプが childList ではないので（該当する値がないため）、いずれの情報の addedNodeds と removedNodes は空のノードリストになっています。また、その他の値が null になっているプロパティは、発生した変更のタイプにおいて該当する値がないことを意味します。

変更前の値

attributeOldValue:true を指定すると変更前の属性値を記録し、characterDataOldValue:true を指定すると変更前のテキストデータを記録します。

  1. //監視のオプション
  2.   const config = {
  3.     childList: true,
  4.     subtree: true,
  5.     attributeOldValue: true, //変更前の属性値を記録
  6.     characterDataOldValue: true, //変更前のテキストデータを記録
  7.   };

上記のようにオプションを変更すると、出力は以下のようになります。

この例の場合、type:attributes のp#bar の変更前に style 属性は設定されていないので、null になっています（変更前に style が設定されていれば oldValue にセットされます）。

type:characterData の検知の oldValue は確認できます。

childList の変更前の値

type:childList の oldValue は常に null ですが、変更前の値は removedNodes を展開すると確認することができます。この例の場合はノードリストの最初のノードなので、0 を展開すると、data と nodeValue、textContent プロパティに値がセットされているのが確認できます。

以下は type:childList の変更前の値をコールバック関数で出力する例です。

  1. const callback = (mutations) => {
  2.   mutations.forEach((mutation) => {
  3.     console.log(mutation);
  4.     // removedNodes に最初の要素がセットされていれば、
  5.     if(mutation.removedNodes[0]) {
  6.       //data を出力（または nodeValue や textContent でも同じ）
  7.       console.log(mutation.removedNodes[0].data)
  8.     }
  9.   })
  10. }

関連項目：変更前のテキストの値

characterData

characterData を true に指定すると、対象ノードのテキストノードのテキスト（data または nodeValue プロパティ）の変更の監視を有効にします。

先の例同様、どのような変化を検知したかを確認するために、検知した変化の内容（MutationRecord オブジェクト）をコンソールに出力する以下のようなオブザーバーを生成します。

  1. //コールバック関数
  2. const callback = (mutations) => {
  3.   mutations.forEach((mutation) => {
  4.     //各 MutationRecord をコンソールに出力
  5.     console.log(mutation);
  6.   })
  7. }
  8. //MutationObserver のインスタンス（オブザーバー）を生成
  9. const observer = new MutationObserver(callback);

以下のような HTML がある場合、

  1. <div id="foo">
  2.   <h2>Mutation Observer</h2>
  3. </div>

以下のように監視の対象を h2 要素とし、監視のオプションに対象ノードのテキストデータの変更を監視する characterData: true を指定して、h2 要素のテキストを textContent で変更してもオブザーバーは変化を検知しません。

characterData: true は、対象ノードのテキストデータ（characterData を継承する Text や Comment など）の変更を監視します。

対象ノードのテキストデータとは、対象ノードの子ノードであるテキストノードのテキスト（data または nodeValue プロパティ）になります。

以下の場合は対象ノードの子ノードの変更（テキストノードの削除・追加によるテキストの変更）になるため、変化を検知しません。

また、テキストノードのテキストは子孫ではない（テキストノードは子を持つことができない）ので、この場合は subtree: true を指定しても意味がありません。

  1. //監視対象のノード
  2. const target = document.querySelector('h2');
  3. //監視のオプション
  4. const config = {
  5.   characterData: true, //対象ノードのテキストデータの変更の監視を有効に
  6.   subtree: true, //対象ノードとその子孫ノードに対する変更の監視を有効に
  7. };
  8. observer.observe(target, config);
  9.  
  10. // h2 要素のテキストを変更
  11. document.querySelector('h2').textContent = 'New Title';

以下のように、h2 要素のテキストをテキストノード（firstChild）の data やnodeValue、textContent プロパティ を使って変更した場合は、オブザーバーは変化を検知します。

この場合は、監視対象を h2 要素としているので、subtree: true の指定も必要になります。

  1. //監視対象のノード
  2. const target = document.querySelector('h2');
  3. //監視のオプション
  4. const config = {
  5.   characterData: true,
  6.   subtree: true, //この場合は、この指定が必要
  7. };
  8. observer.observe(target, config);
  9.  
  10. //テキストノードの data または nodeValue を変更
  11. document.querySelector('h2').firstChild.data = 'New Title';
  12. //または以下でも同じ
  13. //document.querySelector('h2').firstChild.nodeValue = 'New Title';
  14. //document.querySelector('h2').firstChild.textContent = 'New Title';

上記の場合、コンソールには以下が出力され、target は text（テキストノード）に、type は characterData になっています。 type が characterDataの場合、addedNodes と removedNodes は空のノードリスト（NodeList[]）になります。

subtree: true を指定しない場合は、監視対象をテキストノードにする必要があります。

  1. //監視対象をテキストノードに
  2. const target = document.querySelector('h2').firstChild;
  3. const config = {
  4.   characterData: true,
  5. };
  6. observer.observe(target, config);
  7.  
  8. // テキストノードの data または nodeValue を変更
  9. document.querySelector('h2').firstChild.data = 'New Title';
characterDataOldValue

characterData: true を指定する代わりに、characterDataOldValue: true を指定すれば、変更前のテキストデータを記録することができます。

コールバック内では、変更前のテキストデータは .oldValue でアクセスできます。

  1. const callback = (mutations) => {
  2.   mutations.forEach((mutation) => {
  3.     console.log(mutation);
  4.     //変更前のテキストデータを出力
  5.     console.log('mutation.oldValue: ' + mutation.oldValue)
  6.   })
  7. }
  8. const observer = new MutationObserver(callback);
  9. const target = document.querySelector('h2').firstChild;
  10. const config = {
  11.   characterDataOldValue: true, //変更前のテキストデータを記録
  12. };
  13. observer.observe(target, config);
  14. document.querySelector('h2').firstChild.data = 'New Title';

Text ノード

以下の場合、h2 要素のテキストノードは以下のいずれかで確認できます。 

  1. <h2>Mutation Observer</h2>
  2. <script>
  3. console.dir(document.querySelector('h2').childNodes[0])
  4. console.dir(document.querySelector('h2').firstChild)
  5. console.dir(document.querySelector('h2').lastChild)
  6. </script>

#text を展開すると、data やnodeValue、textContent プロパティが確認できます。また、nodeName は #text、nodeType は 3 であることも確認できます。

contentEditable

contenteditable 属性を指定した編集可能な要素を characterData:true や characterDataOldValue:true を指定して、入力されたテキストによる変更を検知することもできます。

  1. <div class="editable" contentEditable>Edit Here</div>

以下を記述して、ブラウザからその領域のテキストを編集すると、変更が検知されてコンソールに変更の情報が出力されます。

  1. const callback = (mutations) => {
  2.   mutations.forEach((mutation) => {
  3.     console.log(mutation);
  4.   })
  5. }
  6. const observer = new MutationObserver(callback);
  7. //監視対象を contenteditable を指定した要素のテキストノードに
  8. const target = document.querySelector('.editable').firstChild
  9. //監視のオプション
  10. const config = {
  11.   characterDataOldValue: true,
  12. };
  13. observer.observe(target, config);

attributes

attributes を true に指定すると、対象ノードの属性に対する変更の監視を有効にします。

先の例同様、どのような変化を検知したかを確認するために、検知した変化の内容（MutationRecord オブジェクト）をコンソールに出力する以下のようなオブザーバーを生成します。

  1. //コールバック関数
  2. const callback = (mutations) => {
  3.   mutations.forEach((mutation) => {
  4.     //各 MutationRecord をコンソールに出力
  5.     console.log(mutation);
  6.   })
  7. }
  8. //MutationObserver のインスタンス（オブザーバー）を生成
  9. const observer = new MutationObserver(callback);

以下のような HTML があり、 h2 要素の属性の変更を検知する場合、

  1. <div id="foo">
  2.   <h2 class="primary">Mutation Observer</h2>
  3. </div>

監視対象を h2 要素にして、監視のオプションの attributes: true を指定すると h2 要素の属性の変更を検出することができます。

以下では h2 要素に classList.add() でクラス属性を追加しています。

  1. //監視対象を h2 要素に指定
  2. const target = document.querySelector('h2.primary');
  3. //監視のオプション
  4. const config = {
  5.   attributes: true,  //対象ノードの属性に対する変更の監視を有効に
  6. };
  7. //監視を開始
  8. observer.observe(target, config);
  9.  
  10. //h2 要素にクラスを追加
  11. document.querySelector('h2.primary').classList.add('mt-3')

コンソールには以下が出力され、type は attributes、attributeName（属性名）は class、target は h2.primary.mt-3 になっています。

addedNodes と removedNodes は NodeList[]（空のノードリスト）になっていています。

attributeFilter

attributes: true の代わりに attributeFilter: 属性名の配列 を使うと、配列で指定した属性名の属性のみを検知します。

以下の場合、class、title、style 属性を追加していますが、attributeFilter:['class', 'style'] としているので、class と style 属性の変更のみが検知されます。

  1. const config = {
  2.   attributeFilter:['class', 'style']  //class と style 属性のみを監視
  3. };
  4. observer.observe(target, config);
  5.  
  6. const h2 = document.querySelector('h2.primary');
  7. h2.classList.add('mt-3');  // class 属性を追加
  8. h2.setAttribute('title', 'Mutation Observer');  // title 属性を追加
  9. h2.style.color = 'red';  // style 属性を追加

attributeOldValue

attributes: true の代わりに attributeOldValue: true を使うと、変更前の属性値を記録することができます。

コールバック関数内では、変更前の属性値は .oldValue でアクセスできます（characterDataOldValue と同じプロパティ）。

  1. const callback = (mutations) => {
  2.   mutations.forEach((mutation) => {
  3.     //変更前の属性値を出力
  4.     console.log('mutation.oldValue: ' + mutation.oldValue)
  5.     console.log(mutation);
  6.   })
  7. }
  8. const observer = new MutationObserver(callback);
  9. const target = document.querySelector('h2.primary');
  10.  
  11. const config = {
  12.   attributeOldValue: true,   //変更前の属性値を記録
  13. };
  14. observer.observe(target, config);
  15. document.querySelector('h2.primary').classList.add('mt-3')

input 要素の属性

監視オプションの attributes や attributeFilter、attributeOldValue を有効にして、input 要素の value 属性や checked 属性を JavaScript から操作した変更を検知することができます。

ブラウザから入力された変更やチェックされた変更などは検知できませんが、それらは通常の input 要素の change や input などのイベントが使えます。

例えば、以下のような HTML がある場合、

  1. <div id="foo">
  2.   <input type="text" id="name" value="name">
  3.   <input type="checkbox" id="agree" value="agreed"> 同意する
  4. </div>

以下のように監視のオプションに attributes: true を指定すると、input 要素の JavaScript からの変更を検知することができます。

この例では２つの input 要素を監視するので、監視対象を親要素の div#foo にして、subtree: true を指定しています。

  1. const callback = (mutations) => {
  2.   mutations.forEach((mutation) => {
  3.     //各 MutationRecord をコンソールに出力
  4.     console.log(mutation);
  5.   })
  6. }
  7. const observer = new MutationObserver(callback);
  8.  
  9. //親要素の div#foo を監視対象に
  10. const target = document.getElementById('foo');
  11.  
  12. //監視のオプション
  13. const config = {
  14.   attributes: true,  //属性に対する変更の監視を有効にし、変更前の値を記録
  15.   subtree: true,  //子孫ノードに対する変更の監視を有効に
  16. };
  17. observer.observe(target, config);
  18.  
  19. // テキストフィールドの value 属性を変更
  20. document.getElementById('name').setAttribute('value', 'Foo');
  21. // チェックボックスの checked 属性を変更
  22. document.getElementById('agree').setAttribute('checked', true)
  23. // 但し、以下では検知されない
  24. //document.getElementById('agree').checked = true; //検知されない

テキストフィールドの value 属性とチェックボックスの checked 属性の変更が検知されて、以下のように出力されます。

コールバック関数

コンストラクター MutationObserver() に渡すコールバック関数は以下の2つの引数を受け取ります。

引数 説明
mutations 発生した変化の情報を記述した MutationRecord オブジェクトの配列
observer コールバックを実行した MutationObserver のインスタンス（MutationObserver 自身への参照）。必要に応じてコールバック内から自身へアクセスできます（特定の条件で監視を停止・再開する場合など）。必要ない場合は省略することができます。
構文 
  1. const callback = (mutations, observer) => {
  2.   //DOM に変更があった場合に実行する処理
  3. }

MutationRecord

コールバック関数の第一引数 mutations には、発生した DOM の変化の情報を格納した MutationRecord オブジェクトの配列が渡されます。

MutationRecord オブジェクトは以下のようなプロパティがセットされます。

発生した変化（ミューテーション）の type により各プロパティにセットされる値は異なります。

例えば、type が childList の場合は addedNodes と removedNodes のいずれか、または両方のノードリストにノードが含まれますが、その他の type では空のノードリスト（NodeList[]）にります。

MutationRecord の構造は type に関わらず一定なので、type と target 以外の大部分のプロパティの値には null や空のノードリスト（NodeList[]）がセットされています。

MutationRecord のプロパティ
プロパティ 型 説明
type String 発生した DOM の変更の種類を表す以下のいずれかの文字列。
  • attributes： 属性値に対する変更
  • characterData：テキストデータ（data）に対する変更
  • childList：ノードツリーに対する変更
target Node 変更の影響を受けたノード（type に応じて以下のいずれか）。
  • attributes の場合：属性が変更された要素
  • characterData の場合：CharacterData ノード（text など）
  • childList の場合：子ノードが変更されたノード（親ノード）
addedNodes NodeList 追加されたノードのリスト。※ 複数のノードが入っている可能性があります（例えば、DocumentFragment を追加した場合など）。何もノードが追加されていない場合は空のノードリスト NodeList[]
removedNodes NodeList 削除されたノードのリスト。※ 複数のノードが入っている可能性があります。何もノードが削除されていない場合は空のノードリスト NodeList[]
previousSibling Node 追加あるいは削除されたノードの直前にあるノード。該当するノードがなければ null
nextSibling Node 追加あるいは削除されたノードの直後にあるノード。該当するノードがなければ null
attributeName String 変更された属性の名前。該当する属性がなければ null
attributeNamespace String 変更された属性の名前空間（XML の場合）。該当がなければ null
oldValue String 変更前の値（type に応じて以下のいずれか）。
  • attributes の場合：変更された属性の変更前の属性値
  • characterData の場合：変更されたノードの変更前のデータ
  • childList の場合：null
※ この機能が動作するためには observe() メソッドの第二引数で、attributeOldValue または characterDataOldValue が true に設定されている必要があります。

コールバック関数では、第一引数に渡される MutationRecord の配列を調べることで、発生した変更の情報にアクセスすることができます。

以下は body 及びその子孫ノードの変更を監視して、変更を検知したらタイプごとに変更の内容をコンソールに出力する例です。

type が childList の場合は、addedNodes 及び removedNodes には複数のノードが含まれている可能性があるので、forEach() で各ノードを調べています。type が childList 以外の場合は、addedNodes 及び removedNodes は空のノードリストがセットされます。

  1. document.addEventListener('DOMContentLoaded', ()=> {
  2.   //body 及びその子孫ノードを監視して変更を検知したらタイプごとにコンソールに出力
  3.   new MutationObserver((mutations) => {
  4.     //MutationRecord の配列の個々の要素を調べる
  5.     for(const mutation of mutations) {
  6.       console.log('*** 変更の種類： ' + mutation.type + " ***");
  7.       console.log('変更を検知したノード：' + mutation.target.nodeName);
  8.       // type が childList の場合
  9.       if ( mutation.type == 'childList' ) {
  10.         // addedNodes のノードリストにノードが含まれれば
  11.         if (mutation.addedNodes.length >= 1) {
  12.           mutation.addedNodes.forEach((node) => {
  13.             console.log('追加されたノード: ' + node.nodeName);
  14.             //ノードが要素の場合
  15.             if(node.nodeType ===1 && node.textContent) {
  16.               console.log('テキスト: ' + node.textContent);
  17.             }
  18.             //ノードがテキストノードの場合
  19.             else if(node.nodeType ===3) {
  20.               console.log('テキスト: ' + node.data);
  21.               console.log('親ノード: ' + node.parentNode.nodeName);
  22.             }
  23.           })
  24.         }
  25.         // removedNodes のノードリストにノードが含まれれば
  26.         if (mutation.removedNodes.length >= 1) {
  27.           mutation.removedNodes.forEach((node) => {
  28.             console.log('削除されたノード: ' + node.nodeName);
  29.             //ノードが要素の場合
  30.             if(node.nodeType ===1 && node.textContent) {
  31.               console.log('テキスト: ' + node.textContent);
  32.             }
  33.             //ノードがテキストノードの場合
  34.             else if(node.nodeType ===3) {
  35.               console.log('テキスト: ' + node.data);
  36.             }
  37.           })
  38.         }
  39.       }
  40.       // type が characterData の場合
  41.       else if (mutation.type == 'characterData') {
  42.         console.log('変更されたノード： ' + mutation.target.nodeName);
  43.         console.log('変更されたテキストデータ： ' + mutation.target.data );
  44.       }
  45.       // type が attributes の場合
  46.       else if (mutation.type == 'attributes') {
  47.         console.log('変更されたノード： ' + mutation.target.nodeName);
  48.         console.log('変更された属性： ' + mutation.attributeName);
  49.       }
  50.     }
  51.   }).observe(document.body, { //監視対象 を document.body に
  52.     // すべてのタイプの監視を有効にし、子孫ノードの監視も有効に
  53.     attributes: true,
  54.     childList: true,
  55.     characterData: true,
  56.     subtree: true,
  57.   });
  58. });

コールバック関数の例

以下は、div#container の直下にテキストノードが追加されたら、p 要素でラップする例です。

HTML 
  1. <body>
  2.   <div id="container"></div>
  3. </body>

div#container 直下へのテキストノードの追加を監視するので、target には div#container を指定し、オプションは childList: true を指定します。

コールバック関数では、MutationRecord の type が childList の場合は、その addedNodes を調べます。addedNodes は複数のノードが入っている可能性があるノードリストなので forEach() で各ノードを調べ、テキストノードであれば処理を実行します。

JavaScript 
  1. //コールバック関数
  2. const callback = (mutations) => {
  3.   //引数の mutations は MutationRecord の配列なので forEach でループ
  4.   mutations.forEach((mutation) => {
  5.     //console.log('called');
  6.     // MutationRecord の type が childList であれば
  7.     if ( mutation.type === 'childList' ) {
  8.       // addedNodes（ノードリスト）にノードが入っていれば
  9.       if (mutation.addedNodes.length >= 1) {
  10.         // addedNodes に含まれている各ノードを調べる
  11.         mutation.addedNodes.forEach((node) => {
  12.           //console.log(node.nodeType);
  13.           // nodeType が 3（テキストノード）であれば
  14.           if(node.nodeType === 3) {
  15.             //p 要素を生成
  16.             const p = document.createElement('p');
  17.             //p.appendChild(node); //これだとエラーになる
  18.             //生成した p 要素に追加されたテキストノードのテキストを設定
  19.             p.innerText = node.data
  20.             //追加されたテキストノードを p 要素に置換
  21.             node.parentNode.replaceChild(p, node);
  22.           }
  23.         })
  24.       }
  25.     }
  26.   })
  27. }
  28. //MutationObserver のインスタンス（オブザーバー）を生成
  29. const observer = new MutationObserver(callback);
  30.  
  31. //監視対象を div#container に
  32. const target = document.getElementById('container')
  33. //対象ノードの子ノードに対する追加・削除の監視を有効に
  34. const config = {
  35.   childList: true,
  36. };
  37. observer.observe(target, config);

例えば、以下のような変更を記述すると、div#container の直下へのテキストノードの追加なので、変更は検知され、追加されたテキストは p 要素でラップされます。

テキスト以外のノードを追加した場合も childList: true によりコールバック関数は呼び出されますが、 p 要素でラップする処理は実行されません。

  1. //テキストノードを生成（表示するテキスト）
  2. const text = document.createTextNode('Hello document!');
  3. //監視対象（ div#container）の直下にテキストノードを追加
  4. document.getElementById('container').appendChild(text);

ノードの種類

ノードの種類は nodeType で判定できます。以下は一般的なノードの種類です。

※ 要素はノードの種類の１つです

一般的なノードの種類
ノード インターフェース nodeType 定数 nodeType の値
要素ノード Element Node.ELEMENT_NODE 1
属性ノード Attr Node.ATTRIBUTE_NODE 2
テキストノード Text Node.TEXT_NODE 3
コメントノード Coment Node.COMMENT_NODE 8
文書ノード Document Node.DOCUMENT_NODE 9

変更前のテキストの値

以下は div#container の配下の要素でテキストが変更された場合に、変更前のテキストの値をコンソールに出力する例です。

テキストの変更を検知するには、監視オプションに characterDataOldValue:true と childList:true を指定し、対象のノードの子孫ノードも監視対象にするので subtree:true も指定します。

対象ノードのテキストデータが変更された場合は、characterDataOldValue:true により oldValue プロパティで変更前のテキストの値を参照できますが、要素の textContent でテキストを変更した場合は、oldValue プロパティの値は null なので、removedNodes を調べます（変更前の値 ）。

HTML 
  1. <div id="container">
  2.   <p>Lorem ipsum dolor sit amet consectetur adipisicing elit. </p>
  3.   <p>Tenetur at magnam dolores corporis architecto esse.</p>
  4. </div>

MutationRecord の type が childList の場合は removedNodes から、characterData の場合は oldValue から変更前の値を取得できます。

JavaScript 
  1. //コールバック関数
  2. const callback = (mutations) => {
  3.   //引数の mutations は MutationRecord の配列なので forEach でループ
  4.   mutations.forEach((mutation) => {
  5.     // MutationRecord の type が childList であれば
  6.     if ( mutation.type === 'childList' ) {
  7.       // removedNodes にノードが入っていれば
  8.       if (mutation.removedNodes.length >= 1) {
  9.         // removedNodes に含まれている各ノードを調べる
  10.         mutation.removedNodes.forEach((node) => {
  11.           // data プロパティ（テキスト）を出力
  12.           console.log('Old Value : ' + node.data);
  13.         })
  14.       }
  15.     }
  16.     // MutationRecord の type が characterData であれば
  17.     else if ( mutation.type === 'characterData' ) {
  18.       // oldValue プロパティを出力
  19.       if(mutation.oldValue) console.log('Old Value : ' + mutation.oldValue)
  20.     }
  21.   })
  22. }
  23. //MutationObserver のインスタンス（オブザーバー）を生成
  24. const observer = new MutationObserver(callback);
  25.  
  26. //監視対象を div#container に
  27. const target = document.getElementById('container')
  28. //監視のオプション
  29. const config = {
  30.   childList: true,
  31.   characterDataOldValue: true,
  32.   subtree: true
  33. };
  34. observer.observe(target, config);
  35.  
  36. //textContent でテキストを変更
  37. document.querySelectorAll('#container p')[0].textContent = '1st paragraph.'
  38. //テキストノードの data プロパティでテキストを変更
  39. document.querySelectorAll('#container p')[1].firstChild.data = '2nd paragraph';

MutationObserver の使用例

例えば、ページ（ドキュメント）を読み込んだ時点で要素に対してスクリプトを適用している場合、後から動的に追加した要素にはスクリプトは適用されていないので、その効果は反映されません。

そのような場合、MutationObserver を使うと、ページに動的に挿入された要素を検出して、自動的にスクリプトを再度実行することで追加された要素を含むページ全体に効果を適用させることができます。

以下は、対象となる要素が動的に追加された際に MutationObserver を使ってページ読み込み時に実行している関数を再度実行して適用させる例です。

この例の場合、ページ読み込み時に独自に定義したスクロールスパイの関数とスムーススクロールの関数を実行していますが、そのままでは動的に追加した要素は効果が反映されません。

以下では、body 及びその子孫ノードに linkTarget クラスを指定した div 要素を追加する変更を検知すると、自動的にスクロールスパイの関数 ioScrollSpy() とリンク項目を追加してスムーススクロールを適用する関数 addNavigationItem() を実行してページに適用します。

挿入された要素が div.linkTarget かをチェックするには matches() メソッドを使用しています。

18〜23行目は、追加されたノードの子ノードとして div.linkTarget が含まれている場合にも対応するための記述です。

  1. //MutationObserver のコールバック関数
  2. const callback = (mutationsList) => {
  3.   mutationsList.forEach((mutation) => {
  4.     if ( mutation.type == 'childList' ) {
  5.       if (mutation.addedNodes.length >= 1) {
  6.         for(let node of mutation.addedNodes) {
  7.           // 要素ノードのみを対象とし、他のノード（例 テキストノード）はスキップ
  8.           if (!(node instanceof HTMLElement)) continue;
  9.           //if (!(node.nodeType === 1)) continue;
  10.           // 挿入された要素が linkTarget クラスの div 要素かをチェック
  11.           if (node.matches('div.linkTarget')) {
  12.             //スクロールスパイの関数を実行
  13.             ioScrollSpy();
  14.             //ナビゲーションにリンク項目を追加する関数を実行
  15.             addNavigationItem();
  16.           }
  17.           // サブツリーのどこかに linkTarget クラスの div 要素がある場合
  18.           for(let elem of node.querySelectorAll('div.linkTarget')) {
  19.             //スクロールスパイの関数を実行
  20.             ioScrollSpy();
  21.             //ナビゲーションにリンク項目を追加する関数を実行
  22.             addNavigationItem();
  23.           }
  24.         }
  25.       }
  26.     }
  27.   });
  28. }
  29. // コールバック関数を渡してオブザーバーを生成
  30. mo = new MutationObserver(callback);
  31. // 監視対象とオプションを指定して監視を開始
  32. mo.observe( document.body, {
  33.   childList: true, //子ノードに対する変更（追加・削除）の監視を有効に
  34.   subtree: true, //子孫ノードに対する変更の監視を有効に
  35. });

上記のコールバック関数部分は forEach() を使って以下のように記述しても同じです。

  1. const callback = (mutationsList) => {
  2.   mutationsList.forEach((mutation) => {
  3.     if ( mutation.type == 'childList' ) {
  4.       if (mutation.addedNodes.length >= 1) {
  5.         mutation.addedNodes.forEach((node) => {
  6.           // node が要素要素であれば（node.nodeType === 1 と同じ）
  7.           if(node instanceof HTMLElement) {
  8.             // 挿入された要素が linkTarget クラスの div 要素であれば
  9.             if (node.matches('div.linkTarget')) {
  10.               //スクロールスパイの関数を実行
  11.               ioScrollSpy();
  12.               //ナビゲーションにリンク項目を追加する関数を実行
  13.               addNavigationItem();
  14.             }
  15.             // 挿入された要素のサブツリーに linkTarget クラスの div 要素があれば取得
  16.             const linkTarget = node.querySelectorAll('div.linkTarget');
  17.             if(linkTarget.length >=1 ) {
  18.               linkTarget.forEach( () => {
  19.                 ioScrollSpy();
  20.                 addNavigationItem();
  21.               })
  22.             }
  23.           }
  24.         })
  25.       }
  26.     }
  27.   });
  28. }

サンプルを開く

上記サンプルでは、ボタンをクリックすると div.linkTarget を追加します（実際にはこのような使い方はしないと思います）。

  1. <!doctype html>
  2. <html>
  3. <head>
  4. <meta charset="utf-8">
  5. <meta name="robots" content="noindex,nofollow">
  6. <meta name="viewport" content="width=device-width, initial-scale=1">
  7. <meta http-equiv="X-UA-Compatible" content="IE=edge">
  8. <title>IntersectionObserver with MutationObserver 1</title>
  9. <style>
  10. *, *::before, *::after {
  11.   box-sizing: border-box;
  12.   margin: 0;
  13.   padding: 0;
  14. }
  15. html {
  16.   color: #444;
  17. }
  18. body {
  19.   margin-top: 50px;
  20. }
  21. h1 {
  22.   color: #999;
  23.   font-size: 24px;
  24.    margin-bottom: 2rem;
  25. }
  26. h2 {
  27.   margin-bottom: 1rem;
  28. }
  29. p {
  30.   margin-bottom: .5rem;
  31. }
  32. .wrapper {
  33.   max-width: 780px;
  34.   margin: 20px auto 0;
  35.   padding: 0 1rem;
  36. }
  37. .nav-wrapper {
  38.   position: sticky;
  39.   top: 0px;
  40.   width: 100%;
  41.   background-color: #fefefe;
  42.   padding: .5rem 0;
  43. }
  44. .nav {
  45.   width: 100%;
  46.   max-width: 600px;
  47.   display: flex;
  48.   justify-content: flex-start;
  49. }
  50. .contents {
  51.   width: 100%;
  52. }
  53. .nav {
  54.   padding-left: 0;
  55. }
  56. .nav li {
  57.   list-style: none;
  58.   color: #70B466;
  59. }
  60. .nav a {
  61.   display: block;
  62.   width: 100%;
  63.   padding: .25rem .5rem;
  64.   text-decoration: none;
  65.   color: #70B466;
  66. }
  67. .nav a.active {
  68.   color: #D0F0C1;
  69.   background-color: #557E49;
  70. }
  71. .linkTarget {
  72.   margin-top: 4rem;
  73. }
  74. .footer {
  75.   width: 100vw;
  76.   height: 400px;
  77.   background-color: #eee;
  78.   margin-top: 300px;
  79. }
  80. /*トップへスクロールするボタン*/
  81. #scroll-to-top {
  82.   position: fixed;
  83.   right: 15px;
  84.   bottom: 2rem;
  85.   z-index: 100;
  86.   font-size: 0.75rem;
  87.   background-color: #557E49;
  88.   width: 80px;
  89.   height: 50px;
  90.   clip-path: polygon(50% 0%, 0% 100%, 100% 100%);
  91.   color: #fff;
  92.   line-height: 50px;
  93.   text-align: center;
  94.   transition: opacity .4s;
  95.   opacity: .7;
  96.   cursor: pointer;
  97. }
  98. #scroll-to-top:hover {
  99.   opacity: 1;
  100. }
  101. #scroll-to-top p {
  102.   margin-top: 10px;
  103. }
  104. .controls button {
  105.   margin: 20px 20px 0 20px;
  106. }
  107. #addContent {
  108.   background-color: rgb(194, 240, 244);
  109.   border: 1px solid #8394af;
  110.   padding: 8px;
  111. }
  112. .controls input:checked + label {
  113.   color: red;
  114. }
  115. </style>
  116. </head>
  117.  
  118. <body>
  119. <div class="wrapper">
  120.   <h1>IntersectionObserver with MutationObserver 1</h1>
  121.   <nav class="nav-wrapper">
  122.     <ol id="navigation" class="nav">
  123.       <li><a href="#section1">Section 1</a></li>
  124.       <li><a href="#section2">Section 2 </a></li>
  125.       <li><a href="#section3">Section 3</a></li>
  126.     </ol>
  127.   </nav>
  128.   <div class="controls">
  129.     <button id="addContent">Add Content</button>
  130.   </div>
  131.   <main class="contents">
  132.     <div class="linkTarget" id="section1">
  133.       <h2>Section 1</h2>
  134.       <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Tempora dolores quam a dolorem, architecto molestias fugit necessitatibus, deserunt doloremque! Laborum voluptatum, maiores temporibus ab pariatur reiciendis ipsa ad tenetur in.</p>
  135.       <p>Possimus, ipsam a vero quae tempora molestias autem quas quisquam officiis distinctio recusandae, et, consectetur blanditiis maxime, eaque inventore ut. Aut facere, quae architecto unde, dolores autem est ratione voluptatum.</p>
  136.     </div>
  137.     <div class="linkTarget" id="section2">
  138.       <h2>Section 2</h2>
  139.       <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Dolorem natus quos voluptatibus tempore repudiandae aut, vero dolorum magni, exercitationem magnam eveniet, omnis soluta doloremque atque iusto provident expedita sint enim.</p>
  140.       <p>Commodi nulla cupiditate rerum culpa at aspernatur dolorem iusto fuga officiis magni, nihil accusamus impedit repellendus obcaecati quod optio, odit reiciendis porro minima explicabo nesciunt earum, facilis quos ut accusantium!</p>
  141.     </div>
  142.     <div class="linkTarget" id="section3">
  143.       <h2>Section 3</h2>
  144.       <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Quis provident facere molestiae exercitationem eligendi quam perferendis quae enim sed omnis harum rem in officiis veritatis aliquid, corrupti veniam velit deleniti.</p>
  145.       <p>Delectus iusto repellendus quas ipsam! Veritatis a, facilis architecto necessitatibus consequuntur omnis neque aliquid quam exercitationem laboriosam quos magni error numquam enim temporibus, iure cumque modi ipsam soluta dignissimos. Nam!</p>
  146.       <p>Nobis consequatur, esse repudiandae soluta excepturi maiores a in quisquam est natus molestias aspernatur dignissimos, asperiores quasi? Quae nulla mollitia, vero nam eaque incidunt cupiditate consectetur. Repellendus, est dignissimos qui.</p>
  147.     </div>
  148.   </main>
  149. </div>
  150. <div class="footer"></div>
  151. <div id="scroll-to-top"><!--トップへスクロールするボタン-->
  152.   <p>Top</p>
  153. </div>
  154. <script>
  155. //ナビゲーションにリンク項目を追加する関数
  156. const addNavigationItem = () => {
  157.   // .linkTarget の要素の数
  158.   const sectionsCount = document.querySelectorAll('.linkTarget').length;
  159.   // 最後の .linkTarget の要素（追加された要素）
  160.   const addedSection = document.querySelectorAll('.linkTarget')[sectionsCount-1];
  161.   // 最後の .linkTarget の要素（追加された要素）のタイトルのテキスト
  162.   const addedSectionTitle = addedSection.querySelector('h2').textContent;
  163.   //li 要素（リンク項目）の生成
  164.   const li = document.createElement('li');
  165.   //innerHTML で子要素（リンク）を追加
  166.   li.innerHTML = `<a href="#section${sectionsCount}">${addedSectionTitle}</a>`;
  167.   //追加先のノードに生成した要素（リンク項目）を追加
  168.   document.getElementById('navigation').appendChild(li);
  169.   //スムーススクロールの関数を実行
  170.   applySmoothScroll(document.querySelectorAll('a[href^="#"]'));
  171. }
  172.  
  173. /****** MutationObserver の設定 ******/
  174.  
  175. //MutationObserver のコールバック関数
  176. const callback = (mutationsList) => {
  177.   mutationsList.forEach((mutation) => {
  178.     if ( mutation.type == 'childList' ) {
  179.       if (mutation.addedNodes.length >= 1) {
  180.         for(let node of mutation.addedNodes) {
  181.           // 要素ノードのみを対象とし、他のノード（例 テキストノード）はスキップ
  182.           if (!(node instanceof HTMLElement)) continue;
  183.           //if (!(node.nodeType === 1)) continue;
  184.           // 挿入された要素が linkTarget クラスの div 要素かをチェック
  185.           if (node.matches('div.linkTarget')) {
  186.             //スクロールスパイの関数を実行
  187.             ioScrollSpy();
  188.             //ナビゲーションにリンク項目を追加する関数を実行
  189.             addNavigationItem();
  190.           }
  191.           // サブツリーのどこかに linkTarget クラスの div 要素がある場合
  192.           for(let elem of node.querySelectorAll('div.linkTarget')) {
  193.             //スクロールスパイの関数を実行
  194.             ioScrollSpy();
  195.             //ナビゲーションにリンク項目を追加する関数を実行
  196.             addNavigationItem();
  197.           }
  198.         }
  199.       }
  200.     }
  201.   });
  202. }
  203. // コールバック関数を渡してオブザーバーを生成
  204. mo = new MutationObserver(callback);
  205. // 監視対象とオプションを指定して監視を開始
  206. mo.observe( document.body, {
  207.   childList: true, //子ノードに対する変更（追加・削除）の監視を有効に
  208.   subtree: true, //子孫ノードに対する変更の監視を有効に
  209. });
  210.  
  211. //クリックで linkTarget クラスの div 要素を追加するリスナー
  212. document.getElementById('addContent').addEventListener('click', () => {
  213.   //Section の番号（現在の.linkTargetに div を追加した後の数なので１増加）
  214.   let sectionsCount = document.querySelectorAll('.linkTarget').length + 1;
  215.   //div 要素の生成
  216.   const div = document.createElement('div');
  217.   //生成した div 要素にクラス属性を設定
  218.   div.className = 'linkTarget';
  219.   div.id = `section${sectionsCount}`;
  220.   //innerHTML で子要素を追加
  221.   div.innerHTML = `<h2>Section ${sectionsCount}</h2>
  222.   <p>Maiores labore quidem est nemo quia ullam deleniti, ipsum voluptatibus dolorem. Explicabo nisi, possimus. Iusto alias, totam sunt excepturi tempora qui modi autem, ipsum aut doloribus facilis, possimus deserunt atque.</p>
  223.   <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Tempora dolores quam a dolorem, architecto molestias fugit necessitatibus, deserunt doloremque! Laborum voluptatum, maiores temporibus ab pariatur reiciendis ipsa ad tenetur in.</p>`;
  224.   //追加先のノードに生成した要素を追加
  225.   document.querySelector('main.contents').appendChild(div);
  226. });
  227.  
  228. /****** スクロールスパイの関数 ******/
  229. const ioScrollSpy = (rootSelector=null, rootMargin='-25% 0px -75%', targetClass='linkTarget', navSelector='#navigation', activeClass='active') => {
  230.   //監視対象の要素を取得
  231.   const targets = document.querySelectorAll('.' + targetClass);
  232.   //オプション
  233.   const options = {
  234.     root: rootSelector ===null ? null : document.querySelector(rootSelector),
  235.     //上から25%の位置を交差の境界とする
  236.     rootMargin: rootMargin,
  237.     threshold: 0 //デフォルトなので省略可能
  238.   }
  239.   //IntersectionObserver のコールバック関数
  240.   const callback = (entries) => {
  241.     // 交差を検知をしたら
  242.     entries.forEach(entry => {
  243.       //監視対象の要素が領域（境界）と交差していれば（isIntersecting が true の場合）
  244.       if (entry.isIntersecting) {
  245.         //その要素を引数として以下の関数を呼び出してメニューをハイライト
  246.         highlightNavMenu(entry.target);
  247.       }
  248.     });
  249.   }
  250.   //IntersectionObserver のインスタンス（オブザーバー）を生成
  251.   const io = new IntersectionObserver(callback, options);
  252.   //それぞれの監視対象の要素を observe() に指定して監視
  253.   targets.forEach( (target) => {
  254.     io.observe(target);
  255.   });
  256.   //メニュー項目をハイライトする（色を変える）関数
  257.   const highlightNavMenu = (target) => {
  258.     //現在アクティブになっている（active クラスが付与されている）メニューの要素を取得
  259.     const highlightedMenu = document.querySelector(navSelector + ' ' + '.' + activeClass);
  260.     //上記で取得した要素が存在すれば、その要素から active クラスを削除
  261.     if (highlightedMenu !== null) {
  262.       highlightedMenu.classList.remove(activeClass);
  263.     }
  264.     //引数で渡された現在交差している（isIntersecting が true の）要素の id 属性からリンク先（href）の値を生成
  265.     const href = '#' + target.id;
  266.     //上記で生成したリンク先を持つメニューが、現在交差している要素のリンク
  267.     const currentActiveMenu =  document.querySelector(`a[href='${href}']`);
  268.     //現在交差している要素のリンクに active クラスを追加
  269.     currentActiveMenu.classList.add(activeClass);
  270.   }
  271. }
  272. //上記で定義した関数を呼び出す
  273. ioScrollSpy();
  274.  
  275. /****** スムーススクロールの設定 ******/
  276. //アニメーション（スムーススクロール）の持続時間
  277. const duration = 800;
  278. //開始時刻を代入する変数（最初は未定義）
  279. let start;
  280. //スクロール先の Y 座標（ウィンドウの左上からの座標）
  281. let targetY;
  282. //現在の垂直（Y）方向のスクロール量（位置）
  283. let currentY;
  284. //イージング関数の定義
  285. const easeInQuad = (x) => {
  286.   return x * x;
  287. }
  288. //スクロール先を調整する値（上部の固定メニューの高さ）
  289. let offset = 80;
  290. //コールバック関数
  291. const smoothScroll = (timestamp) => {
  292.   if (start === undefined) {
  293.     start = timestamp;
  294.   }
  295.   //経過時間
  296.   const elapsed = start ? timestamp - start : 0;
  297.   //進捗度を算出してイージングを適用
  298.   const relativeProgress =  easeInQuad( Math.min(1, elapsed / duration) );
  299.   //移動する量（targetY）に進捗度を適用して scrollTo のY座標へ指定する値を算出
  300.   const scrollY = currentY + targetY * relativeProgress;
  301.   //上記で算出した位置へスクロール（上部の固定メニューの高さ分を offset で調整）
  302.   window.scrollTo(0, scrollY - offset);
  303.   //進捗度が1未満の場合は自身を繰り返す
  304.   if (relativeProgress < 1) {
  305.     requestAnimationFrame(smoothScroll);
  306.   }
  307. }
  308.  
  309. //href 属性が # から始まる要素（内部リンク）を全て取得
  310. let links = document.querySelectorAll('a[href^="#"]');
  311. //内部リンクにスムーススクロールを適用される（イベントリスナーを設定する）関数
  312. const applySmoothScroll = (links) => {
  313.   //内部リンクが存在すれば
  314.   if(links.length > 0) {
  315.     //内部リンクのそれぞれの要素に対して以下を実行
  316.     links.forEach((elem) => {
  317.       //それぞれの要素にクリックイベントを設定
  318.       elem.addEventListener('click', (e) => {
  319.         //href 属性の値を取得
  320.         const href = e.currentTarget.getAttribute('href');
  321.         //href 属性の値からスクロール先の要素を取得
  322.         const target = href === "#" ?
  323.           //href 属性の値が # の場合は対象を html 要素
  324.           document.querySelector('html') :
  325.           //それ以外は # 以降の部分を ID として対象の要素
  326.           document.getElementById(href.replace('#', ''));
  327.  
  328.         //取得した要素が実際に存在すれば以下を実行
  329.         if(target) {
  330.           //開始時刻を初期化
  331.           start = undefined;
  332.           //対象（スクロール先）の要素の Y 座標（ウィンドウ座標）
  333.           targetY =  target.getBoundingClientRect().y;
  334.           //現在の垂直方向にスクロールされている量
  335.           currentY = window.scrollY;
  336.           //関数を実行
  337.           smoothScroll();
  338.         }
  339.       });
  340.     });
  341.   }
  342. }
  343. //上記で定義した関数を呼び出す
  344. applySmoothScroll (links);
  345.  
  346. //ページトップへスクロールするボタンのクリックイベント
  347. document.getElementById('scroll-to-top').addEventListener('click', (e) => {
  348.   //開始時刻を初期化
  349.   start = undefined;
  350.   //スクロール先の要素を html として Y 座標（ウィンドウ座標）を取得
  351.   targetY =  document.querySelector('html').getBoundingClientRect().y;
  352.   //垂直方向にスクロールされている量（位置）
  353.   currentY  = window.scrollY;
  354.   //関数を実行
  355.   smoothScroll();
  356. });
  357. </script>
  358. </body>
  359. </html>

以下は上記のサンプルとほぼ同じですが、チェックボックスで監視の有効・無効を切り替えられるようにした動作確認用のサンプルです。有効・無効の切り替えは disconnect() と observe() を使っています。

チェックを外して監視を無効にした状態でコンテンツを追加した場合はスクロールスパイは適用されませんが、再度チェックを入れて有効にすると、その後追加されたコンテンツ及びその前に追加されたコンテンツにスクロールスパイが適用されます。

サンプルを開く

  1. <!doctype html>
  2. <html>
  3. <head>
  4. <meta charset="utf-8">
  5. <meta name="robots" content="noindex,nofollow">
  6. <meta name="viewport" content="width=device-width, initial-scale=1">
  7. <meta http-equiv="X-UA-Compatible" content="IE=edge">
  8. <title>IntersectionObserver with MutationObserver 2</title>
  9. <style>
  10. *, *::before, *::after {
  11.   box-sizing: border-box;
  12.   margin: 0;
  13.   padding: 0;
  14. }
  15. html {
  16.   color: #444;
  17. }
  18. body {
  19.   margin-top: 50px;
  20. }
  21. h1 {
  22.   color: #999;
  23.   font-size: 24px;
  24.    margin-bottom: 2rem;
  25. }
  26. h2 {
  27.   margin-bottom: 1rem;
  28. }
  29. p {
  30.   margin-bottom: .5rem;
  31. }
  32. .wrapper {
  33.   max-width: 780px;
  34.   margin: 20px auto 0;
  35.   padding: 0 1rem;
  36. }
  37. .nav-wrapper {
  38.   position: sticky;
  39.   top: 0px;
  40.   width: 100%;
  41.   background-color: #fefefe;
  42.   padding: .5rem 0;
  43. }
  44. .nav {
  45.   width: 100%;
  46.   max-width: 600px;
  47.   display: flex;
  48.   justify-content: flex-start;
  49. }
  50. .contents {
  51.   width: 100%;
  52. }
  53. .nav {
  54.   padding-left: 0;
  55. }
  56. .nav li {
  57.   list-style: none;
  58.   color: #70B466;
  59. }
  60. .nav a {
  61.   display: block;
  62.   width: 100%;
  63.   padding: .25rem .5rem;
  64.   text-decoration: none;
  65.   color: #70B466;
  66. }
  67. .nav a.active {
  68.   color: #D0F0C1;
  69.   background-color: #557E49;
  70. }
  71. .linkTarget {
  72.   margin-top: 4rem;
  73. }
  74. .footer {
  75.   width: 100vw;
  76.   height: 400px;
  77.   background-color: #eee;
  78.   margin-top: 300px;
  79. }
  80. /*トップへスクロールするボタン*/
  81. #scroll-to-top {
  82.   position: fixed;
  83.   right: 15px;
  84.   bottom: 2rem;
  85.   z-index: 100;
  86.   font-size: 0.75rem;
  87.   background-color: #557E49;
  88.   width: 80px;
  89.   height: 50px;
  90.   clip-path: polygon(50% 0%, 0% 100%, 100% 100%);
  91.   color: #fff;
  92.   line-height: 50px;
  93.   text-align: center;
  94.   transition: opacity .4s;
  95.   opacity: .7;
  96.   cursor: pointer;
  97. }
  98. #scroll-to-top:hover {
  99.   opacity: 1;
  100. }
  101. #scroll-to-top p {
  102.   margin-top: 10px;
  103. }
  104. .controls button {
  105.   margin: 20px 20px 0 20px;
  106. }
  107. #addContent {
  108.   background-color: rgb(194, 240, 244);
  109.   border: 1px solid #8394af;
  110.   padding: 8px;
  111. }
  112. .controls input:checked + label {
  113.   color: red;
  114. }
  115. </style>
  116. </head>
  117. <body>
  118. <div class="wrapper">
  119.   <h1>IntersectionObserver with MutationObserver 2</h1>
  120.   <nav class="nav-wrapper">
  121.     <ol id="navigation" class="nav">
  122.       <li><a href="#section1">Section 1</a></li>
  123.       <li><a href="#section2">Section 2 </a></li>
  124.       <li><a href="#section3">Section 3</a></li>
  125.     </ol>
  126.   </nav>
  127.   <div class="controls">
  128.     <input type="checkbox" name="mo" id="enableMO" value="Observe Mutation" checked>
  129.     <label for="enableMO"> Observe Mutation </label>
  130.     <button id="addContent">Add Content</button>
  131.   </div>
  132.   <main class="contents">
  133.     <div class="linkTarget" id="section1">
  134.       <h2>Section 1</h2>
  135.       <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Tempora dolores quam a dolorem, architecto molestias fugit necessitatibus, deserunt doloremque! Laborum voluptatum, maiores temporibus ab pariatur reiciendis ipsa ad tenetur in.</p>
  136.       <p>Possimus, ipsam a vero quae tempora molestias autem quas quisquam officiis distinctio recusandae, et, consectetur blanditiis maxime, eaque inventore ut. Aut facere, quae architecto unde, dolores autem est ratione voluptatum.</p>
  137.     </div>
  138.     <div class="linkTarget" id="section2">
  139.       <h2>Section 2</h2>
  140.       <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Dolorem natus quos voluptatibus tempore repudiandae aut, vero dolorum magni, exercitationem magnam eveniet, omnis soluta doloremque atque iusto provident expedita sint enim.</p>
  141.       <p>Commodi nulla cupiditate rerum culpa at aspernatur dolorem iusto fuga officiis magni, nihil accusamus impedit repellendus obcaecati quod optio, odit reiciendis porro minima explicabo nesciunt earum, facilis quos ut accusantium!</p>
  142.     </div>
  143.     <div class="linkTarget" id="section3">
  144.       <h2>Section 3</h2>
  145.       <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Quis provident facere molestiae exercitationem eligendi quam perferendis quae enim sed omnis harum rem in officiis veritatis aliquid, corrupti veniam velit deleniti.</p>
  146.       <p>Delectus iusto repellendus quas ipsam! Veritatis a, facilis architecto necessitatibus consequuntur omnis neque aliquid quam exercitationem laboriosam quos magni error numquam enim temporibus, iure cumque modi ipsam soluta dignissimos. Nam!</p>
  147.       <p>Nobis consequatur, esse repudiandae soluta excepturi maiores a in quisquam est natus molestias aspernatur dignissimos, asperiores quasi? Quae nulla mollitia, vero nam eaque incidunt cupiditate consectetur. Repellendus, est dignissimos qui.</p>
  148.     </div>
  149.   </main>
  150. </div>
  151. <div class="footer"></div>
  152. <div id="scroll-to-top"><!--トップへスクロールするボタン-->
  153.   <p>Top</p>
  154. </div>
  155. <script>
  156. //ナビゲーションにリンク項目を追加する関数
  157. const addNavigationItem = () => {
  158.   const sectionsCount = document.querySelectorAll('.linkTarget').length;
  159.   const addedSection = document.querySelectorAll('.linkTarget')[sectionsCount-1];
  160.   const addedSectionTitle = addedSection.querySelector('h2').textContent;
  161.   //li 要素（リンク項目）の生成
  162.   const li = document.createElement('li');
  163.   //innerHTML で子要素（リンク）を追加
  164.   li.innerHTML = `<a href="#section${sectionsCount}">${addedSectionTitle}</a>`;
  165.   //追加先のノードに生成した要素（リンク項目）を追加
  166.   document.getElementById('navigation').appendChild(li);
  167.   //スムーススクロールの関数を実行
  168.   applySmoothScroll(document.querySelectorAll('a[href^="#"]'));
  169. }
  170.  
  171.  
  172. /****** MutationObserver の設定 ******/
  173. //MutationObserver のコールバック
  174. const moCallback = (mutationsList) => {
  175.   mutationsList.forEach((mutation) => {
  176.     if ( mutation.type == 'childList' ) {
  177.       if (mutation.addedNodes.length >= 1) {
  178.         for(let node of mutation.addedNodes) {
  179.           // 要素のみを対象とし、他のノード（例 テキストノード）はスキップ
  180.           if (!(node instanceof HTMLElement)) continue;
  181.           // 挿入された要素が linkTarget クラスの div 要素かをチェック
  182.           if (node.matches('div.linkTarget')) {
  183.             //スクロールスパイの関数を実行
  184.             ioScrollSpy();
  185.             //ナビゲーションにリンク項目を追加する関数を実行
  186.             addNavigationItem();
  187.           }
  188.           // サブツリーのどこかに linkTarget クラスの div 要素がある場合
  189.           for(let elem of node.querySelectorAll('div.linkTarget')) {
  190.             //スクロールスパイの関数を実行
  191.             ioScrollSpy();
  192.             //ナビゲーションにリンク項目を追加する関数を実行
  193.             addNavigationItem();
  194.           }
  195.         }
  196.       }
  197.     }
  198.   });
  199. }
  200. // 監視対象
  201. const moTarget = document.body;
  202. // 監視のオプション
  203. const moConfig = {
  204.   childList: true,
  205.   subtree: true,
  206. };
  207. // コールバック関数を渡してオブザーバーを生成
  208. const mo = new MutationObserver(moCallback);
  209. // 監視対象とオプションを指定して監視を開始
  210. mo.observe(moTarget, moConfig);
  211.  
  212. //MutationObserver が現在有効かどうか
  213. let isEnabledMO = true;
  214.  
  215. //チェックボックスのリスナー
  216. document.querySelector('#enableMO').addEventListener('change', (e) => {
  217.   if( e.currentTarget.checked ) {
  218.     //チェックボックスがチェックされれば変更の監視を開始（または再開）
  219.     if(!isEnabledMO) mo.observe(moTarget, moConfig);
  220.     isEnabledMO = true;
  221.   }else{
  222.     //チェックが外されれば変更の監視を停止
  223.     mo.disconnect();
  224.     isEnabledMO = false;
  225.   }
  226. });
  227.  
  228. //クリックで linkTarget クラスの div 要素を追加するリスナー
  229. document.getElementById('addContent').addEventListener('click', () => {
  230.   let sectionsCount = document.querySelectorAll('.linkTarget').length + 1;
  231.   //div 要素の生成
  232.   const div = document.createElement('div');
  233.   //生成した div 要素にクラス属性を設定
  234.   div.className = 'linkTarget';
  235.   div.id = `section${sectionsCount}`;
  236.   //innerHTML で子要素を追加
  237.   div.innerHTML = `<h2>Section ${sectionsCount}</h2>
  238.   <p>Maiores labore quidem est nemo quia ullam deleniti, ipsum voluptatibus dolorem. Explicabo nisi, possimus. Iusto alias, totam sunt excepturi tempora qui modi autem, ipsum aut doloribus facilis, possimus deserunt atque.</p>
  239.   <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Tempora dolores quam a dolorem, architecto molestias fugit necessitatibus, deserunt doloremque! Laborum voluptatum, maiores temporibus ab pariatur reiciendis ipsa ad tenetur in.</p>`;
  240.   //追加先のノードに生成した要素を追加
  241.   document.querySelector('main.contents').appendChild(div);
  242.   //MutationObserver が有効でない場合にはリンク項目も追加
  243.   if(!isEnabledMO) {
  244.     addNavigationItem();
  245.   }
  246. });
  247.  
  248. /****** スクロールスパイの関数 ******/
  249. const ioScrollSpy = (rootSelector=null, rootMargin='-25% 0px -75%', targetClass='linkTarget', navSelector='#navigation', activeClass='active') => {
  250.   //監視対象の要素を取得
  251.   const targets = document.querySelectorAll('.' + targetClass);
  252.   //オプション
  253.   const options = {
  254.     root: rootSelector ===null ? null : document.querySelector(rootSelector),
  255.     //上から25%の位置を交差の境界とする
  256.     rootMargin: rootMargin,
  257.     threshold: 0 //デフォルトなので省略可能
  258.   }
  259.   //IntersectionObserver のコールバック関数
  260.   const callback = (entries) => {
  261.     // 交差を検知をしたら
  262.     entries.forEach(entry => {
  263.       //監視対象の要素が領域（境界）と交差していれば（isIntersecting が true の場合）
  264.       if (entry.isIntersecting) {
  265.         //その要素を引数として以下の関数を呼び出してメニューをハイライト
  266.         highlightNavMenu(entry.target);
  267.       }
  268.     });
  269.   }
  270.   //IntersectionObserver のインスタンス（オブザーバー）を生成
  271.   const io = new IntersectionObserver(callback, options);
  272.   //それぞれの監視対象の要素を observe() に指定して監視
  273.   targets.forEach( (target) => {
  274.     io.observe(target);
  275.   });
  276.   //メニュー項目をハイライトする（色を変える）関数
  277.   const highlightNavMenu = (target) => {
  278.     //現在アクティブになっている（active クラスが付与されている）メニューの要素を取得
  279.     const highlightedMenu = document.querySelector(navSelector + ' ' + '.' + activeClass);
  280.     //上記で取得した要素が存在すれば、その要素から active クラスを削除
  281.     if (highlightedMenu !== null) {
  282.       highlightedMenu.classList.remove(activeClass);
  283.     }
  284.     //引数で渡された現在交差している（isIntersecting が true の）要素の id 属性からリンク先（href）の値を生成
  285.     const href = '#' + target.id;
  286.     //上記で生成したリンク先を持つメニューが、現在交差している要素のリンク
  287.     const currentActiveMenu =  document.querySelector(`a[href='${href}']`);
  288.     //現在交差している要素のリンクに active クラスを追加
  289.     currentActiveMenu.classList.add(activeClass);
  290.   }
  291. }
  292. //上記で定義した関数を呼び出す
  293. ioScrollSpy();
  294.  
  295. /****** スムーススクロールの設定 ******/
  296. //アニメーション（スムーススクロール）の持続時間
  297. const duration = 800;
  298. //開始時刻を代入する変数（最初は未定義）
  299. let start;
  300. //スクロール先の Y 座標（ウィンドウの左上からの座標）
  301. let targetY;
  302. //現在の垂直（Y）方向のスクロール量（位置）
  303. let currentY;
  304. //イージング関数の定義
  305. const easeInQuad = (x) => {
  306.   return x * x;
  307. }
  308. //スクロール先を調整する値（上部の固定メニューの高さ）
  309. let offset = 80;
  310. //コールバック関数
  311. const smoothScroll = (timestamp) => {
  312.   if (start === undefined) {
  313.     start = timestamp;
  314.   }
  315.   //経過時間
  316.   const elapsed = start ? timestamp - start : 0;
  317.   //進捗度を算出してイージングを適用
  318.   const relativeProgress =  easeInQuad( Math.min(1, elapsed / duration) );
  319.   //移動する量（targetY）に進捗度を適用して scrollTo のY座標へ指定する値を算出
  320.   const scrollY = currentY + targetY * relativeProgress;
  321.   //上記で算出した位置へスクロール（上部の固定メニューの高さ分を offset で調整）
  322.   window.scrollTo(0, scrollY - offset);
  323.   //進捗度が1未満の場合は自身を繰り返す
  324.   if (relativeProgress < 1) {
  325.     requestAnimationFrame(smoothScroll);
  326.   }
  327. }
  328.  
  329. //href 属性が # から始まる要素（内部リンク）を全て取得
  330. let links = document.querySelectorAll('a[href^="#"]');
  331. //内部リンクにスムーススクロールを適用される（イベントリスナーを設定する）関数
  332. const applySmoothScroll = (links) => {
  333.   //内部リンクが存在すれば
  334.   if(links.length > 0) {
  335.     //内部リンクのそれぞれの要素に対して以下を実行
  336.     links.forEach((elem) => {
  337.       //それぞれの要素にクリックイベントを設定
  338.       elem.addEventListener('click', (e) => {
  339.         //href 属性の値を取得
  340.         const href = e.currentTarget.getAttribute('href');
  341.         //href 属性の値からスクロール先の要素を取得
  342.         const target = href === "#" ?
  343.           //href 属性の値が # の場合は対象を html 要素
  344.           document.querySelector('html') :
  345.           //それ以外は # 以降の部分を ID として対象の要素
  346.           document.getElementById(href.replace('#', ''));
  347.  
  348.         //取得した要素が実際に存在すれば以下を実行
  349.         if(target) {
  350.           //開始時刻を初期化
  351.           start = undefined;
  352.           //対象（スクロール先）の要素の Y 座標（ウィンドウ座標）
  353.           targetY =  target.getBoundingClientRect().y;
  354.           //現在の垂直方向にスクロールされている量
  355.           currentY = window.scrollY;
  356.           //関数を実行
  357.           smoothScroll();
  358.         }
  359.       });
  360.     });
  361.   }
  362. }
  363. //上記で定義した関数を呼び出す
  364. applySmoothScroll (links);
  365.  
  366. //ページトップへスクロールするボタンのクリックイベント
  367. document.getElementById('scroll-to-top').addEventListener('click', (e) => {
  368.   //開始時刻を初期化
  369.   start = undefined;
  370.   //スクロール先の要素を html として Y 座標（ウィンドウ座標）を取得
  371.   targetY =  document.querySelector('html').getBoundingClientRect().y;
  372.   //垂直方向にスクロールされている量（位置）
  373.   currentY  = window.scrollY;
  374.   //関数を実行
  375.   smoothScroll();
  376. });
  377. </script>
  378. </body>
  379. </html>

関連ページ

slotchange イベント

Web Components の slot 要素では、スロットのノードが変更（追加・削除）されると slotchange イベントが発生して変更をイベントとして検知できますが、スロットに入っているノードの子ノード（テキストなど）が変更された場合は、slotchange イベントは発生しません。

MutationObserver を使うとスロットの追加・削除以外の変更も検知することができます。

以下はカスタム要素 custom-menu の定義で、slotchange イベントのリスナーを設定してスロットに変更があると、コンソールにイベントが発生したスロットの name 属性を出力する例です。

  1. // カスタム要素 custom-menu を定義
  2. customElements.define('custom-menu', class extends HTMLElement {
  3.   constructor() {
  4.     super();
  5.     this.attachShadow({mode: 'open'});
  6.     this.shadowRoot.innerHTML = `
  7.     <div class="menu">
  8.       <slot name="title"></slot>
  9.       <ul>
  10.         <slot name="item"></slot>
  11.       </ul>
  12.     </div>`;
  13.  
  14.     // class="menu" の div 要素に slotchange イベントのリスナーを設定
  15.     this.shadowRoot.querySelector('div.menu').addEventListener('slotchange',e => {
  16.       console.log("slotchange Event: " + e.target.name)
  17.     })
  18.   }
  19. });
  20.  
  21. //カスタム要素を取得
  22. const menu = document.querySelector('custom-menu');
  23.  
  24. // 1秒後にスロットに要素の追加とテキストの変更を実行
  25. setTimeout(() => {
  26.   console.log('1秒後')
  27.   // li 要素を生成
  28.   const item = document.createElement('li');
  29.   // slot 属性を指定
  30.   item.setAttribute('slot', 'item');
  31.   item.textContent = 'Item 3';
  32.   // カスタム要素に li 要素を追加
  33.   menu.appendChild(item);
  34.   // カスタム要素の slot 属性が title の要素のテキストを変更
  35.   menu.querySelector('[slot="title"]').innerHTML = "New Menu";
  36. }, 1000);
カスタム要素を利用する HTML 
  1. <custom-menu>
  2.   <h3 slot="title">Menu</h3>
  3.   <li slot="item">Item 1</li>
  4.   <li slot="item">Item 2</li>
  5. </custom-menu>

以下がコンソールへの出力です。

  1. slotchange Event: title //初期化の際の出力
  2. slotchange Event: item //初期化の際の出力
  3. 1秒後
  4. slotchange Event: item  //li 要素の追加による出力

上記では、setTimeout() を使って1秒後にスロットの li 要素を追加し、スロットの h3 要素のテキストを変更していますが、h3 要素のテキストの変更は検知できません（最初の２つの出力は、初期化の際に出力されたもので、変更によるものではありません）。

以下は slotchange イベントの代わりに、MutationObserver を使ってスロットの変更を検知する例です。カスタム要素の定義とスロットの変更部分は前述の例と同じです。

observe() メソッドの第一引数には監視の対象としてカスタム要素 custom-menu を指定し、第二引数のオプションには childList: true と subtree: true を指定しています。

コールバック関数では、type が childList（対象ノードの子ノードの変更）の場合に、addedNodes と removedNodes に含まれるノードを調べて内容をコンソールに出力しています。

  1. customElements.define('custom-menu', class extends HTMLElement {
  2.   constructor() {
  3.     super();
  4.     this.attachShadow({mode: 'open'});
  5.     this.shadowRoot.innerHTML = `
  6.     <div class="menu">
  7.       <slot name="title"></slot>
  8.       <ul>
  9.         <slot name="item"></slot>
  10.       </ul>
  11.     </div>
  12.     `;
  13.     //MutationObserver を使ってスロットの変更を検知して、内容をコンソールに出力
  14.     const mo = new MutationObserver((mutations) => {
  15.       for(const mutation of mutations) {
  16.         if ( mutation.type == 'childList' ) {
  17.           if (mutation.addedNodes.length >= 1) {
  18.             mutation.addedNodes.forEach((node) => {
  19.               console.log('追加されたノード: ' + node.nodeName);
  20.               if(node.nodeType ===1 && node.textContent) {
  21.                 console.log('テキスト: ' + node.textContent);
  22.               }
  23.               if(node.nodeType === 3) {
  24.                 console.log('テキスト: ' + node.data);
  25.                 console.log('親ノード: ' + node.parentNode.nodeName);
  26.               }
  27.             })
  28.           }
  29.           if (mutation.removedNodes.length >= 1) {
  30.             mutation.removedNodes.forEach((node) => {
  31.               console.log('削除されたノード: ' + node.nodeName);
  32.               if(node.nodeType ===1 && node.textContent) {
  33.                 console.log('テキスト: ' + node.textContent);
  34.               }
  35.               if(node.nodeType === 3) {
  36.                 console.log('テキスト: ' + node.data);
  37.               }
  38.             })
  39.           }
  40.         }
  41.       }
  42.     }).observe(document.querySelector('custom-menu'), {
  43.       subtree: true,
  44.       childList: true
  45.     });
  46.   }
  47. });
  48.  
  49. //以下は前述の例と同じ
  50. const menu = document.querySelector('custom-menu');
  51. setTimeout(() => {
  52.   console.log('1秒後')
  53.   const item = document.createElement('li');
  54.   item.setAttribute('slot', 'item');
  55.   item.textContent = 'Item 3';
  56.   menu.appendChild(item);
  57.   menu.querySelector('[slot="title"]').innerHTML = "New Menu";
  58. }, 1000);

この場合は、テキストの変更も検知され、以下のように出力されます。

  1. 1秒後
  2. 追加されたノード: LI
  3. テキスト: Item 3
  4. 追加されたノード: #text
  5. テキスト: New Menu
  6. 親ノード: H3
  7. 削除されたノード: #text
  8. テキスト: Menu

通常の MutationObserver 同様、監視オプションに attributes: true や characterData: true を指定すれば、属性の変更やテキストデータの変更も検知することができます。

上記では MutationObserver をカスタム要素のコンストラクター内で定義していますが、コンストラクターの外で定義しても問題ないようです。

関連ページ：Web components の使い方