TypeScriptでbigint型を使う12の方法

はじめに
●TypeScriptとbigint型の基本
- ○bigint型とは？
- ○bigintの宣言方法
●bigint型の使い方
●bigint型の応用例
●bigint型の注意点と対処法
●bigintのカスタマイズ方法
- ○関数を通じてのbigintの初期化
- ○bigintを用いたカスタム計算
まとめ

はじめに

TypeScriptが急速に人気を集めている現代の開発環境において、特に大きな数値を取り扱う場面で「bigint型」の存在は無視できません。

この記事では、TypeScriptでのbigint型の基本から実践的な使い方、カスタマイズ方法まで、初心者から中級者向けに徹底的に解説します。

bigint型の魅力や応用法を習得することで、より多彩なプログラムを構築する手助けとなることを願っています。

●TypeScriptとbigint型の基本

TypeScriptは、JavaScriptに静的な型を導入することで、より安全かつ効率的にコードを書くことができるように設計された言語です。

このTypeScriptが提供するデータ型の中で、特に注目すべきものが「bigint型」です。

○bigint型とは？

bigint型は、JavaScriptとTypeScriptの新しい数値型で、任意の大きさの整数を扱うことができる特性を持っています。

従来の数値型であるNumber型は、IEEE 754標準の64ビット浮動小数点数をベースとしているため、正確に表現できる整数の範囲が限定されていました。

しかし、bigint型の導入により、それ以上の大きさの整数も扱うことが可能となりました。

特に、金融や科学計算、暗号技術など、高い精度の計算を必要とする分野での利用が期待されています。

このコードでは、Number型とbigint型の最大値を比較しています。

Number型の最大値を超えた数値を正確に扱う場面で、bigint型がいかに役立つかを表しています。

const maxNumber = Number.MAX_SAFE_INTEGER;
const bigIntValue = 9007199254740993n; // nを付けることでbigintリテラルとなる

console.log(`Numberの最大値: ${maxNumber}`);
console.log(`bigint型の値: ${bigIntValue}`);

このコードを実行すると、Numberの最大値と比べて、bigint型ではそれを超えた数値も正確に扱っていることが確認できます。

○bigintの宣言方法

TypeScriptでbigint型を宣言するには、変数にnをつけたリテラルを代入するか、BigInt関数を使用して変数に代入します。

いくつかの方法でbigint型の変数を宣言するサンプルコードを紹介します。

// リテラルを用いたbigintの宣言
let value1: bigint = 12345n;

// BigInt関数を使用したbigintの宣言
let value2: bigint = BigInt("12345");

console.log(`value1: ${value1}`);
console.log(`value2: ${value2}`);

このコードでは、リテラルを使用した方法とBigInt関数を使用した方法の2種類でbigint型の変数を宣言しています。

両方の方法で同じ結果を得られることが確認できるでしょう。

●bigint型の使い方

TypeScriptの中で、数値を取り扱う際の新しい方法としてbigint型が登場しました。

これは、従来のnumber型では取り扱えない非常に大きな整数を簡単に操作するためのデータ型です。

ここでは、bigint型の基本的な使用方法を詳しく解説します。

○サンプルコード1：基本的なbigintの宣言と使用

まずは、bigint型の変数をどのように宣言するのかを見ていきましょう。

// bigint型の変数を宣言
const bigValue: bigint = 1234567890123456789012345678901234567890n;

// bigint型のリテラルには最後に "n" を付けます
const anotherBigValue = 9876543210987654321098765432109876543210n;

console.log(bigValue + anotherBigValue);

このコードでは、bigint型を使って非常に大きな整数を宣言しています。

変数bigValueとanotherBigValueは、それぞれ適当な大きな整数を代入しています。

この時、bigintリテラルを使用する場合は、数値の最後にnを付けることでbigint型として認識されます。

このコードを実行すると、bigValueとanotherBigValueの合計値が出力されます。

従来のnumber型では扱えないような大きな整数の加算も、bigintを使うことで簡単に実行できます。

続いて、上記のコードを実行した際の結果を確認します。

非常に大きな整数を加算した結果、さらに大きな整数が出力されることを確認できます。

上記の例を実行すると、コンソールに次のような結果が表示されます。

11111111101111111110111111111101111111100n

このように、bigint型を使うことで、JavaScriptやTypeScriptの中で従来難しかった大きな整数の計算を簡単に行うことができます。

特に金融系のアプリケーションや、高精度な計算が必要な場面での活用が期待されています。

○サンプルコード2：bigintでの加減算

TypeScriptにおいて、通常の数値型で扱うことが難しい超大きな数字を扱う際、bigint型が非常に有用です。

ここでは、bigint型を用いて加減算を行う方法について、詳しく解説します。

まず、基本的なサンプルコードを紹介します。

// BigIntの値の宣言
let num1: bigint = 1000000000000000000000n;
let num2: bigint = 2000000000000000000000n;

// 加算
let resultAdd: bigint = num1 + num2;
console.log(`加算の結果：${resultAdd}`);

// 減算
let resultSub: bigint = num2 - num1;
console.log(`減算の結果：${resultSub}`);

このコードでは、初めに2つのbigint型の値を宣言しています。

続いて、これらの値を用いて加算と減算を行い、その結果をコンソールに表示しています。

このサンプルコードを実行すると、加算と減算の結果が表示されます。

具体的には、加算の結果として「3000000000000000000000」という値が、減算の結果として「1000000000000000000000」という値がそれぞれ出力されるでしょう。

○サンプルコード3：bigintと数値の型変換

TypeScriptでの数値計算の際、通常の数値型だけでなく、特に大きな数値を扱う必要がある場合、bigint型を使用することが考えられます。

一方、bigint型と通常の数値型（number型）の間で型変換を行う必要が生じることも少なくありません。

ここでは、bigint型とnumber型の間での型変換方法について説明します。

まず、bigint型をnumber型に変換する基本的な方法を見ていきましょう。

このコードでは、あるbigint値をnumber型に変換しています。

// bigintの値を定義
const bigValue: bigint = 1234567890123456789012345678901234567890n;

// bigintをnumberに変換
const numberValue: number = Number(bigValue);

console.log(`変換後の数値: ${numberValue}`);

このコードを実行すると、bigValueが表すbigintの値がnumber型に変換され、その結果がnumberValueとして出力されます。

ただし、数値が大きすぎると精度の問題が発生する可能性があるので注意が必要です。

次に、number型をbigint型に変換する方法を見ていきます。

このコードでは、あるnumber値をbigint型に変換しています。

// numberの値を定義
const numericValue: number = 1234567890;

// numberをbigintに変換
const bigIntConverted: bigint = BigInt(numericValue);

console.log(`変換後のbigint: ${bigIntConverted}`);

上記のコードを実行すると、numericValueが表すnumberの値がbigint型に変換され、その結果がbigIntConvertedとして出力されます。

○サンプルコード4：bigintの比較

TypeScriptのbigint型は、JavaScriptにおいて大きな整数を扱うための新しいデータ型です。

ここでは、bigint型の数値同士を比較する方法について詳しく解説していきます。

一般的な数値型の場合と同様に、bigint型でも比較演算子を利用して大小関係を調べることが可能です。

具体的なコードを紹介します。

const num1: bigint = 1000000000000000000000n;
const num2: bigint = 999999999999999999999n;

if (num1 > num2) {
    console.log("num1はnum2より大きい");
} else if (num1 < num2) {
    console.log("num1はnum2より小さい");
} else {
    console.log("num1とnum2は等しい");
}

このコードでは、まずnum1とnum2という二つのbigint型の変数を宣言しています。

それぞれの変数には非常に大きな整数値が代入されています。そして、if文を使ってこれらの数値を比較しています。

このコードを実行すると、num1がnum2より大きいので、”num1はnum2より大きい”と表示されます。

一般的な数値型と同じように、==や!=を使用して、二つのbigint型の数値が等しいかどうかを判断することもできます。

ただし、TypeScriptで型の安全性を高めるため、===や!==を使用することをおすすめします。

次に示すコードは、bigint型の変数が等しいかどうかを確認する例です。

const num3: bigint = 1234567890123456789012345678901234567890n;
const num4: bigint = 1234567890123456789012345678901234567890n;

if (num3 === num4) {
    console.log("num3とnum4は等しい");
} else {
    console.log("num3とnum4は等しくない");
}

このコードでは、num3とnum4という二つのbigint型の変数に同じ値を代入し、それらが等しいかどうかを===演算子を使って確認しています。

このコードを実行すると、”num3とnum4は等しい”と表示されるでしょう。

●bigint型の応用例

ビッグインテージャーとして知られるbigint型は、非常に大きな整数値を扱うことができる特性を持っています。

そのため、多くのプログラムで役立つ応用的な利用方法が存在します。ここでは、bigint型を使った大数計算に焦点を当てて詳しく解説します。

○サンプルコード5：bigintを使った大数計算

数値計算の中で、特に大きな数値を取り扱う場面では、通常のnumber型ではオーバーフローしてしまい正確な計算ができません。

しかし、bigint型を使用することでこの問題を解消することができます。

次のコードは、通常のnumber型とbigint型で非常に大きな数の計算を試みる例です。

// 通常のnumber型での大数計算
let largeNumber: number = 9007199254740991; 
console.log(largeNumber + 1); // 9007199254740992
console.log(largeNumber + 2); // 9007199254740992 ← 正しくない結果

// bigint型での大数計算
let largeBigInt: bigint = 9007199254740991n; 
console.log(largeBigInt + 1n); // 9007199254740992n
console.log(largeBigInt + 2n); // 9007199254740993n ← 正しい結果

このコードでは、まず通常のnumber型で大数計算を試みています。

しかし、加算結果が正確でないことがわかります。一方、bigint型を使用することで、期待通りの計算結果を得ることができます。

具体的には、largeNumber + 2の計算結果が正確でないことが確認できます。

一方で、bigint型を使用した場合のlargeBigInt + 2nは、正確な結果を返しています。

また、bigint型のリテラルは数値の後ろにnを付けることで表現します。

このnがあることで、TypeScriptはこの値をbigint型として認識するのです。

○サンプルコード6：bigintでのビット操作

ビット操作は、情報の最小単位であるビットを直接操作する技術です。

TypeScriptのbigint型は、非常に大きな数値を扱うことができるため、ビット操作を用いることで高度な計算やデータの取り扱いを実現できます。

ここでは、bigint型での基本的なビット操作をいくつかのサンプルコードとともに徹底解説します。

// ビットシフトによる倍数・半数計算
let num1: bigint = 2n;

// 左シフトにより、num1を2倍にする
let doubled = num1 << 1n; // 4n
// 右シフトにより、num1を半分にする
let halved = num1 >> 1n; // 1n

// ビットの論理演算
let num2: bigint = 6n; // 110 (2進数)
let num3: bigint = 3n; // 011 (2進数)

// 論理積(AND)
let andResult = num2 & num3; // 2n, 010 (2進数)
// 論理和(OR)
let orResult = num2 | num3; // 7n, 111 (2進数)
// 排他的論理和(XOR)
let xorResult = num2 ^ num3; // 5n, 101 (2進数)

このコードでは、まずビットシフトを使ってbigint型の数値を倍にしたり、半分にしたりしています。

具体的には、<<を使って左に1ビットシフトすることで数値を2倍にし、>>を使って右に1ビットシフトすることで数値を半分にしています。

次に、ビットの論理演算を利用しています。&は論理積を、|は論理和を、^は排他的論理和を計算します。

これらのビット操作を使うことで、異なる2つのbigint値の各ビット間での論理計算を行うことができます。

たとえば、num2のビット表現は110、num3のビット表現は011です。

これら2つの数値で論理積を取ると、中央のビットだけが1となるため、結果は010、すなわち2nとなります。

実際に上記のコードを実行すると、doubledは4n、halvedは1n、andResultは2n、orResultは7n、xorResultは5nとなります。

○サンプルコード7：bigintと配列の操作

TypeScriptの強力な型、bigintは、配列との連携も可能です。

大きな数値を格納している配列との操作をスムーズに行うためには、この連携を理解することが鍵となります。

□配列の中の各bigintを加算する

配列の各要素を合計する際、通常の数値型と同様にreduce関数を使用できますが、bigintを使用する際は、初期値として0nを指定します。

// 配列内の各bigintの合計を計算
const arr: bigint[] = [10n, 20n, 30n, 40n];
const sum = arr.reduce((acc, val) => acc + val, 0n); 
console.log(sum);  // 出力結果: 100n

このコードでは、reduceを使って配列内の各bigint要素を加算しています。

結果として、配列内のすべての要素が合計され、100nが得られます。

□配列の中の特定の条件を満たすbigintを抽出する

filter関数を使用して、配列内の特定の条件を満たすbigintのみを取り出すことができます。

// 20nより大きい数値のみを抽出
const filtered = arr.filter(num => num > 20n);
console.log(filtered);  // 出力結果: [30n, 40n]

上記のコードでは、20nより大きいbigintのみを抽出しています。

そのため、出力結果としては[30n, 40n]という新しい配列が得られます。

□配列内のbigintを変換する

map関数を使用して、配列内の各bigintを別の値に変換することも可能です。

// 配列内の各bigintを2倍にする
const doubled = arr.map(num => num * 2n);
console.log(doubled);  // 出力結果: [20n, 40n, 60n, 80n]

このコードでは、配列内の各要素を2倍にしています。

したがって、[20n, 40n, 60n, 80n]という新しい配列が生成されます。

○サンプルコード8：bigintを活用した関数の作成

TypeScriptのbigint型は、大きな整数値を扱う際に非常に役立つ型です。

特に、一般的な数値型で扱えない非常に大きな数値を取り扱う必要がある際や、計算の精度を維持したいときに、bigint型がその真価を発揮します。

こっこでは、bigint型を使用して独自の関数を作成する方法を詳しく解説します。

具体的には、2つのbigint値を引数として受け取り、それらの値の最大公約数を返す関数を作成してみましょう。

// 最大公約数を求める関数の定義
function gcd(bigintA: bigint, bigintB: bigint): bigint {
    while (bigintB !== 0n) {  // 0nはbigintの0を示す
        const temp = bigintB;
        bigintB = bigintA % bigintB;
        bigintA = temp;
    }
    return bigintA;
}

// 使用例
const num1: bigint = 123456789012345678901234567890n;
const num2: bigint = 98765432109876543210987654321n;
const result: bigint = gcd(num1, num2);

console.log(`2つの数${num1}と${num2}の最大公約数は${result}です。`);

このコードでは、ユークリッドの互除法を使用して2つのbigint値の最大公約数を計算する関数gcdを定義しています。

関数の中では、whileループを使用して繰り返し計算を行い、引数として与えられた2つのbigint値の最大公約数を返します。

実際に上記のコードを実行すると、2つの数123456789012345678901234567890と98765432109876543210987654321の最大公約数は1です。という結果が得られます。

○サンプルコード9：bigintを使った漸化式の計算

漸化式は、ある項が直前の項やそれ以前の項に基づいて計算される数列や関数の一つです。

例えば、フィボナッチ数列は漸化式で表される最も有名な数列の一つであり、これをbigintを使用してTypeScriptで計算することで、非常に大きなフィボナッチ数も正確に計算することができます。

TypeScriptのbigint型は、任意のサイズの整数をサポートしており、漸化式のように急激に値が大きくなる計算でもその魅力を発揮します。

通常の数値型ではオーバーフローが発生しやすいため、bigint型の使用はこのような場合に非常に有効です。

それでは、具体的なサンプルコードを見てみましょう。

// フィボナッチ数列を計算する関数
function fibonacci(n: bigint): bigint {
    if (n === 0n) return 0n;
    if (n === 1n) return 1n;

    let a = 0n;
    let b = 1n;

    for (let i = 2n; i <= n; i++) {
        let temp = a;
        a = b;
        b = temp + b;
    }

    return b;
}

// n = 100のときのフィボナッチ数を計算
const result = fibonacci(100n);
console.log(`100番目のフィボナッチ数は ${result} です。`);

このコードでは、フィボナッチ数列を計算する関数fibonacciを定義しています。

関数の中では、最初の2項（0番目と1番目）を特別扱いし、それ以降の項は直前の2項の合計として計算しています。

実行すると、100番目のフィボナッチ数が非常に大きな値で出力されることを確認できます。

もしbigintを使用しなければ、このような大きな値を正確に計算することは難しいでしょう。

続いて、上記のサンプルコードを実行した際の結果について説明します。

100番目のフィボナッチ数は非常に大きな値となります。

具体的には、約2.6 * 10^20の値となります。

このような大きな数値もbigint型を使用することで、正確に計算し、表示することが可能です。

通常の数値型ではオーバーフローが発生する可能性が高いため、このような計算にはbigint型が最適です。

○サンプルコード10：bigintとJSONの相互変換

TypeScriptのbigint型は、非常に大きな整数を扱うことができる強力な型です。

しかし、このbigint型をJSON形式でシリアライズしたり、逆にデシリアライズしたりする場合には注意が必要です。

JSON自体は、bigint型を直接サポートしていません。

従って、bigintをJSONに変換する場合や、その逆の操作を行う場合には、独自の変換処理が必要となります。

ここでは、bigintをJSON形式に変換し、その後、JSONからbigintに変換する方法をサンプルコードを交えて詳しく解説します。

□bigintからJSONへの変換

まず、bigintをJSONに変換する方法です。

このコードでは、bigintの値を文字列としてJSONに変換しています。

const bigintToJson = (bigintValue: bigint): string => {
    return JSON.stringify({ value: bigintValue.toString() });
}

const myBigInt = 1234567890123456789012345678901234567890n;
console.log(bigintToJson(myBigInt));

このコードを実行すると、次のようなJSON形式の文字列が得られます。

こちらの例では、bigintの値を”value”というキーの値として格納しています。

{
  "value": "1234567890123456789012345678901234567890"
}

□JSONからbigintへの変換

次に、上で得られたJSON形式の文字列から、再びbigintの値を取り出す方法を見ていきましょう。

このコードでは、JSON形式の文字列からオブジェクトを生成し、そのオブジェクトから文字列として保存されたbigintの値を取り出し、bigint型に変換しています。

const jsonToBigint = (jsonString: string): bigint => {
    const obj = JSON.parse(jsonString);
    return BigInt(obj.value);
}

const jsonString = '{"value":"1234567890123456789012345678901234567890"}';
const recoveredBigInt = jsonToBigint(jsonString);
console.log(recoveredBigInt);

このコードを実行すると、元のbigintの値、すなわち1234567890123456789012345678901234567890nが得られます。

○サンプルコード11：bigintを使ったモジュールの作成

TypeScriptの機能を最大限に活用すると、bigint型を使ったモジュールを作成することが可能です。

モジュールとは、再利用可能なコードのまとまりのことを指します。

これにより、bigintを用いた複雑な計算や関数を一元管理し、他のプロジェクトでも再利用することが可能となります。

では、具体的にどのようにモジュールを作成するのか、サンプルコードを用いて詳しく見ていきましょう。

// bigintCalc.ts
export function add(a: bigint, b: bigint): bigint {
    return a + b;
}

export function subtract(a: bigint, b: bigint): bigint {
    return a - b;
}

export function multiply(a: bigint, b: bigint): bigint {
    return a * b;
}

このコードでは、bigintCalc.tsというファイル名で3つの関数を定義しています。

それぞれ加算、減算、乗算の計算を行う関数です。

add関数：この関数は、2つのbigint値を引数として受け取り、それらを加算した結果を返します。
subtract関数：2つのbigint値を引数として受け取り、前者から後者を引いた結果を返します。
multiply関数：2つのbigint値を引数として受け取り、それらの乗算結果を返します。

これらの関数は、exportキーワードを使用して外部から利用可能にしています。

これにより、他のTypeScriptファイルからこのモジュールをインポートして関数を使用することができます。

次に、このモジュールを使用する側のコードを見てみましょう。

import { add, subtract, multiply } from './bigintCalc';

const num1: bigint = 1000n;
const num2: bigint = 2000n;

const result1 = add(num1, num2);
console.log(`加算結果：${result1}`);  // 加算結果：3000

const result2 = subtract(num1, num2);
console.log(`減算結果：${result2}`);  // 減算結果：-1000

const result3 = multiply(num1, num2);
console.log(`乗算結果：${result3}`);  // 乗算結果：2000000

こちらのコードでは、先ほど作成したbigintCalc.tsモジュールから3つの関数をインポートしています。

その後、それぞれの関数を使用して計算を行い、結果を表示しています。

これらのコードを実行すると次のような出力が得られます。

加算結果として3000、減算結果として-1000、そして乗算結果として2000000が表示されるでしょう。

これにより、bigint型の計算が正確に行われていることが確認できます。

○サンプルコード12：bigintでの非同期処理

JavaScriptやTypeScriptにおいて、非同期処理は主にPromiseやasync/awaitを使用して行います。

ここでは、TypeScriptのbigint型を用いて非同期処理を行う方法について解説します。

非同期処理を行うことで、重い計算を背景で行いつつ、メインのスレッドをブロックせずに他の処理を続行することができます。

この特性を利用して、bigint型での大量の計算を非同期に行う例を考えてみましょう。

非同期で大きな数字を2つ掛け合わせる処理を行うサンプルコードを紹介します。

const multiplyBigNumbers = async (a: bigint, b: bigint): Promise<bigint> => {
    return new Promise((resolve) => {
        setTimeout(() => {
            resolve(a * b);
        }, 1000);
    });
}

const main = async () => {
    const num1: bigint = 1234567890123456789012345678901234567890n;
    const num2: bigint = 9876543210987654321098765432109876543210n;
    const result: bigint = await multiplyBigNumbers(num1, num2);
    console.log(`結果: ${result}`);
}

main();

このコードでは、まず非同期関数multiplyBigNumbersを定義しています。

この関数内でsetTimeoutを用いることで、1秒後に2つのbigint型の数を掛け合わせる処理を行います。

そして、その結果をPromiseで返します。

main関数内で、非常に大きな2つの数字num1とnum2を定義し、先ほど定義した非同期関数multiplyBigNumbersを呼び出して計算を行います。

計算結果は変数resultに格納され、その後コンソールに出力されます。

このコードを実行すると、1219326311370217952261850327338369056877548454420nという出力がされます。

●bigint型の注意点と対処法

bigint型はTypeScriptで大きな整数を扱うためのデータ型です。しかし、このデータ型を使用する際にはいくつかの注意点があります。

ここでは、それらの注意点とその対処法を詳しく解説していきます。

○浮動小数点数との直接的な演算ができない

TypeScriptのbigint型は、基本的に他の数値型とは異なるので、bigintと通常の数字や浮動小数点数との直接的な算術演算はサポートされていません。

例えば、次のようなコードはエラーとなります。

let big: bigint = 123456789012345678901234567890n;
let floatNum: number = 123.456;

// エラー: bigintとnumberは直接演算できない
let result = big + floatNum;

このコードでは、bigint型の変数bigとnumber型の変数floatNumの加算を試みていますが、これは許されていません。

このような場合の対処法として、先に適切な型に変換してから演算を行う必要があります。

bigintへの変換方法は次のようになります。

let convertedBig: bigint = BigInt(floatNum);
let result = big + convertedBig;

ここで、BigInt関数を使用してnumber型の変数をbigint型に変換しています。

○ビット演算の挙動が異なる

bigint型は、ビット演算をサポートしていますが、number型とは異なる結果を返す場合があるので注意が必要です。

例として、次のコードを考えてみましょう。

let num1: number = -1;
let num2: bigint = -1n;

console.log(num1 >> 1);  // -1
console.log(num2 >> 1n); // -1n

このコードでは、number型の変数とbigint型の変数で右シフト演算を実行しています。

両方とも同じ結果を返すことが期待されますが、実際には異なる場合があるので注意が必要です。

○一部のライブラリやフレームワークでのサポートが限定的

bigint型は新しいデータ型であるため、古いライブラリやフレームワークではサポートが限定的である場合があります。

例えば、JSONのパースや文字列変換などの際に、bigint型が正しく扱われない場合があります。

これを避けるためには、適切なライブラリやツールを使用するか、bigint型を使用しない方法を選択する必要があります。

●bigintのカスタマイズ方法

JavaScriptやTypeScriptでの数値の取り扱いには限界があります。

特に大きな数値の取り扱いにおいて、通常のnumber型だけでは限界が出てきます。

そこで、bigint型が役立ちます。

しかし、bigint型をより使いやすく、また応用的に利用するためには、いくつかのカスタマイズ方法を知っておくことが有効です。

ここでは、TypeScriptにおけるbigintのカスタマイズ方法をいくつかのサンプルコードを交えて紹介します。

○関数を通じてのbigintの初期化

実務では、特定の条件下でbigintを生成する必要が出てくることがあります。

そのためのカスタマイズ方法として、関数を用いて初期化する方法を考えてみましょう。

// 文字列からbigintを生成する関数
function createBigIntFromString(s: string): bigint {
  // 文字列が数値かどうかチェック
  if (!/^-?\d+$/.test(s)) {
    throw new Error('無効な文字列です');
  }
  return BigInt(s);
}

// 使用例
const bigNumber = createBigIntFromString("123456789012345678901234567890");
console.log(bigNumber);  // 123456789012345678901234567890nと表示されます。

このコードでは、createBigIntFromString関数を使って文字列からbigintを生成しています。

関数内部では、文字列が数値の形式に適しているか確認してから、BigIntを使って変換しています。

このコードを実行すると、123456789012345678901234567890nという大きな数値がコンソールに表示されます。

○bigintを用いたカスタム計算

数値計算の際、特定の条件下で計算結果をカスタマイズすることがあります。

例えば、計算結果が一定の閾値を超えた場合、その値をリセットするといった処理を実現できます。

// bigintを受け取り、一定の閾値を超えたらリセットする関数
function resetIfExceedsThreshold(value: bigint, threshold: bigint): bigint {
  if (value > threshold) {
    return 0n;
  }
  return value;
}

// 使用例
const result = BigInt(10000) * BigInt(10000);
const adjustedResult = resetIfExceedsThreshold(result, 50000000n);
console.log(adjustedResult);  // 0nと表示されます

このコードでは、resetIfExceedsThreshold関数を通じて、計算結果が閾値50000000nを超えた場合、0nにリセットする処理を行っています。

このコードを実行すると、計算結果が閾値を超えているため、コンソールには0nと表示されます。