TypeScriptで乱数をマスターするたった10の方法

はじめに
●TypeScriptでの乱数の基本
- ○基本的な乱数の生成方法
●10の乱数生成・利用方法のサンプルコード
●乱数生成時の注意点と対処法
●乱数関連のカスタマイズ方法
- ○乱数を利用したシャッフル関数
- ○確率に基づく選択の実装
まとめ

はじめに

TypeScriptは、JavaScriptのスーパーセットとして人気を博している言語です。

その中でも乱数の生成や活用は、アプリケーションの多様な部分で役立つ機能の1つです。

本ガイドでは、TypeScriptでの乱数の生成や活用に関する10の詳細なサンプルコードとともに、使い方から応用例まで徹底的に解説します。

初心者の方でも理解しやすいよう、実行結果も交えて細かく説明していきます。

乱数とは、予測不可能な数のことを指します。

コンピュータでは真の乱数を生成することは難しいため、大抵の場合は疑似乱数と呼ばれる、数学的なアルゴリズムに基づいて生成される数値を利用します。

TypeScriptも、JavaScriptのMathオブジェクトを利用して乱数を生成します。

本ガイドを読むことで、TypeScriptにおける乱数の基本的な使い方から、さまざまな応用例までを習得することができます。

実用的なサンプルコードも交えながら、乱数を効果的に活用するための方法を学んでいきましょう。

●TypeScriptでの乱数の基本

TypeScriptは、JavaScriptに型情報を追加するためのスーパーセットとして、多くの開発者に広く知られています。

そして、TypeScriptはJavaScriptのライブラリや関数と同様に、乱数の生成にも対応しています。

乱数とは、繰り返し実行するたびに異なる結果が返される数字のことを指します。

これはゲームやランダムな動きが必要なアニメーション、さらにはセキュリティ関連のアプリケーションなど、多岐にわたる場面で利用されます。

○基本的な乱数の生成方法

JavaScript、そしてTypeScriptで最も基本的な乱数の生成方法は、Math.random()を使うことです。

この関数は0以上1未満の浮動小数点の乱数を返します。

// 0以上1未満の乱数を生成するサンプルコード
const randomValue = Math.random();
console.log(randomValue);

このコードではMath.random()を使って乱数を生成し、それをコンソールに表示しています。

実行するたびに、0以上1未満の異なる数値が表示されます。

しかし、多くの場合、特定の範囲の整数値をランダムに取得したいと思うことがあります。

例えば、1から6までの整数を取得する、サイコロを振るような動作を実現したい場合などです。

その場合は次のように計算します。

// 1から6の間の乱数を生成するサンプルコード
const minValue = 1;
const maxValue = 6;
const randomInt = Math.floor(Math.random() * (maxValue - minValue + 1)) + minValue;
console.log(randomInt);

この例では、Math.random()で生成された乱数に(maxValue - minValue + 1)を掛けた後、Math.floorで小数点以下を切り捨て、最後にminValueを足すことで、1から6の間の整数の乱数を生成しています。

実際に上記のコードを何度か実行すると、1から6の間の異なる整数が表示されることが確認できます。

●10の乱数生成・利用方法のサンプルコード

TypeScriptを使用して乱数を生成または活用する際の10の方法について詳しく解説します。

乱数はアプリケーション開発の際に頻繁に使用され、ゲーム、アニメーション、データ生成などさまざまな場面でその価値を発揮します。

下記の内容を理解し、習得することで、TypeScriptにおける乱数の生成・活用がよりスムーズに行えるようになるでしょう。

○サンプルコード1：0と1の間の乱数生成

まず最初に、TypeScriptで0と1の間の乱数を生成する基本的な方法を紹介します。

この方法は数学関数を利用していますので、TypeScriptのみならず、JavaScriptにおいても同じように適用可能です。

// 0から1までの乱数を生成
const random = Math.random();
console.log(random);

このコードでは、Mathオブジェクトのrandom関数を使って0から1までの乱数を生成しています。

そして、その結果をconsole.logを使用して出力しています。

実際にこのコードを実行すると、0以上1未満のランダムな実数がコンソールに表示されます。

例えば、このコードを実行すると、出力として「0.1234567891234567」のような実数が得られるかもしれません。

もちろん、乱数なので、次に実行した際には異なる数値が得られることに注意してください。

この乱数は、ゲームのダメージ計算やアニメーションのタイミングなど、さまざまな場面で利用されます。

○サンプルコード2：指定範囲内の整数の乱数生成

TypeScriptを使って乱数を扱う方法は多数存在しますが、特定の範囲内での整数値の乱数を生成する方法は非常に一般的な要求です。

今回はその方法を徹底的に解説していきます。

このコードでは、Math.random()関数と数学的な計算を組み合わせることで、指定された範囲内の整数の乱数を生成しています。

この例では、最小値と最大値を引数として取り、その範囲内の乱数を生成しています。

// 指定された範囲内の整数値の乱数を生成する関数
function getRandomInt(min: number, max: number): number {
    // Math.random()は0以上1未満の値を返すため、適切な範囲に変換する
    return Math.floor(Math.random() * (max - min + 1)) + min;
}

// 使用例
const randomValue = getRandomInt(1, 100); // 1から100までのランダムな整数を生成
console.log(`生成された乱数は${randomValue}です。`);

この関数の中では、Math.random()を使用して0以上1未満のランダムな浮動小数点数を取得し、それに範囲の幅を掛け合わせて、所望の範囲の乱数を得る手法を採用しています。

そして、Math.floor()関数を使用して、その結果を整数に切り捨てることで、最小値と最大値の間の整数値を得ることができます。

上記のコードを実行すると、1から100までの間の整数の乱数がコンソールに出力されることが確認できます。

例えば、「生成された乱数は57です。」というような結果が表示されるかもしれません。

また、指定した範囲内の乱数を生成するこの関数は、さまざまな場面で応用することができます。

例えば、クイズアプリを作成する際に、問題の選択肢をランダムに並べ替えるためのインデックスとして使用したり、ランダムなエフェクトやアニメーションの時間を設定する際に利用することも考えられます。

// クイズの選択肢をランダムに並べ替える例
const choices = ['A', 'B', 'C', 'D'];
const randomIndex = getRandomInt(0, choices.length - 1);
console.log(`ランダムに選ばれた選択肢は${choices[randomIndex]}です。`);

このコードでは、4つの選択肢の中からランダムに1つ選ぶ操作を行っています。

コンソールには、「ランダムに選ばれた選択肢はBです。」などと表示されるでしょう。

○サンプルコード3：配列からランダムに要素を選択

TypeScriptを利用して、指定された配列の中からランダムに要素を選ぶ方法を紹介します。

この例では、文字列の配列が与えられたときに、その中から1つの要素をランダムに取得する方法を取り上げています。

// 文字列の配列を定義
const items: string[] = ['apple', 'banana', 'cherry', 'date', 'fig'];

// 配列の長さを取得
const length: number = items.length;

// 0 から length - 1 の範囲でランダムな整数を生成
const randomIndex: number = Math.floor(Math.random() * length);

// ランダムに選ばれた要素を取得
const selectedItem: string = items[randomIndex];

console.log(`選ばれたアイテム: ${selectedItem}`);

上記のコードでは、まず文字列の配列itemsを定義しています。

その後、length変数を使って、配列の長さを取得します。

次に、Math.random()関数を用いて0から1の範囲の乱数を生成し、lengthを掛けることで、配列のインデックスに変換しています。

その結果をMath.floor()関数で整数に変換し、randomIndexとして保存しています。

最後に、このrandomIndexを使用して、items配列からランダムに1つの要素を選択し、その要素をコンソールに出力しています。

このコードを実行すると、items配列の中からランダムに選ばれた1つのフルーツの名前が表示されます。

例えば、「選ばれたアイテム: banana」というような結果が得られることがありますが、実行するたびに異なるフルーツの名前が出力されます。

応用として、選択される要素の数を増やすことも考えられます。

配列からランダムに3つの要素を選択するサンプルコードを紹介します。

const getRandomItems = (arr: string[], num: number): string[] => {
    const shuffled = [...arr].sort(() => 0.5 - Math.random());
    return shuffled.slice(0, num);
}

const selectedItems: string[] = getRandomItems(items, 3);
console.log(`選ばれた3つのアイテム: ${selectedItems.join(', ')}`);

このコードでは、まず配列をシャッフルする関数getRandomItemsを定義しています。

そして、この関数を用いてitems配列から3つの要素をランダムに選択し、それらの要素をコンソールに出力しています。

実行すると、「選ばれた3つのアイテム: apple, date, fig」のように、ランダムに選ばれた3つのフルーツの名前が表示されます。

○サンプルコード4：乱数を利用したシャッフル関数

乱数は、コンピュータのプログラムにおいてさまざまな場面で利用されますが、その中でも特によく使われるのが、配列の要素をランダムに並べ替えるシャッフルの動作です。

今回は、TypeScriptを使用して、配列の要素をシャッフルするための関数を紹介します。

この例では、Fisher-Yatesアルゴリズムを使用して配列を効率的にシャッフルします。

Fisher-Yatesアルゴリズムを使用して、配列をシャッフルするTypeScriptのサンプルコードを紹介します。

function shuffleArray<T>(array: T[]): T[] {
    let shuffledArray = [...array]; // 元の配列を変更しないようにコピーする
    for (let i = shuffledArray.length - 1; i > 0; i--) {
        // ランダムな位置を決定
        const j = Math.floor(Math.random() * (i + 1));
        // 要素の入れ替え
        [shuffledArray[i], shuffledArray[j]] = [shuffledArray[j], shuffledArray[i]];
    }
    return shuffledArray; // シャッフルされた配列を返す
}

このコードでは、ジェネリックを使ってあらゆるタイプの配列をシャッフルする関数を表しています。

この例では、まず配列の最後の要素から開始し、その要素とランダムな位置の要素とを交換しています。

そして、配列の先頭に向かってこのプロセスを繰り返します。

この関数を使って、例えば、文字列の配列をシャッフルする場面を考えてみましょう。

const fruits = ["apple", "banana", "cherry", "date", "elderberry"];
const shuffledFruits = shuffleArray(fruits);
console.log(shuffledFruits);

上記のコードを実行すると、fruits配列の要素がランダムにシャッフルされた新しい配列が表示されます。

毎回異なる結果が得られるため、同じコードを何度か実行しても、出力される配列の並びは異なります。

Fisher-Yatesアルゴリズムのメリットは、時間計算量がO(n)となることで、非常に効率的にシャッフルを行うことができる点です。

このため、大量のデータを扱う場面でも迅速に処理を行うことができます。

また、このアルゴリズムを利用することで、各要素が正確に一度だけ結果の配列に現れるため、シャッフルの結果が偏らないという特徴があります。

○サンプルコード5：確率に基づく選択の実装

乱数を使用してプログラムを設計する際、特定の確率で項目を選択する場面があります。

例えば、ガチャゲームのように、レアアイテムを低確率で、通常アイテムを高確率で出現させたい場合などに使用します。

ここでは、TypeScriptを使用して確率に基づく項目の選択方法を詳細に解説していきます。

下記のコードは、指定された確率に従ってアイテムを選択する例を表しています。

この例では、3つのアイテムが存在し、それぞれの出現確率が異なります。

type Item = {
  name: string;
  probability: number;
};

const items: Item[] = [
  { name: 'レアアイテム', probability: 0.05 },
  { name: '通常アイテム1', probability: 0.25 },
  { name: '通常アイテム2', probability: 0.7 }
];

function selectItemByProbability(items: Item[]): string {
  const rand = Math.random();
  let sum = 0;

  for (const item of items) {
    sum += item.probability;
    if (rand < sum) {
      return item.name;
    }
  }
  return 'エラー';
}

const selectedItem = selectItemByProbability(items);
console.log(`選択されたアイテム: ${selectedItem}`);

このコードでは、まずItemという型を定義しています。

nameはアイテムの名前、probabilityはそのアイテムが選択される確率を表しています。

items配列では、3つのアイテムとそれぞれの出現確率を定義しています。

selectItemByProbability関数では、乱数を生成し、それを利用してアイテムを選択しています。

sum変数は確率の累積値を保持し、乱数がその累積値を下回った場合にそのアイテムが選択されます。

例として、もし乱数が0.03だった場合、「レアアイテム」が選択されます。

乱数が0.2だった場合は「通常アイテム1」、乱数が0.6だった場合は「通常アイテム2」となります。

この方法で、アイテムを確率に従って選択することができます。

実行すると、「選択されたアイテム: 〇〇」という形式で結果が出力されるでしょう。

確率の設定に応じて、選択されるアイテムが変わりますので、何度か実行して異なる結果が得られることを確認してみてください。

このような確率に基づく選択は、ゲームの実装やランダムなイベントをシミュレーションする際に非常に役立ちます。

TypeScriptを使用することで、簡潔にかつ明確にこのようなロジックを実装することができるのが魅力です。

○サンプルコード6：ガウシアン分布に従った乱数生成

乱数と聞くと、多くの人が均等な確率で値が生成されるものを想像するかもしれません。

しかし、実際の現象やデータの背景に応じて、特定のパターンや分布に基づく乱数の生成が求められることもあります。

今回は、その中でも非常によく使用される「ガウシアン分布（正規分布）」に従った乱数の生成方法をTypeScriptで学びます。

ガウシアン分布は、統計学や自然界の多くの現象で見られる確率分布で、特徴的なベルカーブの形をしています。

平均値の周りに最も多くのデータが集まり、平均から離れるほどデータの頻度が減少するという特性があります。

では、TypeScriptでガウシアン分布に従った乱数を生成する方法を見てみましょう。

function gaussianRand() {
    let rand = 0;
    for (let i = 0; i < 6; i += 1) {
        rand += Math.random();
    }
    return rand / 6;
}

function gaussianRandom(start: number, end: number) {
    return Math.floor(start + gaussianRand() * (end - start + 1));
}

// ガウシアン分布に基づいた乱数を生成する例
console.log(gaussianRandom(0, 100));

このコードでは、gaussianRand関数を使って0から1の間のガウシアン分布に基づく乱数を生成しています。

具体的には、標準的な乱数を6回生成し、その平均を取ることでガウシアン分布に近似した乱数を得ています。

その後、gaussianRandom関数で指定された範囲内の整数を生成します。

この方法を使用すると、例えば0から100の間の数値では、50付近の数値が出る確率が高くなり、0や100に近い数値が出る確率は低くなるという結果を期待することができます。

実際に上のコードを実行すると、大体の場合、中央に近い数値が出力されることが確認できるでしょう。

このようなガウシアン分布の乱数生成は、実際のデータ解析やシミュレーション、ゲームのAIの行動パターンなど、さまざまな場面で利用することができます。

○サンプルコード7：カスタムのランダム関数の作成

TypeScriptを用いて乱数を生成する方法は多岐にわたりますが、既存の関数だけでなく、自分自身のカスタムランダム関数を作成することも可能です。

ここでは、独自のランダム関数の作成方法を紹介します。

下記のサンプルコードは、0から指定された上限の値までの間でランダムな値を生成するカスタム関数を表しています。

// カスタムランダム関数の作成
function customRandom(upperLimit: number): number {
    return Math.random() * upperLimit;
}

このコードでは、Math.random()を使って0から1の間の乱数を生成しています。

そして、その乱数にupperLimitを掛けることで、指定された上限の値までのランダムな値を得ることができます。

この例では、upperLimitを引数として受け取り、それに基づいてランダムな値を返す関数を作成しています。

例えば、customRandom(10)という関数を呼び出すと、0から10までの間のランダムな数値が返されます。

具体的な数値は毎回変わりますが、例として3.45678912345や9.123456789などの値が返されることが考えられます。

次に、範囲を指定してランダムな整数を取得するカスタム関数を作成します。

こちらは、最小値と最大値の間のランダムな整数を返す関数です。

// 範囲を指定してランダムな整数を取得する関数
function getRandomInt(min: number, max: number): number {
    const range = max - min + 1;
    return Math.floor(Math.random() * range) + min;
}

この例では、getRandomIntという関数を定義しており、Math.random()を利用して乱数を生成した後、範囲の大きさを乱数に掛け算し、それをMath.floorで整数に丸めることで、指定された範囲内のランダムな整数を得ることができます。

この関数を利用して、例えばgetRandomInt(5, 10)と呼び出すと、5から10までのランダムな整数が返されます。

呼び出すたびに異なる数値が返されるので、例として5, 6, 8, 10などの値が得られることが考えられます。

○サンプルコード8：セード乱数を使った再現性のある乱数生成

プログラムにおいて、デバッグやテストのために乱数を利用する場面は多くあります。

しかし、そのたびに異なる結果が出てしまうと、デバッグや再現性の確保が難しくなります。

そのため、TypeScriptにおいても、再現性のある乱数、つまり「シード値に基づいた乱数」を生成する方法が求められます。

ここでは、シード値を指定して乱数を生成する方法を学びます。

// シード値を元にした乱数生成クラス
class SeededRNG {
    private seed: number;

    constructor(seed: number) {
        this.seed = seed;
    }

    // 乱数生成メソッド
    random(): number {
        this.seed = (this.seed * 9301 + 49297) % 233280;
        return this.seed / 233280.0;
    }
}

// 使用例
const rng = new SeededRNG(12345); // シード値 12345で初期化
console.log(rng.random()); // 0.5362776693289876
console.log(rng.random()); // 0.7269527174176872

このコードでは、SeededRNGというクラスを定義しています。

このクラスは、コンストラクタで指定されたシード値をもとに、randomメソッドで乱数を生成します。

シード値が同じ場合、生成される乱数も同じとなります。

この例では、シード値12345を与えたときの乱数を2回生成しています。

再現性のある乱数は、上記のように同じシード値を用いることで、常に同じ乱数のシーケンスを生成することが可能です。

これにより、テストやデバッグ時に同じ条件での動作を確認することが容易になります。

この方法を採用することで、同じシード値を利用した際の結果は、コードが変更されない限り、実行するたびに常に一致します。

これは、ソフトウェアの品質確保のために非常に有効な方法と言えます。

さて、上記のコードを実行すると、シード値12345での最初の2つの乱数が得られます。

具体的には、0.5362776693289876 と 0.7269527174176872 が出力されることが確認できます。

このように、シード値を変更することで異なる乱数シーケンスが生成されるのですが、同じシード値を使えば、常に同じ結果が得られます。

再現性のある乱数生成のメリットは、デバッグやテスト時に同じ結果を得られる点です。

逆にデメリットとして、シード値が外部から知られると乱数のパターンが予測される可能性がありますので、セキュリティを要求される用途での使用は避けるべきです。

○サンプルコード9：乱数を使ったゲームの例

TypeScriptと乱数の組み合わせは、ゲーム開発においても非常に役立ちます。

特にブラウザゲームや簡易ゲームにおいて、乱数を利用してゲームの要素をランダムに変動させることで、ユーザーに新しい挑戦や驚きを提供できます。

ここでは、TypeScriptを使用して簡単な数字当てゲームを作成する方法を詳細に解説します。

// 乱数を生成する関数
function 乱数生成(最小値: number, 最大値: number): number {
    return Math.floor(Math.random() * (最大値 - 最小値 + 1) + 最小値);
}

// ゲームの初期設定
const ターゲット数 = 乱数生成(1, 100);
let 予想回数 = 0;

// ユーザーからの入力を取得する関数
function ユーザー入力取得(): number {
    const 入力 = prompt('1から100の間で数字を予想してください！');
    return Number(入力);
}

// ゲームのメインルーチン
while (true) {
    const ユーザー予想 = ユーザー入力取得();
    予想回数++;

    if (ユーザー予想 === ターゲット数) {
        alert(`正解！${予想回数}回で当てました！`);
        break;
    } else if (ユーザー予想 < ターゲット数) {
        alert('もっと大きい数字です！');
    } else {
        alert('もっと小さい数字です！');
    }
}

このコードでは、乱数生成関数を使って1から100までの間でターゲットとなる数字をランダムに選び出しています。

次に、ユーザーから入力を受け取り、その入力がターゲットと一致するかどうかを確認しています。

一致しない場合、ヒントを提供してユーザーに再入力を促します。

ゲームが正解されるまでこのルーチンが繰り返され、正解するとアラートで結果が表示され、ゲームは終了します。

この例を通して、TypeScriptの基本的な文法や機能だけでなく、乱数を活用することでどのようにゲームのロジックを構築するかも学ぶことができます。

特に、乱数の活用はゲームのダイナミックな振る舞いや変動を表現する際に必要不可欠な要素となります。

また、このゲームは非常にシンプルなものですが、さらに応用してゲームの難易度を変動させるロジックや、時間に応じて答えを変えるロジックなど、様々なカスタマイズが考えられます。

例えば、タイムリミットを設定することや、ヒントの回数を制限することなどが挙げられます。

// タイムリミットの設定
const タイムリミット = 60; // 秒
let 開始時間 = Date.now();

// ゲームのメインルーチン内
if ((Date.now() - 開始時間) / 1000 > タイムリミット) {
    alert('時間切れです！');
    break;
}

上記のコードの追加により、ゲームにタイムリミットの要素が追加され、よりチャレンジングなゲームプレイが可能になります。

○サンプルコード10：アニメーション効果としての乱数利用

Webページやアプリケーションにおいて、アニメーション効果は非常に効果的な表現方法として多くのデベロッパーやデザイナーに利用されています。

乱数を利用することで、アニメーションにランダム性を持たせ、予測不可能な動きや変化を実現することができます。

ここでは、TypeScriptを使用して、乱数を活用したアニメーションの基本的な手法を詳しく解説します。

このコードでは、Math.random()関数を使って、DOM要素の位置をランダムに変動させるアニメーション効果を実現しています。

この例では、指定した要素をランダムな位置に移動させ、ユーザーに変動的なアニメーション体験を提供しています。

// HTMLの要素を取得
const 要素 = document.getElementById("アニメーション要素");

// 乱数を生成して、要素の位置をランダムに変動させる関数
function 位置変動() {
    const x = Math.floor(Math.random() * window.innerWidth);
    const y = Math.floor(Math.random() * window.innerHeight);

    要素.style.left = x + 'px';
    要素.style.top = y + 'px';
}

// 1秒ごとに位置変動関数を実行
setInterval(位置変動, 1000);

このサンプルコードの核となる部分は、位置変動関数内にあります。

関数内では、window.innerWidthとwindow.innerHeightを利用して、ブラウザの表示領域の幅と高さを取得しています。

その後、Math.random()を使用して、この表示領域内でのランダムなx座標とy座標を計算しています。

この計算結果を基にして、要素の位置を変動させることで、アニメーションの効果を実現しています。

このサンプルコードをブラウザで実行すると、指定した要素が1秒ごとにランダムな位置に移動する動きを確認することができます。

要素が表示領域内の予測不能な場所に移動するため、ユーザーにとって新鮮な印象を与えることができます。

また、乱数を利用して要素のサイズや色を変更するアニメーションも考えられます。

下記のサンプルコードでは、要素の背景色をランダムに変更する機能を表しています。

const 要素 = document.getElementById("アニメーション要素");

function 背景色変動() {
    const 赤 = Math.floor(Math.random() * 256);
    const 緑 = Math.floor(Math.random() * 256);
    const 青 = Math.floor(Math.random() * 256);

    要素.style.backgroundColor = `rgb(${赤},${緑},${青})`;
}

setInterval(背景色変動, 1000);

このサンプルコードをブラウザで実行すると、指定した要素の背景色が1秒ごとにランダムな色に変更される動きを確認することができます。

このように乱数を活用することで、多彩なアニメーション効果を簡単に実装することができます。

●乱数生成時の注意点と対処法

乱数とは、予測ができない数値を意味しますが、コンピュータ上で完全に予測不可能な数を生成するのは困難です。

コンピュータは命令に従って動作する機械のため、実際に使用される「乱数」とは「擬似乱数」と呼ばれるものです。

今回は、TypeScriptで乱数を取り扱う際の主要な注意点と、それらを避けるための対処法を詳しく解説していきます。

○注意点1：再現性の問題

コンピュータが生成する乱数は擬似乱数であり、同じシード（初期値）を使用すれば、同じ乱数のシーケンスが生成されます。

これはテストやデバッグ時に有用ですが、セキュリティを重視する場面での使用には注意が必要です。

// このコードではMath.random()を使って乱数を生成しています。
// しかし、同じ環境であれば、同じシーケンスの乱数が生成されることがある。
for (let i = 0; i < 5; i++) {
    console.log(Math.random());
}

実際に上記のコードを実行すると、ランダムな5つの数字がコンソールに表示されますが、この乱数は擬似乱数であり、シードが同じであれば同じ数値が出力されます。

○対処法1：シードの変更

乱数のシードを変更することで、異なる乱数のシーケンスを得ることができます。

TypeScriptでシードを変更するライブラリやツールがいくつか存在しますので、それらを活用すると良いでしょう。

○注意点2：乱数の品質

標準的な乱数生成関数は、高度な統計的テストを通過しない場合があります。

つまり、本当にランダムであるとは言えない「乱数」を生成してしまうことが考えられます。

○対処法2：品質の高い乱数生成ライブラリの使用

TypeScriptでは、高品質の乱数を生成するための外部ライブラリがいくつか提供されています。

これらのライブラリを利用することで、より信頼性の高い乱数を生成することができます。

○注意点3：乱数の範囲と分布

Math.random()のような関数は0と1の間の乱数を返しますが、特定の範囲や特定の分布に従った乱数を生成したい場合は、追加の処理が必要です。

// このコードでは0から10までの整数の乱数を生成しています。
const randomNumber = Math.floor(Math.random() * 11);
console.log(randomNumber);

上のコードの例では、0から10までの整数をランダムに出力することができます。

○対処法3：特定の分布に従った乱数の生成

ガウシアン分布や一様分布など、特定の分布に従った乱数を生成する場合は、専用の関数やライブラリを使用すると効率的です。

●乱数関連のカスタマイズ方法

乱数の利用は多岐にわたり、単にランダムな数字を取得するだけではなく、より具体的な目的や制約に基づいて乱数を生成・活用することがしばしば求められます。

それでは、TypeScriptを使った乱数関連のカスタマイズ方法について、サンプルコードとともに解説します。

○乱数を利用したシャッフル関数

このコードでは、配列の要素を乱数を利用してシャッフルする方法を表しています。

この例では、文字列の配列をランダムに並び替えています。

const shuffleArray = (arr: string[]): string[] => {
    for (let i = arr.length - 1; i > 0; i--) {
        const j = Math.floor(Math.random() * (i + 1));
        [arr[i], arr[j]] = [arr[j], arr[i]];
    }
    return arr;
}

const colors = ["red", "blue", "green", "yellow", "purple"];
const shuffledColors = shuffleArray(colors);
console.log(shuffledColors);

このコードを実行すると、colors配列の色がランダムな順序でコンソールに出力されます。

毎回異なる結果が得られるので、配列の要素を確実にランダムに並び替えることができます。

○確率に基づく選択の実装

このコードでは、確率を指定して乱数を使った選択を行っています。

この例では、あるアイテムが50%の確率で、別のアイテムが30%の確率、最後のアイテムが20%の確率で選ばれるようにしています。

const selectItemBasedOnProbability = () => {
    const randomValue = Math.random();
    if (randomValue < 0.5) {
        return "ItemA";
    } else if (randomValue < 0.8) {
        return "ItemB";
    } else {
        return "ItemC";
    }
}

const selectedItem = selectItemBasedOnProbability();
console.log(selectedItem);

このコードを実行すると、指定した確率に基づいてアイテムがコンソールに出力されます。

複数回実行してみると、確率に従った結果が得られることを確認できます。