MENU
  1. ホーム
  2. JavaScript
  3. JavaScriptにおける整数演算と浮動小数点演算の違いを徹底解説

JavaScriptにおける整数演算と浮動小数点演算の違いを徹底解説

JavaScript

JavaScriptでの整数演算と浮動小数点演算の基本概念を理解することは、正確かつ効率的なプログラミングのために重要です。プログラム内で数値計算を行う際、整数と浮動小数点の違いを把握し、それぞれの特性に応じた適切な演算を行うことが求められます。本記事では、整数演算と浮動小数点演算の基本的な違い、具体的な使用例、精度や性能の違い、さらに実際のプロジェクトでの応用例について詳しく解説します。これにより、JavaScriptを用いた数値演算のスキルを向上させ、開発効率を高めることができます。

目次

整数演算とは

整数演算とは、整数（小数点を持たない数値）を対象とした算術演算のことを指します。これには、加算、減算、乗算、除算、および剰余演算（余りを求める演算）などが含まれます。

整数演算の特徴

整数演算には以下のような特徴があります：

  1. 精度の維持：整数演算では、小数点以下の値を扱わないため、精度の損失がありません。
  2. 効率の良さ：整数演算は、計算資源（CPU時間やメモリ）を比較的少なく消費するため、計算が高速です。
  3. データ型の制約：JavaScriptでは、整数演算に使われる数値も内部的には全て浮動小数点数（64ビットのIEEE 754規格）として扱われますが、ビット演算やMath.floor()などの関数を用いることで、整数としての特性を維持したまま計算を行うことが可能です。

整数演算の用途

整数演算は、以下のような場面でよく用いられます：

  1. カウンタの操作：ループ処理での繰り返し回数のカウントなど。
  2. インデックスの計算：配列やリストのインデックス操作。
  3. ビット演算：低レベルのデータ処理やハードウェア制御などで利用。

整数演算はプログラミングの基本的な操作の一つであり、その効率性と正確性から、多くのアルゴリズムやデータ処理の基礎となっています。

浮動小数点演算とは

浮動小数点演算とは、小数点を含む数値（浮動小数点数）を対象とした算術演算のことを指します。これには、加算、減算、乗算、除算などの基本的な演算に加え、指数、対数、三角関数などの高度な数学演算が含まれます。

浮動小数点演算の特徴

浮動小数点演算には以下のような特徴があります：

  1. 広範な数値範囲：浮動小数点数は非常に大きな数値や非常に小さな数値を表現できるため、科学技術計算などで広く使用されます。
  2. 精度の限界：浮動小数点数は有限のビット数で表現されるため、極めて細かい値や非常に大きな値の計算では精度の限界があります。これにより、丸め誤差が発生することがあります。
  3. 標準規格：浮動小数点数は一般にIEEE 754規格に基づいており、JavaScriptでもこの規格に従っています。

浮動小数点演算の用途

浮動小数点演算は、以下のような場面でよく用いられます：

  1. 科学技術計算：物理、化学、工学などの分野での計算に使用されます。
  2. 金融計算：通貨の計算などで高精度が求められる場合。
  3. グラフィックス：コンピュータグラフィックスでの座標計算や色の計算など。

浮動小数点演算は、数値計算の精度と範囲を広げるために不可欠な技術であり、多くのアプリケーションで使用されています。ただし、整数演算に比べて計算資源を多く消費し、丸め誤差の問題もあるため、使用する際にはこれらの点に注意が必要です。

整数と浮動小数点の違い

整数と浮動小数点の違いは、数値の表現方法と演算の特性にあります。これらの違いは、プログラミングにおいて数値をどのように扱うかに大きな影響を与えます。

数値の表現方法

  1. 整数：
  • 整数は、小数点を持たない数値で、全体が一つの数を表します。例として、1, -42, 1000などがあります。
  • JavaScriptでは、整数も浮動小数点数として内部的に扱われますが、ビット演算やMath.floor()を用いることで、整数としての特性を保つことができます。
  1. 浮動小数点数：
  • 浮動小数点数は、小数点を含む数値で、非常に大きな数や非常に小さな数を表現することができます。例として、3.14, -0.001, 2.5e6（2.5×10^6）などがあります。
  • JavaScriptでは、IEEE 754規格に基づく64ビットの浮動小数点数として扱われます。

演算の特性

  1. 精度：
  • 整数演算は、精度を失うことなく計算を行うことができます。整数同士の演算結果も常に整数になります。
  • 浮動小数点演算では、非常に大きな数や非常に小さな数を扱うことができますが、有限のビット数で表現されるため、丸め誤差が発生することがあります。
  1. 範囲：
  • 整数は、表現できる範囲が決まっており、その範囲を超えるとオーバーフローやアンダーフローが発生します。JavaScriptでは、整数の範囲は安全な整数（Number.MIN_SAFE_INTEGERからNumber.MAX_SAFE_INTEGERまで）に限定されます。
  • 浮動小数点数は、非常に広い範囲の数値を表現でき、科学技術計算などで使用されることが多いです。

使用例の違い

  1. 整数：
  • カウンタやループの制御、インデックスの操作など、正確な数値が必要な場面で使用されます。
  1. 浮動小数点数：
  • 科学技術計算、金融計算、グラフィックス計算など、精度が許容される範囲内で広範な数値を扱う場面で使用されます。

整数と浮動小数点数の特性を理解し、それぞれの用途に応じた適切な数値型を選択することが、効率的かつ正確なプログラミングの基本となります。

JavaScriptでの整数演算の例

JavaScriptでは、整数演算を行うために特別なデータ型は必要ありません。内部的には全ての数値が64ビットの浮動小数点数として扱われますが、整数演算も正確に行うことができます。ここでは、JavaScriptでの基本的な整数演算の例をいくつか紹介します。

基本的な整数演算

JavaScriptでは、基本的な算術演算子を使用して整数演算を行うことができます。以下にその例を示します：

let a = 10;
let b = 3;

// 加算
let sum = a + b; // 13

// 減算
let difference = a - b; // 7

// 乗算
let product = a * b; // 30

// 除算
let quotient = Math.floor(a / b); // 3

// 剰余（余り）
let remainder = a % b; // 1

console.log(`Sum: ${sum}`);
console.log(`Difference: ${difference}`);
console.log(`Product: ${product}`);
console.log(`Quotient: ${quotient}`);
console.log(`Remainder: ${remainder}`);

ビット演算

整数演算の一部として、JavaScriptではビット演算も行うことができます。ビット演算は、数値をビット単位で操作する方法であり、効率的な計算を行う際に役立ちます。以下にその例を示します：

let x = 5;  // 0101 in binary
let y = 3;  // 0011 in binary

// AND演算
let andResult = x & y; // 1 (0001 in binary)

// OR演算
let orResult = x | y; // 7 (0111 in binary)

// XOR演算
let xorResult = x ^ y; // 6 (0110 in binary)

// NOT演算
let notResult = ~x; // -6 (invert all bits of 0101, resulting in 1010 in two's complement form)

// 左シフト演算
let leftShiftResult = x << 1; // 10 (1010 in binary)

// 右シフト演算
let rightShiftResult = x >> 1; // 2 (0010 in binary)

console.log(`AND: ${andResult}`);
console.log(`OR: ${orResult}`);
console.log(`XOR: ${xorResult}`);
console.log(`NOT: ${notResult}`);
console.log(`Left Shift: ${leftShiftResult}`);
console.log(`Right Shift: ${rightShiftResult}`);

整数としての扱い

JavaScriptで整数として数値を扱う場合、Math.floor(), Math.ceil(), Math.round()などの関数を利用して浮動小数点数を整数に変換することができます。

let floatNum = 5.7;

// 切り捨て
let floored = Math.floor(floatNum); // 5

// 切り上げ
let ceiled = Math.ceil(floatNum); // 6

// 四捨五入
let rounded = Math.round(floatNum); // 6

console.log(`Floored: ${floored}`);
console.log(`Ceiled: ${ceiled}`);
console.log(`Rounded: ${rounded}`);

以上の例からわかるように、JavaScriptでは様々な方法で整数演算を行うことができます。これらの基本的な操作を理解することで、より複雑な数値処理も容易に行うことができるようになります。

JavaScriptでの浮動小数点演算の例

JavaScriptでは、浮動小数点数を使用してより複雑な数値演算を行うことができます。浮動小数点演算は、小数点を含む数値や非常に大きな数値、非常に小さな数値を扱う際に有効です。ここでは、JavaScriptでの基本的な浮動小数点演算の例をいくつか紹介します。

基本的な浮動小数点演算

JavaScriptでは、整数演算と同様に、基本的な算術演算子を使用して浮動小数点演算を行うことができます。以下にその例を示します：

let a = 5.5;
let b = 2.2;

// 加算
let sum = a + b; // 7.7

// 減算
let difference = a - b; // 3.3

// 乗算
let product = a * b; // 12.1

// 除算
let quotient = a / b; // 2.5

console.log(`Sum: ${sum}`);
console.log(`Difference: ${difference}`);
console.log(`Product: ${product}`);
console.log(`Quotient: ${quotient}`);

浮動小数点数の精度と丸め誤差

浮動小数点数は精度の限界があるため、演算結果に丸め誤差が生じることがあります。以下はその例です：

let x = 0.1;
let y = 0.2;

// 理論上は0.3になるはずですが、丸め誤差が発生します
let result = x + y; // 0.30000000000000004

console.log(`Result: ${result}`);

このような丸め誤差を回避するために、必要に応じて数値を丸める処理を行います：

let preciseResult = Math.round((x + y) * 100) / 100; // 0.3
console.log(`Precise Result: ${preciseResult}`);

浮動小数点数の特殊な演算

浮動小数点数を使用することで、より複雑な数学的演算も行うことができます。以下にいくつかの例を示します：

let num = 16;

// 平方根
let sqrt = Math.sqrt(num); // 4

// 累乗
let pow = Math.pow(num, 2); // 256

// 自然対数
let log = Math.log(num); // 2.772588722239781

// 三角関数
let angle = Math.PI / 4; // 45 degrees in radians
let sin = Math.sin(angle); // 0.7071067811865475
let cos = Math.cos(angle); // 0.7071067811865475
let tan = Math.tan(angle); // 1

console.log(`Square Root: ${sqrt}`);
console.log(`Power: ${pow}`);
console.log(`Logarithm: ${log}`);
console.log(`Sine: ${sin}`);
console.log(`Cosine: ${cos}`);
console.log(`Tangent: ${tan}`);

浮動小数点数の比較

浮動小数点数を比較する際には、丸め誤差を考慮する必要があります。以下にその例を示します：

let a = 0.1 + 0.2;
let b = 0.3;

// 直接比較は避ける
let isEqual = (a === b); // false

// 許容誤差を用いて比較する
let epsilon = Number.EPSILON;
let isApproximatelyEqual = Math.abs(a - b) < epsilon; // true

console.log(`Direct Comparison: ${isEqual}`);
console.log(`Approximate Comparison: ${isApproximatelyEqual}`);

以上の例からわかるように、JavaScriptでは浮動小数点演算を使って幅広い数値処理が可能です。これらの基本的な操作を理解することで、より高度な数値計算やアルゴリズムの実装が容易になります。

演算精度の違いとその影響

整数演算と浮動小数点演算の間には、精度の違いがあり、それぞれがプログラムに与える影響も異なります。このセクションでは、これらの違いとその影響について詳しく説明します。

整数演算の精度

整数演算は、小数点以下の値を持たないため、計算結果は常に正確です。整数演算で扱う数値は、JavaScriptでは通常安全な整数範囲内（Number.MIN_SAFE_INTEGERからNumber.MAX_SAFE_INTEGER）に制限されています。この範囲内であれば、演算結果に精度の問題は発生しません。

let a = 9007199254740991; // MAX_SAFE_INTEGER
let b = 1;
let sum = a + b; // 9007199254740992, still accurate within safe range
console.log(sum);

浮動小数点演算の精度

浮動小数点演算は、非常に大きな数値や非常に小さな数値を扱うことができる一方で、丸め誤差が発生することがあります。これは、浮動小数点数が有限のビット数で表現されるためです。このため、計算結果に微小な誤差が含まれることがあります。

let x = 0.1;
let y = 0.2;
let result = x + y; // 0.30000000000000004
console.log(result);

精度の違いが与える影響

  1. 計算結果の信頼性：
  • 整数演算では、計算結果が常に正確であるため、信頼性が高いです。
  • 浮動小数点演算では、丸め誤差が発生するため、特に累積計算や連続した計算において、結果の信頼性が低下することがあります。
  1. 計算の適用範囲：
  • 整数演算は、カウンタやインデックス計算など、正確な値が必要な場面で適用されます。
  • 浮動小数点演算は、科学技術計算、金融計算、グラフィックス計算など、広範な数値を扱う必要がある場面で適用されます。
  1. パフォーマンス：
  • 整数演算は、浮動小数点演算よりも一般的に計算が高速であり、リソース消費も少ないです。
  • 浮動小数点演算は、計算がやや重くなる傾向がありますが、現在のプロセッサは浮動小数点演算を効率的に処理する機能を持っています。

丸め誤差の影響とその対策

浮動小数点演算では、丸め誤差を最小限に抑えるための対策が必要です。以下にその例を示します：

let a = 0.1;
let b = 0.2;
let result = a + b;

// 直接比較ではなく、許容誤差を用いた比較を行う
let epsilon = Number.EPSILON;
let isApproximatelyEqual = Math.abs(result - 0.3) < epsilon; // true

console.log(`Result: ${result}`);
console.log(`Is Approximately Equal: ${isApproximatelyEqual}`);

このように、浮動小数点演算においては許容誤差を考慮した計算や比較を行うことで、精度の違いが与える影響を軽減することができます。整数演算と浮動小数点演算の特性を理解し、適切な方法で数値計算を行うことが、正確で効率的なプログラミングの鍵となります。

四捨五入や丸め誤差の処理

四捨五入や丸め誤差の処理は、浮動小数点演算を扱う際に非常に重要です。JavaScriptでは、これらの処理を行うための組み込み関数がいくつか提供されています。ここでは、四捨五入や丸め誤差の処理方法について詳しく解説します。

四捨五入の方法

JavaScriptでは、四捨五入を行うためにMath.round()関数を使用します。この関数は、数値を最も近い整数に四捨五入します。

let num = 4.6;
let rounded = Math.round(num); // 5
console.log(`Rounded: ${rounded}`);

また、特定の小数点以下の桁数に四捨五入する場合には、以下のようなカスタム関数を使用します：

function roundTo(num, decimalPlaces) {
  let factor = Math.pow(10, decimalPlaces);
  return Math.round(num * factor) / factor;
}

let value = 3.14159;
let roundedValue = roundTo(value, 2); // 3.14
console.log(`Rounded to 2 decimal places: ${roundedValue}`);

切り上げと切り捨ての方法

JavaScriptでは、切り上げと切り捨てのためにそれぞれMath.ceil()とMath.floor()関数を使用します。

let num = 4.2;
let ceiled = Math.ceil(num); // 5
let floored = Math.floor(num); // 4
console.log(`Ceiled: ${ceiled}`);
console.log(`Floored: ${floored}`);

丸め誤差の処理

浮動小数点演算では、丸め誤差が発生することがあります。この問題を軽減するために、数値を整数に変換してから計算を行う方法があります。例えば、通貨の計算などで使用されます。

let x = 0.1;
let y = 0.2;
let result = x + y; // 0.30000000000000004

// 丸め誤差を処理するために数値を整数に変換
let preciseResult = Math.round((x + y) * 100) / 100; // 0.3
console.log(`Result with rounding: ${preciseResult}`);

浮動小数点数の比較

浮動小数点数を比較する際には、直接比較するのではなく、許容誤差（イプシロン）を用いた比較を行うことが推奨されます。

let a = 0.1;
let b = 0.2;
let result = a + b;

let epsilon = Number.EPSILON;
let isApproximatelyEqual = Math.abs(result - 0.3) < epsilon; // true

console.log(`Result: ${result}`);
console.log(`Is Approximately Equal: ${isApproximatelyEqual}`);

このように、四捨五入や丸め誤差の処理を適切に行うことで、浮動小数点演算の精度を向上させることができます。これにより、計算結果の信頼性が高まり、プログラムの品質が向上します。

性能とメモリ使用量の比較

整数演算と浮動小数点演算は、それぞれ異なる性能特性とメモリ使用量を持ちます。このセクションでは、これらの違いについて詳しく説明し、それがプログラムの実行にどのように影響するかを見ていきます。

整数演算の性能

整数演算は一般的に浮動小数点演算よりも高速です。これは、整数演算が単純なビット操作に基づいており、CPUがそれを効率的に処理できるためです。以下の例は、整数の加算と乗算の性能を示しています。

console.time('Integer Addition');
let sum = 0;
for (let i = 0; i < 1000000; i++) {
  sum += i;
}
console.timeEnd('Integer Addition');

console.time('Integer Multiplication');
let product = 1;
for (let i = 1; i < 10000; i++) {
  product *= i;
}
console.timeEnd('Integer Multiplication');

浮動小数点演算の性能

浮動小数点演算は、整数演算よりも複雑で、CPUリソースを多く消費します。しかし、現代のCPUは浮動小数点演算を効率的に処理するための専用ハードウェアを持っているため、多くの場合、パフォーマンスは十分に高いです。

console.time('Float Addition');
let floatSum = 0;
for (let i = 0; i < 1000000; i++) {
  floatSum += 0.1;
}
console.timeEnd('Float Addition');

console.time('Float Multiplication');
let floatProduct = 1;
for (let i = 1; i < 10000; i++) {
  floatProduct *= 1.0001;
}
console.timeEnd('Float Multiplication');

メモリ使用量の比較

メモリ使用量については、JavaScriptでは全ての数値が64ビットの浮動小数点数（IEEE 754規格）として扱われるため、整数演算でも浮動小数点演算でもメモリ使用量に大きな差はありません。しかし、特定のアルゴリズムやデータ構造に依存する場合、メモリ使用量が異なることがあります。

メモリ使用量の例

let intArray = new Array(1000000).fill(1); // 整数の配列
let floatArray = new Array(1000000).fill(1.1); // 浮動小数点数の配列

console.log(`Integer Array Size: ${intArray.length}`);
console.log(`Float Array Size: ${floatArray.length}`);

使用場面による選択

  1. 整数演算：
  • 繰り返し処理やループカウンタ、インデックス計算など、高速かつ正確な計算が求められる場面で適用されます。
  1. 浮動小数点演算：
  • 科学技術計算、金融計算、グラフィックス計算など、広範な数値を扱う必要がある場面で適用されます。

整数演算と浮動小数点演算の性能とメモリ使用量の違いを理解し、適切な場面でこれらを選択することが、効率的なプログラム作成の鍵となります。

演算エラーのトラブルシューティング

整数演算や浮動小数点演算において、さまざまな演算エラーが発生することがあります。これらのエラーは、適切に対処しないとプログラムの動作に影響を与える可能性があります。このセクションでは、一般的な演算エラーとその対処法について説明します。

整数演算でのエラー

整数演算において、主に発生するエラーは以下の通りです。

オーバーフローとアンダーフロー

整数オーバーフローは、演算結果が整数の最大値を超えた場合に発生し、アンダーフローは最小値を下回った場合に発生します。JavaScriptでは、これらのエラーはサイレントに発生し、結果が予期せぬ値になることがあります。

let maxInt = Number.MAX_SAFE_INTEGER;
let overflowResult = maxInt + 1;
console.log(`Overflow Result: ${overflowResult}`);

let minInt = Number.MIN_SAFE_INTEGER;
let underflowResult = minInt - 1;
console.log(`Underflow Result: ${underflowResult}`);

対処法

オーバーフローやアンダーフローを回避するためには、演算前に数値が範囲内に収まるかを確認することが重要です。

function safeAdd(a, b) {
  if (a > Number.MAX_SAFE_INTEGER - b) {
    throw new Error("Integer overflow");
  }
  return a + b;
}

try {
  let result = safeAdd(Number.MAX_SAFE_INTEGER, 1);
} catch (e) {
  console.error(e.message); // Integer overflow
}

浮動小数点演算でのエラー

浮動小数点演算において、主に発生するエラーは以下の通りです。

丸め誤差

浮動小数点数の精度の限界により、計算結果に微小な誤差が生じることがあります。これは、特に累積計算や連続した計算において顕著です。

let a = 0.1;
let b = 0.2;
let result = a + b; // 0.30000000000000004
console.log(`Result with rounding error: ${result}`);

対処法

丸め誤差を軽減するためには、計算結果を適切に丸めることが重要です。特定の小数点以下の桁数で丸める関数を利用することで、誤差を最小限に抑えます。

function roundToPrecision(num, precision) {
  let factor = Math.pow(10, precision);
  return Math.round(num * factor) / factor;
}

let preciseResult = roundToPrecision(a + b, 2); // 0.3
console.log(`Precise Result: ${preciseResult}`);

非数（NaN）エラー

浮動小数点演算では、計算結果が非数（NaN）となる場合があります。これは、無効な演算が行われたときに発生します。

let invalidOperation = 0 / 0;
console.log(`Invalid Operation Result: ${invalidOperation}`); // NaN

対処法

NaNが発生する可能性のある演算を行う場合は、結果がNaNかどうかをチェックすることが重要です。

let value = 0 / 0;
if (isNaN(value)) {
  console.error("Invalid result: NaN");
}

Infinityと-Infinity

浮動小数点演算で、非常に大きな数値や非常に小さな数値を扱うと、Infinityや-Infinityが発生することがあります。

let largeNumber = 1e308;
let infinityResult = largeNumber * 2;
console.log(`Infinity Result: ${infinityResult}`); // Infinity

対処法

Infinityや-Infinityを回避するためには、演算前に数値が安全な範囲内に収まるかを確認することが重要です。

function safeMultiply(a, b) {
  if (!isFinite(a * b)) {
    throw new Error("Result is Infinity");
  }
  return a * b;
}

try {
  let result = safeMultiply(1e308, 2);
} catch (e) {
  console.error(e.message); // Result is Infinity
}

これらの対処法を用いることで、整数演算および浮動小数点演算における一般的なエラーを防ぐことができます。適切なエラーハンドリングを行うことで、プログラムの信頼性と安定性を向上させることができます。

応用例と演習問題

整数演算と浮動小数点演算の基本を理解したところで、実際のプロジェクトでの応用例と理解を深めるための演習問題を紹介します。これにより、学んだ知識を実践的に活用できるようになります。

応用例：支払い計算システム

この応用例では、整数演算と浮動小数点演算を組み合わせた簡単な支払い計算システムを作成します。商品の価格は浮動小数点数で表現され、数量は整数で表現されます。

// 商品データ
let items = [
  { name: "Apple", price: 0.99, quantity: 3 },
  { name: "Banana", price: 0.79, quantity: 5 },
  { name: "Orange", price: 1.25, quantity: 2 }
];

// 合計金額を計算
function calculateTotal(items) {
  let total = 0;
  for (let item of items) {
    total += item.price * item.quantity;
  }
  return roundToPrecision(total, 2);
}

// 小数点以下2桁に丸める関数
function roundToPrecision(num, precision) {
  let factor = Math.pow(10, precision);
  return Math.round(num * factor) / factor;
}

let totalAmount = calculateTotal(items);
console.log(`Total Amount: $${totalAmount}`); // Total Amount: $8.45

応用例：座標変換

コンピュータグラフィックスやゲーム開発において、座標変換はよく使われる操作です。ここでは、2D座標の回転を浮動小数点演算で行います。

function rotatePoint(x, y, angle) {
  let radians = angle * (Math.PI / 180);
  let cos = Math.cos(radians);
  let sin = Math.sin(radians);

  let newX = x * cos - y * sin;
  let newY = x * sin + y * cos;

  return { x: roundToPrecision(newX, 2), y: roundToPrecision(newY, 2) };
}

let point = { x: 1, y: 0 };
let angle = 90;
let rotatedPoint = rotatePoint(point.x, point.y, angle);
console.log(`Rotated Point: (${rotatedPoint.x}, ${rotatedPoint.y})`); // Rotated Point: (0, 1)

演習問題

以下の演習問題に挑戦して、整数演算と浮動小数点演算の理解を深めてください。

問題1: 合計値と平均値の計算

整数の配列が与えられたとき、合計値と平均値を計算する関数を作成してください。平均値は小数点以下2桁に丸めてください。

function calculateSumAndAverage(numbers) {
  let sum = numbers.reduce((acc, num) => acc + num, 0);
  let average = roundToPrecision(sum / numbers.length, 2);
  return { sum, average };
}

let numbers = [1, 2, 3, 4, 5];
let result = calculateSumAndAverage(numbers);
console.log(`Sum: ${result.sum}, Average: ${result.average}`); // Sum: 15, Average: 3.00

問題2: 商品のディスカウント計算

商品価格と割引率が与えられたとき、割引後の価格を計算する関数を作成してください。割引後の価格は小数点以下2桁に丸めてください。

function calculateDiscountedPrice(price, discountRate) {
  let discount = price * (discountRate / 100);
  let discountedPrice = price - discount;
  return roundToPrecision(discountedPrice, 2);
}

let price = 50;
let discountRate = 10;
let discountedPrice = calculateDiscountedPrice(price, discountRate);
console.log(`Discounted Price: $${discountedPrice}`); // Discounted Price: $45.00

問題3: 矩形の面積と周囲長の計算

矩形の幅と高さが与えられたとき、その面積と周囲長を計算する関数を作成してください。結果は整数で返してください。

function calculateAreaAndPerimeter(width, height) {
  let area = width * height;
  let perimeter = 2 * (width + height);
  return { area, perimeter };
}

let width = 5;
let height = 10;
let rectangle = calculateAreaAndPerimeter(width, height);
console.log(`Area: ${rectangle.area}, Perimeter: ${rectangle.perimeter}`); // Area: 50, Perimeter: 30

これらの応用例と演習問題を通じて、整数演算と浮動小数点演算の実践的な使用方法を理解し、プログラミングスキルを向上させることができます。

まとめ

本記事では、JavaScriptにおける整数演算と浮動小数点演算の違いについて詳しく解説しました。整数演算は精度が高く高速である一方、浮動小数点演算は広範な数値範囲を扱うことができますが、丸め誤差に注意が必要です。演算エラーのトラブルシューティングや、四捨五入、切り上げ、切り捨ての方法についても説明しました。さらに、支払い計算システムや座標変換などの実践的な応用例と、理解を深めるための演習問題を紹介しました。

これらの知識を活用することで、JavaScriptでの数値演算を効率的かつ正確に行うことができ、プログラムの品質を向上させることができます。整数演算と浮動小数点演算の特性を理解し、適切に使い分けることで、より複雑な数値計算も確実にこなせるようになるでしょう。

JavaScript
JavaScript 整数演算 浮動小数点演算

コメント

コメントする

目次