JavaScriptでの数学

はじめに

数値と数値データを使用すると、どのような方法でも言語を操作できます。 ただし、JavaScriptで算術演算子を使用するほかに、数学的な構成は初心者にとっては困難な作業になる場合があります。 このため、構文ではなく、一般的な数学関数に集中する必要があります。このリストは、並べ替え、丸め、ランダム値の生成などから始まります。詳細を説明する前にこれで十分です。 JavaScriptで数学を操作するために知っておくべきことは、関数、オペランド、演算子などのことだけです。

翻訳者から

みなさんこんにちは、 マキシム・イワノフとドミトリー・セルギエンコフはあなたと一緒です。そして今日、ReactJS、Angular、TypeScriptなどのファッショナブルで有用なものについて話さないことにしました。 今日はJavaScriptでの数学に焦点を当てます。 数学が好きなら、あなたは自由にそれをすることができますが、あなたの目標が科学的研究ではなく、プログラマとして働くなら、 数学は勉強するのに最適なオブジェクトではないでしょう 。

1. 乱数を扱う
   
   
   
   
   • メインケース
   • 間隔内の乱数[最小、最大）
   • 間隔内の乱数[最小、最大]
   • ブール確率変数（true / false）
   • 例外を伴うランダム値
   • 繰り返しのないランダムな値
   • 暗号化ランダム変数
   
   
   
2. 丸め
   
   
   
   
   • 丸めが必要な理由
   • 小数の丸め
   • 10進数の丸めエラーの回避
   • 機械イプシロン丸め
   • フラクショナルクリッピング
   • 最も近い数への丸め
   • 最も近い整数に切り捨てます
   • 最も近い整数に切り上げます
   • 必要なより大きい/小さい数への丸め
   • 範囲内の数値を修正する
   • ガウス丸め
   
   
   
3. 仕分け
   
   
   
   
   • アルファベット順の並べ替え
   • 数値ソート
   • JSONのような構造を並べ替える
   
   
   
4. べき関数を使用する
   
   
   
   
   • べき乗
   • 平方根および立方根
   
   
   
5. 数学定数
   
   
   
   
   • Math.pi
   • Math.SQRT2
   • Math.SQRT1_2
   • Math.e
   • Math.ln2
   • Math.ln10
   • Math.LOG2E
   • Math.LOG10E
   
   
   
6. Math.abs、parseInt、parseFloat
   
   
   
   
   • Math.abs（）
   • parseInt（）
   • parseFloat（）
   
   
   

乱数を扱う

JavaScriptでは、 夜空に散らばる星を描くなど、乱数が必要になることがよくあります。 ただし、事故にはさまざまな種類があり、アプリケーションのロジックとニーズに応じて、いずれかが必要になる場合があります。

メインケース

ランダム性の最も単純な形式は、JavaScriptに組み込まれているMath.random（）関数です。

> Math.random() 0.19401081069372594
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Math.random（）は常に0〜1の浮動小数点数を返します。技術的な観点から、Math.random（）が返す数値は0になりますが、1になることはありません。



Math.random（）を頻繁に使用する場合は、スクリプトで独自の関数を使用します。

 function getRandom() { return Math.random(); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

もちろん、問題は、この関数が常に非常に限られた範囲内で乱数を作成することです。そして、この問題を解決するために設計されたいくつかの推奨事項を検討しようとします。

間隔内の乱数[最小、最大）

この機能を拡張するには、少しの計算が必要です。



ランダム浮動小数点数：

 function getRandomFloat(min, max) { return Math.random() * (max - min) + min; } getRandomFloat(11, 101) > 75.31898734299466
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

整数の乱数：

 function getRandomInt(min, max) { return Math.floor(Math.random() * (max - min)) + min; } getRandomInt(10, 20) > 12
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

間隔内の乱数[最小、最大]

 function getRandomInRange(min, max) { return Math.floor(Math.random() * (max - min + 1)) + min; } getRandomInRange(1, 10) > 7
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ブール確率変数（true / false）

コイントスを表す0または1の単純なランダム性が必要な場合：

 function coinToss() { return Math.floor(Math.random() * 2); } coinToss(); > 0
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

trueまたはfalseを取得する必要がある場合：

 function coinToss() { return (Math.floor(Math.random() * 2) === 0); } coinToss(); > true
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

またはそれ以外：

 function coinToss() { return Math.random()<.5; } coinToss(); > true
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

特定の単語をコインの側面に関連付けたい場合（はい/いいえ、上部/下部など）：

 function coinFlip() { return (Math.floor(Math.random() * 2) === 0) ? "up" : "down"; } coinFlip(); > up
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

例外を伴うランダム値

整数の範囲が限られている場合、抽出したい数値の配列を作成し、この配列からランダムに選択する必要があります。

 let numPool = [ 1, 3, 5, 7, 9, 10 ], rand = numPool[Math.floor(Math.random() * numPool.length)];
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

除外する数値の配列を使用して、最初の配列から2番目の配列へのフィルタリング結果を含む空の配列を準備することもできます。

 let numPool = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]; let excludePool = [ 3, 4 ]; let filteredPool = [];
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

次に、ループ内でnumPool配列を実行します。ドロップされた番号が存在し、excludePool配列にある場合、filteredPoolに結果を入れます。

 for (let i = 0; i < numPool.length; i++) { if (excludePool.indexOf(numPool[i]) === -1) { filteredPool.push(numPool[i]); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

最後に、filteredPool配列から乱数を取得します。

 let rand = filteredPool[Math.floor(Math.random() * filteredPool.length)];
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

繰り返しのないランダムな値

数の小さなセットの場合、要素で満たされた配列を作成し、それらをランダムにシャッフルし、結果を新しい配列に入れてから、それを1つずつ引き出す必要があります。

 let numPool = [ 13, 21, 36, 14, 27, 10 ]; function shuffle(numPool) { for( let j, x, i = numPool.length; i; j = parseInt(Math.random() * i), x = numPool[--i], numPool[i] = numPool[j], numPool[j] = x ); return numPool; }; let randomResult = shuffle(numPool); while( randomResult.length > 0 ) { console.log( randomResult.pop() ); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

より広い範囲の数値を取得するには、配列を作成し、以前に生成されたものを除く乱数を入力します。

 let numReserve = [] while (numReserve.length < 12) { let randomNumber = Math.ceil(Math.random() * 1000); let found = false; for (let i = 0; i < numReserve.length; i++) { if (numReserve[i] === randomNumber){ found = true; break; } } if (!found) { numReserve[numReserve.length]=randomNumber; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

上記のコードでは、numReserveに0から1000までの12個の乱数が入力されています。

暗号化ランダム変数

残念ながら、上記のメソッドはどれも、暗号で保護された関数に十分なランダム性を持つ数値を作成しません（Math.random（）は、乱数を生成するのに十分な関数ではありません）。 したがって、typedArrayを作成することでWeb Cryptography APIを使用できます。

 let cryptoStor = new Uint16Array(8);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この場合、8つの異なるスロットを持つ配列を作成します。各スロットには符号なし16ビット整数が含まれます。 Int8Array、Uint8Array、int16Array、Int32Array、およびUint32Arrayには他のオプションがあります。



次に、特定のタイプの乱数で配列を埋める必要があります。

 window.crypto.getRandomValues(cryptoStor); > [43484, 57947, 46691, 49849, 24272, 11827, 28203, 17423]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

さらに、Web Cryptography APIは最新のブラウザーで良好にサポートされています 。

読書へ：

1. ランダムプライム

2. 特定の範囲でJavaScriptでランダムな整数を生成する

3. 暗号化の概要

4. 暗号的に堅牢な擬似乱数ジェネレーター

5. 擬似乱数ジェネレーター

丸め

非常に多くの場合、JavaScriptの計算では必要な結果が得られません。 もちろん、数字を使って何でもできます-切り上げ、切り捨て、範囲の設定、不必要な数字を特定の小数点以下の桁数に切り捨てます。すべては将来この数字で何をしたいかによって異なります。

丸めが必要な理由

JavaScriptの興味深い側面の1つは、実際に整数を格納しないことです。浮動小数点数をすぐに使用します。 これは、多くの小数値が有限の小数点以下の桁数で表現できないという事実と相まって、JavaScriptでは次の結果を得ることができます。

 0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

実際の目的のために、この不正確さは重要ではありません。私たちの場合、私たちは五分の一分の一のエラーについて話しているが、誰かを失望させるかもしれません。 数値、つまり通貨、パーセンテージ、またはファイルサイズの値を操作すると、やや奇妙な結果が得られる場合があります。 これらの不正確さを修正するには、結果を丸めることができれば十分であり、小数の精度を設定するだけで十分です。



数値の丸めには実際的な用途があります。たとえば、特定の範囲の数値を操作できます。たとえば、値を最も近い整数に丸めて、小数部分だけを処理することはできません。

小数の丸め

10進数をトリムするには、 toFixedメソッドまたはtoPrecisionメソッドを使用します。 どちらも単一の引数を取り、それぞれが結果を含む有効桁数（つまり、数値で使用される総桁数）または小数点以下の桁数（小数点以下の数値）を決定します。

1. 引数がtoFixed（）に定義されていない場合、デフォルトではゼロになります。つまり、小数点以下の桁数は0で、引数の最大値は20です。
2. toPrecisionに引数が指定されていない場合、数値は変更されません。

 let randNum = 6.25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" randNum = 87.335; randNum.toFixed(2); > "87.33" randNum = 87.337; randNum.toPrecision(3); > "87.3"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

toFixed（）とtoPrecision（）の両方のメソッドは、数値ではなく結果の文字列表現を返します。 つまり、丸められた値をrandNumで合計すると、数字の合計ではなく、文字列が連結されます。

 let randNum = 6.25; let rounded = randNum.toFixed(); // "6" console.log(randNum + rounded); > "6.256"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

結果を数値データ型にする場合は、parseFloatを適用する必要があります。

 let randNum = 6.25; let rounded = parseFloat(randNum.toFixed(1)); console.log(rounded); > 6.3
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

まれな場合を除いて、値5は丸められることに注意してください。



toFixed（）およびtoPrecision（）メソッドは、小数部分を切り捨てるだけでなく、小数点以下の桁を補うことができるので便利です。これは、通貨を扱う場合に便利です。

 let wholeNum = 1 let dollarsCents = wholeNum.toFixed(2); console.log(dollarsCents); > "1.00"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

整数の数が精度自体よりも大きい場合、toPrecisionは指数表記を生成することに注意してください。

 let num = 123.435 num.toPrecision(2); > "1.2e+2"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

10進数の丸めエラーの回避

場合によっては、toFixedとtoPrecisionは値5を切り上げて切り上げます：

 let numTest = 1.005; numTest.toFixed(2); > "1.00"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

上記の計算の結果は1ではなく1.01になっているはずです。同様のエラーを回避する場合は、指数を使用して計算するJack L Mooreが提案するソリューションを使用できます。

 function round(value, decimals) { return Number(Math.round(value+'e'+decimals)+'e-'+decimals); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

今：

 round(1.005,2); > 1.01
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

上記のソリューションよりも堅牢なソリューションが必要な場合は、 MDNにアップグレードできます。

機械イプシロン丸め

10進数を丸める別の方法がES6で導入されました。 マシンイプシロンの丸めは、2つの浮動小数点数を比較する際に妥当な誤差を提供します。 丸めを行わないと、比較により次のような結果が生成される場合があります。

 0.1 + 0.2 === 0.3 > false
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

関数でMath.EPSILONを使用して、正しい比較を取得します。

 function epsEqu(x, y) { return Math.abs(x - y) < Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この関数は2つの引数を取ります。1つ目は現在の計算、2つ目は予想される結果です。 2つの比較を返します。

 epsEqu(0.1 + 0.2, 0.3) > true
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

最新のブラウザーはすべてES6数学関数を既にサポートしていますが、IE 11のようなブラウザーでサポートが必要な場合はpolyfillsを使用してください 。

フラクショナルクリッピング

上記のすべてのメソッドは、10進数に丸めることができます。 数値を小数点以下2桁に切り捨てるには、最初に100を掛けてから、結果を100で除算する必要があります。

 function truncated(num) { return Math.trunc(num * 100) / 100; } truncated(3.1416) > 3.14
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

メソッドを小数点以下の桁数に合わせたい場合は、 二重ビット単位の否定を使用できます。

 function truncated(num, decimalPlaces) { let numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

今：

 let randInt = 35.874993; truncated(randInt,3); > 35.874
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

最も近い数への丸め

最も近いものに応じて、10進数を最も近い数値に切り上げまたは切り捨てるには、Math.round（）を使用します。

 Math.round(4.3) > 4 Math.round(4.5) > 5
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

「値の半分」である0.5は、数学の規則に従って切り上げられることに注意してください。

最も近い整数に切り捨てます

常に切り捨てる場合は、Math.floorを使用します。

 Math.floor(42.23); > 42 Math.floor(36.93); > 36
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

切り捨ては、負の数値を含むすべての数値に対して機能することに注意してください。 低層階（負の数を表す）を含む、無限の階数を持つ超高層ビルを想像してください。 2〜3の下位レベル（値は-2.5）のエレベーターにいる場合、Math.floorは-3に移動します。

 Math.floor(-2.5); > -3
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ただし、この状況を回避したい場合は、最新のすべてのブラウザー（IE / Edgeを除く）でサポートされているMath.truncを使用してください 。

 Math.trunc(-41.43); > -41
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

MDNでは、ブラウザとIE / EdgeでMath.truncサポートを提供するポリフィルがあります。

最も近い整数に切り上げます

一方、常に切り上げる必要がある場合は、Math.ceilを使用します。 繰り返しますが、無限のリフトを思い出してください。Math.ceilは、数値が負であるかどうかに関係なく、常に「上」になります。

 Math.ceil(42.23); > 43 Math.ceil(36.93); > 37 Math.ceil(-36.93); > -36
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

大きい/小さい数に丸める必要があります

最も近い5の倍数に丸める場合、最も簡単な方法は、数値を5で除算して丸め、次に同じ量で乗算する関数を作成することです。

 function roundTo5(num) { return Math.round(num/5)*5; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

今：

 roundTo5(11); > 10
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

値の倍数に丸めたい場合、より一般的な関数を使用して、初期値と倍数を渡します：

 function roundToMultiple(num, multiple) { return Math.round(num/multiple)*multiple; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

今：

 let initialNumber = 11; let multiple = 10; roundToMultiple(initialNumber, multiple); > 10;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

範囲内の数値を修正する

範囲内にあるx値を取得したい場合が多くあります。 たとえば、1から100までの値が必要な場合がありますが、値は123になります。これを修正するために、最小値（数値セットの最小値を返す）と最大値（数値セットの最大値を返す）を使用できます。 この例では、範囲は1〜100です。

 let lowBound = 1; let highBound = 100; let numInput = 123; let clamped = Math.max(lowBound, Math.min(numInput, highBound)); console.log(clamped); > 100;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

繰り返しになりますが、操作を再利用し、すべてを関数にラップすることができます。DanielX . Mooreによって提案されたソリューションを使用します。

 Number.prototype.clamp = function(min, max) { return Math.min(Math.max(this, min), max); };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

今：

 numInput.clamp(lowBound, highBound); > 100;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ガウス丸め

銀行の丸めとも呼ばれるガウス丸めは、この場合の丸めが最も近い偶数に発生することです。 この丸め方法は統計エラーなしで機能します。 最適な解決策はTim Downによって提案されました：

 function gaussRound(num, decimalPlaces) { let d = decimalPlaces || 0, m = Math.pow(10, d), n = +(d ? num * m : num).toFixed(8), i = Math.floor(n), f = n - i, e = 1e-8, r = (f > 0.5 - e && f < 0.5 + e) ? ((i % 2 == 0) ? i : i + 1) : Math.round(n); return d ? r / m : r; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

今：

 gaussRound(2.5) > 2 gaussRound(3.5) > 4 gaussRound(2.57,1) > 2.6
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

CSS 10進数：



JavaScriptはHTML要素の位置変換を作成するためによく使用されるため、要素の小数値を生成するとどうなるか疑問に思うかもしれません。

 #box { width: 63.667731993px; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

幸いなことに、最新のブラウザでは、ブロックモデルでパーセンテージやピクセル単位などの小数値が考慮されます。

読書へ：

1. 浮動小数点を扱う際にすべての科学者が算術について知っておくべきこと

2. 任意精度の10進算術で動作する高速JavaScriptライブラリ

3. JavaScriptのDecimal任意精度の拡張タイプ

4. 10進数および任意の算術のための任意精度のJavaScriptライブラリ

5. すべてのJavaScript開発者が浮動小数点について知っておくべきこと

6. JSでこのような浮動小数点の問題があるのはなぜですか？

仕分け

多くの場合、いくつかの要素を並べ替える必要があります。たとえば、ゲームレコードの配列があり、それらはプレーヤーの降順に整理する必要があります。 残念ながら、標準のsort（）メソッドにはいくつかの驚くべき制限があります。一般的に使用される英語の単語ではうまく機能しますが、数字、一意の文字、または大文字の単語に遭遇するとすぐに壊れます。

アルファベット順の並べ替え

配列をアルファベット順にソートするのが最も簡単なタスクであるように思われます。

 let fruit = ["butternut squash", "apricot", "cantaloupe"]; fruit.sort(); > "apricot", "butternut squash", "cantaloupe"]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ただし、要素の1つが大文字になるとすぐに問題が発生します。

 let fruit = ["butternut squash", "apricot", "Cantalope"]; fruit.sort(); > "Cantaloupe", "apricot", "butternut squash"]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これは、デフォルトで、ソーターがUnicodeで表される最初の文字を比較するという事実によるものです。 Unicodeは、プラットフォームに関係なく、プログラムに関係なく、言語に関係なく、あらゆる文字に固有のコードです。 たとえば、コードテーブルを見ると、文字「a」の値はU + 0061（16進法0x61 ）であり、文字「C」のコードはU + 0043（0x43）です。 「A」。



大文字と小文字が混在する配列を並べ替えるには、すべての要素を一時的に小文字に変換するか、いくつかの引数を指定してlocaleCompare（）メソッドを使用して並べ替え順序を決定する必要があります。 原則として、このような場合、すぐに再利用する関数を作成することをお勧めします。

 function alphaSort(arr) { arr.sort(function (a, b) { return a.localeCompare(b, 'en', {'sensitivity': 'base'}); }); } let fruit = ["butternut squash", "apricot", "Cantaloupe"]; alphaSort(fruit) > ["apricot", "butternut squash", "Cantaloupe"]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

逆のアルファベット順にソートされた配列を取得したい場合は、関数の位置aとbを入れ替えるだけです：

 function alphaSort(arr) { arr.sort(function (a, b) { return b.localeCompare(a, 'en', {'sensitivity': 'base'}); }); } let fruit = ["butternut squash", "apricot", "Cantaloupe"]; alphaSort(fruit) > ["Cantaloupe", "butternut squash", "apricot"]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ここで、localeCompareが引数とともに使用されることに注意する価値があります。IE11+でサポートされていることを覚えておく必要があります。IEの古いバージョンでは、引数なしで使用できます。

 function caseSort(arr) { arr.sort(function (a, b) { return a.toLowerCase().localeCompare(b.toLowerCase()); }); } let fruit = ["butternut squash", "apricot", "Cantaloupe"]; caseSort(fruit) > ["apricot", "butternut squash", "Cantaloupe"]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

数値ソート

これはすべて、ゲームレコードの配列について上で説明した例には当てはまりません。 ソートはいくつかの数値配列でうまく機能しますが、ある時点で結果が予測できない場合があります。

 let highScores = [11, 57, 10, 16, 32, 100]; highScores.sort(); > [10, 100, 11, 16, 32, 57]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

実際、sort（）メソッドは辞書式比較を実行します。つまり、数値は文字列に変換され、この文字列の最初の文字をUnicodeテーブル文字の順序で照合することにより、比較が再度実行されます。 したがって、ソート順を再度決定する必要があります。

 let highScores = [11, 57, 10, 16, 32, 100]; highScores.sort( function(a,b) { return a - b; } ); > [10, 11, 16, 32, 57, 100]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

繰り返しますが、数値を逆順にソートするには、関数の位置aとbを交換します。

JSONのような構造を並べ替える

最後に、ゲームレコードの配列として表示されるJSONのようなデータ構造がある場合：

 let scores = [ { "name": "Daniel", "score": 21768 }, { "name": "Michael", "score": 33579 }, { "name": "Alison", "score": 38395 } ];
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ES6 +では、矢印関数を使用できます。

 scores.sort((a, b) => b.score - a.score));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

このサポートがない古いブラウザーの場合：

 scores.sort(function(a, b) { return a.score - b.score });
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ご覧のとおり、JavaScriptでの並べ替えはそれほど明白ではありません。これらの例が何らかの形で生活を楽にすることを願っています。

読書へ：

1. 並べ替え

2. ソートアルゴリズム

3. バブルソートとすべてすべて

4. JavaScriptでの文字列の自然なソート

5. JavaScriptの洗練されたソート

6. Javascriptソートベンチマーク

7. パフォーマンスをお探しですか？ [] .sort（V8）を使用しないでください。

べき関数を使用する

累乗とは、元々自然数の倍数乗算の結果として定義される演算であり、aの平方根は2乗したときにaを与える数です。 これらの関数は、面積、体積の計算時、または物理モデリング中を含め、数学の授業で日常生活で絶えず使用できます。



JavaScriptでは、べき乗関数はMath.pow（）として表され、新しい指数演算子「* *」が新しいES7標準に導入されました。

べき乗

数値をn乗するためには、Math.pow（）関数を使用します。最初の引数は累乗する数値、2番目の引数は指数です：

 Math.pow(3,2) > 9
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この形式の書き込みは3乗、つまり3×3を意味し、結果9になります。もちろん、別の例を挙げることができます。

 Math.pow(5,3); > 125
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

つまり、立方体の5、つまり5×5×5は125です。



ECMAScript 7はJavaScriptの次のバージョンです。原則として、新しく提案されたべき乗演算子を使用できます-* *、この形式の記述はより視覚的になります。

 3 ** 2 > 9
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

現時点では、この演算子のサポートはかなり制限されているため、使用することはお勧めしません。



電力関数は、さまざまな状況で役立ちます。 1時間あたりの秒数を計算する簡単な例：Math.pow（60.2）。

平方根および立方根

Math.sqrt（）とMath.cbrt（）は、Math.pow（）の反対です。 思い出してくださいが、aの平方根は2乗したときにaを与える数値です。

 Math.sqrt(9) > 3
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

同時に、aの立方根は、立方体に組み立てられたときにaを与える数値です。

 Math.cbrt(125) > 5
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Math.cbrt（）は最近JavaScript仕様に導入されたため、最新のブラウザー（Chrome 38以降、FirefoxおよびOpera 25以降、Safari 7.1以降）でのみサポートされています。Internet Explorerはこのリストにないことに気付くでしょうが、MDNにはpolyfillがあります。

例

もちろん、これらの関数のいずれかで非整数値を使用できます。

 Math.pow(1.25, 2); > 1.5625 Math.cbrt(56.57) > 3.8387991760286138
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これは、負の引数値を使用する場合にも非常にうまく機能することに注意してください。

 Math.pow(-5,2) > 25 Math.pow(10,-2) > 0.01
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ただし、平方根の場合、これは機能しません。

 Math.sqrt(-9) > NaN
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

数学的分析から、虚数は負の数の平方根を指すことがわかります。そして、これは複素数を扱うための別のテクニックにつながるかもしれませんが、それは別の話です。



Math.pow（）で小数値を使用して、数値の平方根と立方根を見つけることができます。平方根は0.5の尺度を使用します。

 Math.pow(5, 0.5); // = Math.sqrt(5) = 5 ** (1/2) > 2.23606797749979
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ただし、浮動小数点の変動のため、正しい結果を正確に推測することはできません。

 Math.pow(2.23606797749979,2) > 5.000000000000001
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

このような状況では、数値の符号を切り捨てるか、ある値に丸める必要があります。



理由は不明ですが、JavaScriptでは、Math.pow（）関数とMath.exp（）を混同します。これは、一般的な数値の指数関数です。注：英語では、「指数」は「指数」と翻訳されるため、指数、指数などの指数の代替名がありますが、英語を話す可能性が高くなります。

読書へ：

1. Math.pow（num、2）vs（self = num）* self

2. 負の数値 の算術平方根

3. 負の判別式で二次方程式を解く例

4. JavaScriptおよびNode.jsの広範な数学ライブラリ

5. MathMLおよびポリフィル

数学定数

JavaScriptでの数学の操作は、多数の組み込み定数によって促進されます。これらの定数は、Mathオブジェクトのプロパティです。定数がキャメルケース表記ではなく大文字で記述されていることに注意してください。

Math.pi

数値Piは、円の円周と直径の長さの比に等しい数学定数です。古い名前はルドルフ番号です。Piは無理数です。つまり、その値はm / nの分数として正確に表現できません。mとnは整数です。したがって、その10進表現は終わりがなく、周期的ではありません。紙では、3.14159という短い形式の記述を使用することが一般的です。



ブラウザは無限の数を保存できないため、JavaScriptはPiを3.141592653589793に丸めます。これはほとんどのタスクに十分です。



この数は長さ、円周を見つける問題で最も一般的ですが、数Piは確率、統計、工学、自然科学でも使用されます。これは普遍定数のようなものです。

Math.SQRT2

2の平方根は正の実数であり、それを乗算すると2になります。幾何学的に、2の平方根は、1辺の正方形の対角線の長さとして表すことができます（これはピタゴラスの定理に従う）。これは数学の歴史で知られている最初の無理数でした。JavaScriptはこの数値を値1.4142135623730951に丸めます。（JavaScriptの丸め誤差のため：Math.SQRT2 * Math.SQRT2は2に等しくありません）。

Math.SQRT1_2

0.5の平方根は、2の平方根で割った単位です。また、これは無理数です。



紙上で最も単純な変換は、次のように記述できます。

√（1/2）=√1/√2= 1 /√2=√2/ 2

しかし、浮動小数点の問題により、次の結果が得られます。

 Math.SQRT1_2 === Math.sqrt(1/2) > true Math.sqrt(2) / 2 === Math.sqrt(1/2) > true 1 / Math.sqrt(2) === Math.sqrt(1/2) > false
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Math.e

奇妙なことに、数学では定数eは常に小文字で記述されていましたが、JavaScriptではこの数字は大文字で使用されます。数値eは、自然対数の底、数学定数、無理数および超越数です。番号eは、オイラー番号またはネーピア番号と呼ばれることもあります。JavaScriptは2.718281828459045として丸めます。数eは、微分および積分計算、および他の多くの数学の分野で重要な役割を果たします。

 Math.pow(Math.E,1) > 2.718281828459045 Math.pow(Math.E,2) > 7.3890560989306495 Math.pow(Math.E,3) > 20.085536923187664
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

自然対数

自然対数はeの底対数です。ここで、eは約2.718281828の無理定数です。xの自然対数は、xを得るためにeを上げる必要がある指数です。Math.log（x）は、ベースeでのxの自然です。

 Math.log(-1); // NaN, out of range Math.log(0); // -Infinity Math.log(1); // 0 Math.log(10); // 2.302585092994046
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ベースxでyの対数を取得する必要がある場合：

 function getBaseLog(x, y) { return Math.log(y) / Math.log(x); } getBaseLog(1/5, 5) > -1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ただし、浮動小数点数の丸めの性質により、答えは必ずしも正確ではなく、正しい値に近いだけです。

  getBaseLog(10, 1000) > 2.9999999999999996
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Math.ln2

Math.LN2プロパティは、0.6931471805599453に等しい2の自然対数を表します。

Math.ln10

Math.LN10プロパティは、2.302585092994046に等しい10の自然対数を表します

Math.LOG2E

Math.LOG2Eプロパティは、1.4426950408889634に等しいeのバイナリ対数を表します

Math.LOG10E

Math.LOG10Eプロパティは、0.4342944819032518に等しいeの10進数の対数を表します

読書へ：

1. 数学定数

2. 世界が保持する10個の数字

3. 音楽に付けられる数学定数

Math.abs、parseInt、parseFloat

JavaScriptでの数値の操作は、思ったよりもはるかに複雑になる可能性があります。得られた値は常に期待される範囲内に収まるとは限らず、場合によっては期待した結果にならないことがあります。

Math.abs（）

Math.abs（）メソッドは、数値の絶対値を返します。これは、aのモジュールの同様の数学関数を思い出させます。

 let newVal = -57.64; Math.abs(newVal); > 57.64
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Math.abs（0）は常にゼロを返しますが、-Math.abs（NUM）関数の前にマイナス記号を付けると、常に負の値になります。

 -Math.abs(0); > -0
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

parseInt（）

JavaScriptは「15」が数字ではなく文字列であることを理解していることを知っています。たとえば、JavaScriptを使用してCSSプロパティを解析したり、準備されていない配列から値を取得したりすると、結果が予測不能になることがあります。 「17px」として表される入力文字列を取得できますが、これは私たちにとって珍しいことではありません。問題は、この文字列を実際の値に変換し、さらに計算で使用する方法です。



構文：parseInt（string、radix）;



parseInt関数は、渡された最初の引数を文字列型に変換し、解釈して、整数またはNaN値を返します。結果（NaNでない場合）は整数で、最初の引数（文字列）を表し、指定された数値システム（基数）の数値と見なされます。たとえば、基数10は、10進数から8進数から8進数、16進数から16進数などへの変換を示します。基数が10より大きい場合、9より大きい数を示すために文字が使用されます。たとえば、16進数（基数16）の場合、A〜Fの文字が使用されます



。CSSプロパティを操作する例を考えてみましょう。

 let elem = document.body; let centerPoint = window.getComputedStyle(elem).transformOrigin; > "454px 2087.19px"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

値をスペースで区切ることができます。

 let centers = centerPoint.split(" "); > ["454px", "2087.19px"]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ただし、各要素にはまだ文字列があります。関数を適用することでこれを取り除くことができます。

 let centerX = parseInt(centers[0], 10); > 454 let centerY = parseInt(centers[1], 10); > 2087
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ご覧のとおり、2番目の引数は数値の変換先の数値システムを示します。このパラメーターはオプションですが、入力する行がわからない場合は使用することをお勧めします。

parseFloat（）

上記の例から、おそらくparseIntが小数部分を破棄することに気づいたでしょう。この場合、parseFloatは浮動小数点数で動作します。繰り返しますが、これはCSSやその他のタスクを解析する場合、特に浮動小数点をパーセントで処理する場合に役立ちます。



構文：parseFloat（文字列）

 let FP = "33.33333%"; console.log(parseFloat(FP)); > 33.33333
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

parseFloat構文には2番目の引数がないことに注意してください。



parseInt（）およびparseFloat（）は非常に有用な関数であることを理解しています。ここではエラーを回避できないことを考慮することが重要です。したがって、期待される値の範囲を確認し、最終的に結果を分析して、取得した値が正しいことを確認する必要があります。

読書へ：

1. parseInt（）とparseFloat（） の違い

2. JavaScriptのparseInt（）とNumber（）の違いは何ですか？

3. JavaScript parseInt、文字列をIntパフォーマンスに変換

4. ベンチマーク：数値vs. マルvs. parseIntと parseFloat