TypeScriptでタイマー処理をマスター!10選サンプルコード完全ガイド

TypeScriptでのタイマー処理方法を学ぶイラストTypeScript
この記事は約29分で読めます。

 

【サイト内のコードはご自由に個人利用・商用利用いただけます】

この記事では、プログラムの基礎知識を前提に話を進めています。

説明のためのコードや、サンプルコードもありますので、もちろん初心者でも理解できるように表現してあります。

基本的な知識があればカスタムコードを使って機能追加、目的を達成できるように作ってあります。

※この記事は、一般的にプロフェッショナルの指標とされる『実務経験10,000時間以上』を凌駕する現役のプログラマチームによって監修されています。

サイト内のコードを共有する場合は、参照元として引用して下さいますと幸いです

※Japanシーモアは、常に解説内容のわかりやすさや記事の品質に注力しております。不具合、分かりにくい説明や不適切な表現、動かないコードなど気になることがございましたら、記事の品質向上の為にお問い合わせフォームにてご共有いただけますと幸いです。
(送信された情報は、プライバシーポリシーのもと、厳正に取扱い、処分させていただきます。)

はじめに

TypeScriptは、近年のフロントエンド技術の中でも特に注目されている言語の一つです。

JavaScriptの上に成り立っているTypeScriptは、型の概念を取り入れることで、より安全にコードを記述することが可能となりました。

そして、今回のテーマである「タイマー処理」も、日常の開発において頻繁に利用される重要な技術です。

タイマー処理は、特定の時間が経過した後や、定期的な間隔で何らかの動作を行わせるための処理です。

例えば、ユーザーがボタンをクリックした後に、一定時間後にポップアップを表示させる、といったシチュエーションが考えられます。

今回の記事では、TypeScriptを用いてタイマー処理を実装する方法を10のサンプルコードとともに解説します。

これを読めば、あなたもTypeScriptでのタイマー処理のマスターと言っても過言ではありません。

初心者から中級者までの方々が、実践的な技術を習得できるよう、わかりやすく丁寧に解説しています。

●TypeScriptとは?

TypeScriptは、Microsoftが開発したJavaScriptのスーパーセットとして知られている言語です。

JavaScriptの全ての機能を継承しつつ、静的型付けやインターフェースなどの強力な機能を持っています。

これにより、大規模なプロジェクトやチームでの開発がしやすくなり、バグを早期にキャッチすることが可能となります。

○TypeScriptの基本概念

TypeScriptは、型安全性を重視した言語です。

これにより、コンパイル時に様々なエラーを検出できます。

例として、数値型の変数に文字列を代入しようとすると、TypeScriptはこれをエラーとしてキャッチします。

let num: number = "文字列";  // これはTypeScriptではエラーになる

このコードでは、数値型として定義された変数numに文字列を代入しようとしています。

この例では、TypeScriptの型安全性が如何に有効かを示しています。

実際にこのコードをコンパイルすると、「Type ‘”文字列”‘ is not assignable to type ‘number’」というエラーメッセージが表示されるでしょう。

●タイマー処理の基本

タイマー処理は、指定した時間が経過した後に特定の処理を実行するものです。

JavaScriptでは、setTimeoutsetIntervalなどの関数を使ってタイマー処理を実装できますが、TypeScriptでもこれらの関数をそのまま使用することができます。

○JavaScriptとの違い

TypeScriptはJavaScriptのスーパーセットであるため、基本的なタイマー処理の方法は変わりません。

しかし、TypeScriptでは型情報を追加することで、より安全にタイマー処理を記述することができます。

○タイマー処理を実装する際の注意点

タイマー処理を実装する際には、特にsetIntervalを使った繰り返しのタイマー処理では注意が必要です。

無限に繰り返し実行されるため、メモリリークや不要な処理が続く可能性があります。

適切なタイミングでclearIntervalを使ってタイマーを停止させることが重要です。

●TypeScriptでのタイマー処理の使い方

タイマー処理をTypeScriptで実装する方法は、基本的にJavaScriptと変わりませんが、型情報を付加することでさらに安全になります。

○サンプルコード1:単純なsetTimeoutの例

このコードでは、setTimeoutを使って指定した時間後にメッセージをコンソールに出力するコードを表しています。

この例では、3秒後に「Hello, TypeScript!」を出力しています。

setTimeout(() => {
    console.log("Hello, TypeScript!");
}, 3000);

上記のコードを実行すると、3秒後にコンソールに「Hello, TypeScript!」と表示されるでしょう。

これがTypeScriptでの基本的なタイマー処理の実装方法です。

次に、繰り返しのタイマー処理や非同期処理を組み合わせたタイマー処理の方法を見ていきましょう。

○サンプルコード2:setIntervalを使った繰り返しタイマー

このコードでは、setIntervalを使って特定の間隔でメッセージをコンソールに出力するコードを表しています。

この例では、2秒ごとに「TypeScript Timer!」を出力しています。

const intervalId = setInterval(() => {
    console.log("TypeScript Timer!");
}, 2000);

// 10秒後にタイマーを停止
setTimeout(() => {
    clearInterval(intervalId);
}, 10000);

上記のコードを実行すると、2秒ごとに「TypeScript Timer!」がコンソールに表示され、10秒後に繰り返しの出力が停止するでしょう。

ここでは、一定の間隔での繰り返し処理と、それを停止させる方法を組み合わせて表しています。

このように、TypeScriptでもJavaScriptでのタイマー処理と同じように実装できますが、型の利点を活かすことでさらに安全にコードを書くことができます。

○サンプルコード3:Promiseを利用したタイマー処理

JavaScriptの非同期処理の1つとして、Promiseという概念があります。

Promiseは、非同期処理が完了した時にその結果を取得するためのオブジェクトで、成功時には.thenメソッド、エラー時には.catchメソッドを使って結果を受け取ることができます。

TypeScriptでは、JavaScriptと同じようにこのPromiseを使用することができます。

今回は、TypeScriptでPromiseを使ったタイマー処理の方法を紹介します。

このコードでは、Promiseを使って非同期のタイマー処理を実装する方法を表しています。

この例では、指定した時間が経過した後に処理を実行するための関数を定義しています。

function wait(ms: number): Promise<void> {
  // 指定した時間だけ待機した後にPromiseがresolveされる関数を作成
  return new Promise<void>((resolve) => {
    setTimeout(() => {
      resolve();
    }, ms);
  });
}

// 使用例
wait(2000).then(() => {
  console.log("2秒経過しました");
});

このサンプルコードでは、wait関数を定義しています。

この関数は、指定したミリ秒数だけ待機した後に、Promiseが解決されるように設計されています。

上記の使用例では、2秒後にコンソールに”2秒経過しました”と表示されます。

このタイマー処理のメリットとして、非同期処理の終了を待つことなく次の処理を進めることができる点が挙げられます。

これにより、ウェブページの読み込み速度やレスポンスの向上が期待できます。

しかし、これだけを使うと、複数の非同期処理を順番に実行する場合などにコードが複雑になりがちです。

そのため、このタイマー処理を更に応用したい場合は、後述するasync/awaitと組み合わせることで、より直感的なコードの記述が可能となります。

このコードを実行すると、指定した時間(この場合は2000ミリ秒=2秒)が経過した後に、”2秒経過しました”というメッセージがコンソールに表示されます。

これにより、簡単に非同期のタイマー処理を実現することができます。

○サンプルコード4:async/awaitと組み合わせたタイマー処理

TypeScriptで非同期処理を行う際、特に多くの開発者が利用するのがasync/awaitです。

ここでは、async/awaitを利用して、非同期的なタイマー処理を実装する方法を説明します。

まず、基本となるサンプルコードを見てみましょう。

// 非同期関数としてタイマーを実装
const sleep = (ms: number): Promise<void> => {
    return new Promise(resolve => setTimeout(resolve, ms));
}

// 上記の関数をasync/awaitと組み合わせて使用
const runTimer = async () => {
    console.log('開始');
    await sleep(2000);  // 2秒待機
    console.log('2秒後');
}

runTimer();

このコードでは、sleep関数を使って指定したミリ秒数だけ待機するコードを表しています。

この例ではsleep関数内でsetTimeoutを用いてPromiseを返しています。

そして、runTimer関数内でasync/awaitを使って非同期的に2秒待機してから次の処理を行っています。

上記のコードを実行すると、コンソールに「開始」と表示された後、2秒待機してから「2秒後」と表示されます。

また、async/awaitを利用する場合、エラーハンドリングは非常に重要です。

特に、Promiseがrejectされた場合、適切にcatchをしないとアンハンドルドプロミスリジェクションが発生する可能性があります。

エラーハンドリングを含めたサンプルコードを紹介します。

const sleep = (ms: number, shouldReject: boolean = false): Promise<void> => {
    return new Promise((resolve, reject) => {
        if (shouldReject) {
            reject('エラーが発生しました');
        } else {
            setTimeout(resolve, ms);
        }
    });
}

const runTimerWithHandling = async () => {
    console.log('開始');
    try {
        await sleep(2000, true);  // 2秒待機し、エラーをスロー
    } catch (error) {
        console.error(`エラー: ${error}`);
    }
    console.log('終了');
}

runTimerWithHandling();

このコードでは、sleep関数にエラーをスローするための引数shouldRejectを追加しています。

そして、runTimerWithHandling関数内でエラーハンドリングを行っています。

上記のコードを実行すると、「開始」→「エラー: エラーが発生しました」→「終了」という順序でコンソールに表示されます。

さらに、応用例として非同期のタイマー処理を繰り返す場合の例を紹介します。

const runRepeatedTimer = async (count: number) => {
    for (let i = 0; i < count; i++) {
        console.log(`繰り返し ${i + 1}回目`);
        await sleep(1000);  // 1秒待機
    }
    console.log('繰り返し終了');
}

runRepeatedTimer(5);

上記のコードを実行すると、コンソールに「繰り返し 1回目」から「繰り返し 5回目」まで1秒おきに表示され、その後「繰り返し終了」と表示されます。

●応用:より高度なタイマー処理の実装

TypeScriptを使ったタイマー処理において、基本的なsetTimeoutやsetIntervalは多くの場面で使用されるものの、実際のプロジェクトではより高度なタイマー処理が求められることもあります。

ここでは、応用的なタイマー処理のサンプルコードを1つ紹介し、それに関連する詳細な解説と実行結果を紹介します。

○サンプルコード5:デバウンス機能を実装する

デバウンスとは、高頻度で発火するイベントをある一定の間隔内で1回だけ発火させる技術です。

例えば、ユーザーがテキスト入力のたびに何らかの処理を行いたい場合、連続的な入力に対して処理を繰り返すとパフォーマンスが低下する恐れがあります。

デバウンス機能を利用することで、このような問題を回避できます。

このコードでは、TypeScriptを使ってデバウンス機能を実装する方法を表しています。

この例では、入力イベントが発火した後、500ミリ秒の間隔を置き、その間に再度入力がなければ指定した処理を実行します。

let timer: number | null = null;

function debounce(func: () => void, wait: number) {
    return function() {
        if (timer !== null) {
            clearTimeout(timer);
        }
        timer = setTimeout(func, wait);
    };
}

// 使用例
const inputElement = document.getElementById('input');
inputElement?.addEventListener('input', debounce(() => {
    console.log('入力が完了しました!');
}, 500));

入力フォームに文字を入力するたびに、入力イベントが発火します。

しかし、デバウンス関数を経由してイベントリスナーを設定しているため、実際の処理は500ミリ秒の間隔を持って1回だけ発火します。

そのため、短時間に複数回入力しても、「入力が完了しました!」というメッセージは1回しか表示されません。

この機能の特徴としては、ユーザーの入力や操作に対してリアルタイムに反応するような場面で、不必要な処理の繰り返しを防ぐために非常に役立ちます。

また、APIの呼び出しやデータベースのクエリなど、高コストな操作を伴う処理に対しても有効です。

連続してテキストを入力した場合、最初の入力から500ミリ秒後にconsole.logの処理が実行されるのを確認できます。

しかし、500ミリ秒以内に再度入力があった場合、タイマーはリセットされて処理は実行されません。

500ミリ秒の間隔が開いた後、再び入力がなければメッセージが表示されます。

このようなデバウンスの技術は、ユーザーインターフェースの応答性を保ちつつ、不要な処理を省くことでアプリケーションのパフォーマンス向上に繋がります。

特に、大規模なWebアプリケーションやリッチなユーザーインターフェースを持つアプリケーションでの採用が推奨されます。

○サンプルコード6:タイマー処理をキャンセルする方法

TypeScriptを使ってタイマー処理を実装する際、特定の条件下でタイマーをキャンセルしたいケースはよくあります。

ここでは、setTimeoutsetInterval をキャンセルする方法を具体的なサンプルコードを交えて紹介します。

まず、最も基本的な setTimeout をキャンセルする例を考えましょう。

このコードでは setTimeout を使って3秒後にメッセージをログに出力するコードを表しています。

しかし、2秒後にキャンセル処理を実行することで、実際にはメッセージがログに出力されない点を確認してみましょう。

// 3秒後にメッセージを出力するタイマーを設定
let timerId = setTimeout(() => {
    console.log('このメッセージは表示されません。');
}, 3000);

// 2秒後にタイマーをキャンセル
setTimeout(() => {
    clearTimeout(timerId);
    console.log('タイマーをキャンセルしました。');
}, 2000);

この例では setTimeout を2回使用しています。最初の setTimeout で3秒後にメッセージを出力する処理をセットしています。

そして、2つ目の setTimeout で2秒後にキャンセル処理を行っています。

そのため、3秒後に出力されるはずだったメッセージは表示されず、代わりに2秒後に「タイマーをキャンセルしました」というメッセージがログに出力されます。

実際に上記のコードを実行すると、コンソールには「タイマーをキャンセルしました」と表示され、「このメッセージは表示されません」というメッセージは出力されません。

同様に、setInterval もキャンセルが可能です。

setInterval をキャンセルする際には clearInterval 関数を使用します。

次にそのサンプルコードとその説明を紹介します。

// 1秒ごとにメッセージを出力するタイマーを設定
let intervalId = setInterval(() => {
    console.log('1秒ごとにこのメッセージが表示されます。');
}, 1000);

// 5秒後にタイマーをキャンセル
setTimeout(() => {
    clearInterval(intervalId);
    console.log('繰り返しタイマーをキャンセルしました。');
}, 5000);

このコードでは setInterval を使って、1秒ごとにメッセージをログに出力する処理をセットしています。

そして、setTimeout を使用して、5秒後にこの繰り返しタイマーをキャンセルする処理を追加しています。

このコードを実行すると、初めの5秒間は「1秒ごとにこのメッセージが表示されます」というメッセージがコンソールに出力され続けます。しかし、5秒が経過した後にはそのメッセージの出力が停止し、「繰り返しタイマーをキャンセルしました」というメッセージがログに出力されることを確認できます。

タイマー処理のキャンセルは、不要な処理を省き、リソースを節約するために非常に重要です。

特に長い時間実行されるWebページやアプリケーションでは、キャンセル処理を適切に行うことでパフォーマンスの向上やバッテリーの消費を減少させることが期待できます。

○サンプルコード7:複数のタイマー処理を連携させる

TypeScriptでのプログラミングにおいて、複数のタイマー処理をうまく連携させることは、アニメーションや複雑な処理の制御に役立つ技術です。

ここでは、異なるタイマー処理を順番に実行させる方法について、詳細なコード例をもとに解説していきます。

このコードでは、まずsetTimeoutを使って初めてのタイマー処理を実行し、その後に別のsetTimeoutを使って2つ目のタイマー処理を実行するという流れを表しています。

この例では、最初のメッセージを表示してから3秒後に2つ目のメッセージを表示しています。

// TypeScriptのコード例
const firstTimer = () => {
    console.log('最初のタイマー処理です。'); // このメッセージが最初に表示される

    setTimeout(() => {
        console.log('2つ目のタイマー処理が実行されました。'); // このメッセージが3秒後に表示される
    }, 3000);
}

setTimeout(firstTimer, 1000);

このコードを実行すると、まず”最初のタイマー処理です。”というメッセージが1秒後に表示されます。

その後、さらに3秒経過した後に、”2つ目のタイマー処理が実行されました。”というメッセージが表示される流れとなります。

このような連携を取ることで、簡単な処理から複雑なタイマー制御まで、さまざまなタイミングでの動作を実現することが可能となります。

応用例として、Promiseを利用して連鎖的なタイマー処理を実現する方法もあります。

Promiseを利用することで、非同期処理をより柔軟に、そして見通しよく連携させることができます。

const timerPromise = (delay: number, message: string) => {
    return new Promise<void>(resolve => {
        setTimeout(() => {
            console.log(message);
            resolve();
        }, delay);
    });
}

const chainedTimer = async () => {
    await timerPromise(1000, '最初のPromiseベースのタイマー処理');
    await timerPromise(3000, '2つ目のPromiseベースのタイマー処理');
}

chainedTimer();

上記のコードでは、2つのタイマー処理をPromiseを使って連鎖的に実行しています。

最初のタイマー処理が完了した後、次のタイマー処理が実行される流れです。

これにより、タイマー処理の順番を明確に制御しながら、非同期処理を行うことができます。

『TypeScriptでタイマー処理をマスター!10選サンプルコード完全ガイド』

○サンプルコード8:タイマー処理とイベントリスナーの組み合わせ

現代のWebアプリケーション開発において、タイマー処理とイベントリスナーの組み合わせは非常に一般的です。

特に、ユーザーのアクションに応じて何らかの遅延処理を行いたいときや、特定のタイミングでの処理を実現するために、この組み合わせが頻繁に使用されます。

このコードでは、ボタンをクリックすると、3秒後にアラートが表示されるシンプルな例を表しています。

この例では、addEventListenerを使ってボタンのクリックイベントを監視し、イベントが発火したときにsetTimeoutを使用して3秒後にアラートを表示しています。

// HTML要素を取得
const button = document.getElementById('alertButton') as HTMLButtonElement;

// イベントリスナーの追加
button.addEventListener('click', () => {
    // タイマー処理: 3秒後にアラートを表示
    setTimeout(() => {
        alert('3秒経過しました!');
    }, 3000);
});

上記のコードを適切なHTMLファイルに組み込むと、指定されたボタンをクリックすると3秒後に「3秒経過しました!」というアラートが表示されます。

このシンプルな例をベースに、応用やカスタマイズを考えることができます。

例えば、タイマー処理を使用して、ユーザーのアクション後にある期間何も操作がなければ自動でログアウトするという処理や、特定の条件下でのみタイマー処理を発火させるといった複雑な実装も可能です。

また、この基本的なコードを拡張することで、ユーザーがボタンを連続してクリックした場合の処理変更や、複数のイベントリスナーとの連携など、さまざまなシチュエーションに対応することができます。

さらなるカスタマイズ例として、次のような処理を考えてみましょう。

ユーザーがボタンをクリックした後、再度ボタンをクリックする前に3秒経過すると、メッセージが変わるという仕様です。

この場合、次のようなコードを実装できます。

let clickedOnce = false;

const button = document.getElementById('doubleClickButton') as HTMLButtonElement;

button.addEventListener('click', () => {
    if (clickedOnce) {
        alert('2回目のクリックを検知しました!');
        clickedOnce = false;
    } else {
        clickedOnce = true;
        setTimeout(() => {
            if (clickedOnce) {
                alert('再クリックされませんでした');
                clickedOnce = false;
            }
        }, 3000);
    }
});

このコードを実装したWebページでボタンをクリックすると、再度ボタンをクリックする前に3秒が経過すると「再クリックされませんでした」というアラートが表示されます。

しかし、3秒以内に再度ボタンをクリックすると「2回目のクリックを検知しました!」というアラートが表示されます。

○サンプルコード9:カウントダウンタイマーの作成

タイマー処理を利用してカウントダウンタイマーを作成する際のTypeScriptによる実装方法について解説します。

カウントダウンタイマーは、指定された時間が経過するまでの間、1秒ごとにカウントダウンを表示する機能を持つものです。

たとえば、10秒間のカウントダウンを行い、終了時には「終了」と表示するようなものです。

// カウントダウンの開始時間を10秒と設定
let count = 10;

// タイマー処理を1秒ごとに繰り返し行う
const countdown = setInterval(() => {
    // カウントをデクリメント
    count--;

    // カウントが0になったらタイマーを終了し、終了メッセージを表示
    if (count === 0) {
        clearInterval(countdown);
        console.log("終了");
    } else {
        console.log(count);
    }
}, 1000);

このコードでは、setInterval関数を使って1秒ごとにカウントダウンを行うコードを紹介しています。

この例では、変数countをデクリメントしてカウントダウンを進行させています。

countが0になった際には、clearInterval関数を使用してタイマーを停止し、”終了”というメッセージを出力します。

上記のコードを実行すると、10から順に1までの数字が1秒間隔で出力され、最後に”終了”と表示されます。

また、カウントダウンタイマーを作成する際の注意点としては、タイマーの精度を確保することが挙げられます。

JavaScriptやTypeScriptにおけるタイマー処理は、他のタスクとの競合やブラウザのタブが非アクティブになった場合など、予期しない遅延が発生することがあります。

この問題を解決するための応用例として、Dateオブジェクトを使用して正確な経過時間を計算する方法を紹介します。

// 開始時刻と終了時刻を設定
const startTime = new Date();
const endTime = new Date(startTime.getTime() + 10000);  // 10秒後の時刻

const countdown = setInterval(() => {
    const now = new Date();
    const diff = endTime.getTime() - now.getTime();

    if (diff <= 0) {
        clearInterval(countdown);
        console.log("終了");
    } else {
        console.log(Math.ceil(diff / 1000));  // 残り秒数を表示
    }
}, 1000);

この例では、開始時刻と終了時刻をDateオブジェクトとして取得し、それらの差分から残り秒数を計算しています。この方法により、カウントダウンの精度が向上します。

○サンプルコード10:タイマー処理を使ったアニメーションの実装

タイマー処理は、一定の間隔で処理を実行したり、特定の時間後に処理を開始するために使用されるものであり、TypeScriptでもJavaScriptと同様に利用できます。

ここでは、TypeScriptを使用して、タイマー処理を活用したシンプルなアニメーションの実装方法を解説します。

このコードでは、requestAnimationFrameを使ってブラウザのリフレッシュレートに合わせてアニメーションを行うコードを表しています。

この例では、HTMLの要素を一定の速度で左から右へ移動させるアニメーションを作成しています。

// TypeScriptでのアニメーション実装例
const box = document.getElementById("box") as HTMLDivElement;
let position = 0;

function moveBox() {
    // 5ピクセル右に移動
    position += 5;
    box.style.left = position + "px";

    // 画面の右端に到達する前はアニメーションを続ける
    if (position < window.innerWidth) {
        requestAnimationFrame(moveBox);
    }
}

// アニメーション開始
moveBox();

このコードでは、boxというIDを持つdiv要素を取得し、その要素のleftスタイルを変更していることで、一定の速度で左から右へと移動させるアニメーションを実現しています。

また、requestAnimationFrame関数は、ブラウザのリフレッシュレートに合わせて次のフレームの描画を行うための関数です。

これを利用することで、スムーズなアニメーションを実現することができます。

このコードを実際にブラウザで実行すると、指定したHTML要素がスムーズに左から右へ移動するアニメーションが表示されます。

ただし、実際にこのコードを動作させるには、対象となるHTML要素(この例ではIDがboxのdiv要素)を事前にHTML上に配置する必要があります。

さらなる応用として、アニメーションの速度を変更したり、上下左右の異なる方向に動かす、

さらには複数のアニメーションを組み合わせるなどのカスタマイズも可能です。

例えば、下記のコードでは、アニメーションの速度を変更するための変数speedを導入し、これを用いてアニメーションの動きを調整しています。

const box = document.getElementById("box") as HTMLDivElement;
let position = 0;
const speed = 2; // 移動速度を2ピクセルに設定

function moveBox() {
    position += speed;
    box.style.left = position + "px";
    if (position < window.innerWidth) {
        requestAnimationFrame(moveBox);
    }
}

moveBox();

このように、TypeScriptでのタイマー処理を駆使して、独自のアニメーションを実装することができます。

アニメーションの実装には多岐にわたる技術や知識が必要とされる場面も多いため、基本的な動作を理解した上で、さまざまな応用例やカスタマイズを試みることで、より高度なアニメーションを実現することができるでしょう。

●タイマー処理の注意点と対処法

TypeScriptでタイマー処理を実装する際、様々な注意点や対処法が存在します。

今回は、これらの注意点とその解決策について詳細に解説します。

○適切なタイミングでのタイマーのクリア

タイマー処理を使う際、最もよくあるミスの一つは、タイマーのクリアを忘れることです。

これにより、意図しない動作やリソースの無駄使いが生じる可能性があります。

例えば、setTimeoutやsetIntervalを使う際、clearTimeoutやclearIntervalを適切なタイミングで呼び出すことが重要です。

このコードではsetTimeoutを使って1秒後にメッセージを表示するコードを紹介しています。

この例では、ボタンをクリックするとメッセージが表示されるようにしています。

また、別のボタンをクリックするとタイマーがクリアされます。

let timerId: number;

document.getElementById("startTimer").addEventListener("click", () => {
    timerId = setTimeout(() => {
        console.log("1秒後に表示");
    }, 1000);
});

document.getElementById("clearTimer").addEventListener("click", () => {
    clearTimeout(timerId);
});

上記のコードを実行すると、”startTimer”ボタンをクリックすると1秒後にコンソールにメッセージが表示されます。

もし、1秒以内に”clearTimer”ボタンをクリックすると、メッセージは表示されません。

○タイマー処理の精度

JavaScriptやTypeScriptのタイマー処理は、その実行環境や他のタスクの影響を受けるため、厳密な時間精度を持っているわけではありません。

特に、setIntervalを使った繰り返しのタイマー処理は、他の処理との組み合わせや、負荷が高いタスクを繰り返し実行する場合、指定した間隔よりも遅れて実行されることがあります。

この問題を避けるための一つの方法は、次回のタイマーを設定する際の時間を動的に計算することです。

このコードでは、setIntervalを使わずに、setTimeoutを使って繰り返しのタイマー処理を実装するコードを表しています。

この例では、タイマー処理が完了したら次のタイマーを設定しています。

const intervalTime = 1000;
let lastExecutedTime = Date.now();

function repeatFunction() {
    const currentTime = Date.now();
    const deltaTime = currentTime - lastExecutedTime;
    console.log(`経過時間: ${deltaTime}ms`);
    lastExecutedTime = currentTime;
    setTimeout(repeatFunction, intervalTime);
}

repeatFunction();

このコードを実行すると、コンソールに経過時間が表示され、それがおおよそ1秒になるように調整されています。

●カスタマイズ方法

TypeScriptにおけるタイマー処理は、その基本的な機能を超えて、様々なカスタマイズや拡張が可能です。

特に、外部ライブラリを使用することで、より高度なタイマー処理を実現することができます。

今回は、外部ライブラリを使ったタイマー処理のカスタマイズ方法を紹介します。

○外部ライブラリを使ったタイマー処理の拡張

TypeScriptのエコシステムは非常に活発で、多くの外部ライブラリが公開されています。

これらのライブラリを使用することで、独自のタイマー処理や特定のニーズに応える高度な機能を追加することができます。

このコードでは、外部ライブラリ「timer-enhance」を使って、タイマー処理に一定の間隔で実行するインターバル機能を追加するコードを表しています。

この例では、3秒ごとに指定の関数を実行しています。

// 外部ライブラリ「timer-enhance」をインポート
import { EnhancedTimer } from 'timer-enhance';

// EnhancedTimerのインスタンスを作成
const timer = new EnhancedTimer();

// 3秒ごとに実行される関数を設定
timer.setInterval(() => {
    console.log("3秒ごとにこの関数が実行されます");
}, 3000);

// タイマー処理を開始
timer.start();

この例を使うと、通常のタイマー処理よりも簡単に、一定の間隔で関数を実行することができます。

もちろん、このライブラリには他にも様々な機能が提供されています。

例えば、タイマー処理を一時停止したり、再開したり、特定の時間に一度だけ実行するように設定することも可能です。

上述のコードを実行すると、3秒ごとにコンソールに「3秒ごとにこの関数が実行されます」というメッセージが表示されます。

このように、外部ライブラリを利用することで、TypeScriptのタイマー処理をさらに強力にカスタマイズすることができます。

まとめ

本ガイドでは、TypeScriptでのタイマー処理の実装方法を初心者から中級者向けに徹底解説しました。

サンプルコードを通して、基本的なsetTimeoutやsetIntervalの利用方法から、Promiseやasync/awaitを使った高度な処理、さらにはデバウンス機能やタイマー処理のキャンセル方法など、幅広い内容を取り扱いました。

このガイドを通じて、TypeScriptでのタイマー処理の実装に関する技術や知識を深め、日々の開発業務に役立てることができれば幸いです。

引き続き、TypeScriptでの開発を楽しみながら、さらなるスキルアップを目指してください。