JavaScript Math 對象包含一些真正有用且強大的數(shù)學運算，可用于 Web 開發(fā)，但它缺乏大多數(shù)其他語言提供的許多重要運算，本文主要補充一些常用的數(shù)學方法。

sum 求和

sum函數(shù)將涉及對數(shù)組中的所有值求和。

有兩種編寫此函數(shù)的方法：我們可以使用循環(huán)for，或者使用reduce函數(shù)。

使用for循環(huán)：

function sum(array){
    let total = 0
    for(let count = 0; count < array.length; count++){
        total = total + array[count]
    }
    return total
}

使用reduce：

function sum(array){
    return array.reduce((sum, number) => sum + number, 0)
}

這兩個函數(shù)的工作方式完全相同（reduce函數(shù)只是一個內(nèi)置for循環(huán)），并且將返回相同的數(shù)字（給定相同的數(shù)組）。但reduce功能要簡潔得多。

能夠?qū)?shù)字列表求和可能是 JavaScript 的Math對象中最有用和最需要的但是缺失的數(shù)學操作。sum函數(shù)是一個很好的檢查工具。例如，在數(shù)獨中，我們可以通過檢查列/行之和是否為來檢查用戶在該列或行中是否沒有重復。如果我們想計算出總賬單，那么該函數(shù)在在線購物應用程序中也能很好地工作——假設(shè)所有價格都存儲在一個數(shù)組中。

按照購物應用程序示例，下面是示例：

const prices = [2.80, 6.10, 1.50, 1.00, 8.99, 2.99]
function totalCost(prices){
    return prices.reduce((sum, item) => sum + item, 0)
}

product 乘積

product函數(shù)將以與該函數(shù)類似的方式工作sum，只不過我們不是將列表中的所有數(shù)字相加，而是將它們相乘。

同樣我們可以使用與第一個sum函數(shù)幾乎相同的for循環(huán)：

function product(array){
    let total = 1
    for(let count = 0; count < array.length; count++){
        total = total * array[count]
    }
    return total
}

注意，我們用1來初始化total變量，否則我們總是會得到.

使用reduce:

function product(array){
    return array.reduce((total, num) => total*num, 1)
}

這個函數(shù)的用途可能看起來并不明顯。但它在嘗試在一次計算中進行多次轉(zhuǎn)換時非常有用。例如，如果我們想查找 10 個蘋果的價格（每個 1.5 元），滿10個打9折，與其使用巨大的乘法和，不如將所有值存儲在數(shù)組中并使用我們剛剛編寫的product函數(shù)。

const pricePer = 1.50
const number = 10
const discount = 0.9
const conversion = [1.5, 10, 0.9]
const price = product(conversion)

奇數(shù)和偶數(shù)

這個函數(shù)將接受一個數(shù)字，并根據(jù)該數(shù)字是奇數(shù)還是偶數(shù)返回true或者false。

在 JavaScript 中編寫這些函數(shù)的最簡單方法是使用余數(shù)運算符(%)。當一個數(shù)字除以另一個數(shù)字時，這將返回余數(shù)。例如：

11 % 3 === 2
// 11 - 3 * 3 = 2

判斷是否偶數(shù)

function isEven(number){
    return number % 2 === 0
}

判斷是否是奇數(shù)

function isOdd(number){
    return number % 2 !== 0
}

能夠檢查一個數(shù)字是奇數(shù)還是偶數(shù)至關(guān)重要，而且非常簡單。它可能看起來不那么重要，但可以作為一種很好的輸入驗證技術(shù) - 例如，使用數(shù)組長度來做判斷，簡單地通過檢查兩人游戲的獲勝者。可以跟蹤已經(jīng)玩了多少輪。假設(shè)第一輪計為 1，如果數(shù)字為奇數(shù)，則玩家 1 獲勝，如果數(shù)字為偶數(shù)，則玩家 2 獲勝

function checkWinner(gamesPlayed){
    let winner
    if(isOdd(gamesPlayed)){
        winner = "player1"
    }
    else{
        winner = "player2"
    }
    return winner
}

這些函數(shù)是可以互換的，我們很可能只需要使用其中一個。

factorial 階乘

自然數(shù)（任何嚴格大于 0 的整數(shù)）的階乘是所有小于或等于該數(shù)的數(shù)的乘積。例如： 3 階乘（用 表示3!）是3 x 2 x 1 = 6。

有兩種創(chuàng)建factorial函數(shù)的方法：使用for循環(huán)和使用遞歸。遞歸算法，它們本質(zhì)上是重復調(diào)用自身直到達到“基本情況”的函數(shù)。

使用for循環(huán)：

function factorial(number){
  let total = 1
  for (let i = 1; i < number+1; i++){
    total = total * i
  }
  return total
}

這種方式循環(huán)遍歷從 1 到 number 的所有數(shù)字（每次傳遞遞增），并將總數(shù)乘以每個數(shù)字，然后返回最終總數(shù)（數(shù)字階乘）。

使用遞歸：

function factorial(number){
  if (number <= 0){
    return 1
  }
  else{
    return number * factorial(number - 1)
  }
}

在這個函數(shù)中，我們的基本情況為零，因為0!的值為 1。這意味著，當數(shù)字通過函數(shù)時，只要它不為零，它就會將自身乘以factorial(number - 1)

factors 因子

因子成對出現(xiàn)，每對因子相乘形成原始數(shù)字。例如：

• 10的因數(shù)是：1和10；2和5。
• 18的因數(shù)是：1和18；2和9；3和6。

factors函數(shù)接受一個數(shù)字，并返回一個包含其所有因子的數(shù)組。編寫此函數(shù)的方法有很多種，但最簡單的方法是使用命令式方法:

function factors(number){
    let factorsList = []
    for(let count = 1; count < number+1; count++){
        if(number % count === 0){
            factorsList.push(count)
        }
    }
    return factorsList
}

首先，我們創(chuàng)建一個空數(shù)組。然后，我們使用for循環(huán)遍歷從 1 到數(shù)字本身的每個整數(shù)，并在每次傳遞時檢查該數(shù)字是否可被該整數(shù)整除

查找數(shù)字的因子非常有用，特別是當我們需要組建組時 - 例如在在線游戲中，當需要每個團隊中有相同數(shù)量的用戶時。例如，如果我們有 20 個用戶，每個團隊需要 10 名玩家，您可以使用一個factors函數(shù)將這 10 名用戶分成兩個團隊進行匹配。同樣，如果每支球隊需要四名球員，可以使用該factors函數(shù)將四支球隊匹配為五支球隊。

function createTeams(numberOfPlayers, numberOfTeams){
    let playersInEachTeam
    if(factors(numberOfPlayers).includes(numberOfTeams)){
        playersInEachTeam = numberOfPlayers / numberOfTeams
    }
    else{
        playersInEachTeam = "wait for more players"
    }
    return playersInEachTeam
}

isPrime 質(zhì)數(shù)

質(zhì)數(shù)：一個大于1的自然數(shù)，除了1和它本身外，不能被其他自然數(shù)整除

我們可以結(jié)合上一個factors方法來實現(xiàn)。

function isPrime(number){
    return factors(number).length === 2
}

gcd 最大公約數(shù)

最大公約數(shù)運算有時被稱為“最大公因數(shù)”，它可以找到兩個數(shù)字共有的最大因數(shù)。

例如：

• 12和15的GCD是3。
• 8 和 4 的 GCD 是 4。

解決這個問題的一個簡單方法是列出每個數(shù)字的所有因數(shù)（使用我們上面提到的factors``）并比較這些列表。然而，比較列表是一個效率低下的數(shù)組操作。

function gcd(number1, number2){
    let inCommon = []
    for(let i of factors(number1)){
        if(factors(number2).includes(i)){
            inCommon.push(i)
        }
    }
    return inCommon.sort((a,b)=> b - a)[0]
}

還有一種更簡潔的方法是使用遞歸。這是一個非常著名的算法，稱為歐幾里得算法：

function gcd(number1, number2){
    if(number2 === 0){
        return number1
    }
    else{
        return gcd(number2, number1%number2)
    }
}

lcm 最小公倍數(shù)

最小公倍數(shù)與最大公約數(shù)的類似，但是是找到的是兩個數(shù)字都是其因子的最小整數(shù)。

例如：

• 2和6的最小公倍數(shù)是6。
• 4和15的最小公倍數(shù)是60。

對于這個函數(shù)，我們不能只創(chuàng)建一個包含每個數(shù)字的所有倍數(shù)的數(shù)組，因為這將是一個無限列表。

可以使用一個非常有用的公式來計算最小公倍數(shù)：

(number1 x number2) / 最大公約數(shù)

比如：

(2 x 6) / gcd(2,6) = 12/2 = 6

實現(xiàn)：

function lcm(number1, number2){
    return (number1*number2)/gcd(number1, number2)
}

這個函數(shù)可能沒有任何明顯的用途，但它非常適合兩個事件以不同時間間隔發(fā)生的情況，這意味著我們可以使用 lcm 來找出兩個事件何時同時發(fā)生。

例如，如果圖像被編程為每六秒出現(xiàn)一次，一段文本被編程為每八秒出現(xiàn)一次，則圖像和段落將在第 24 秒第一次一起出現(xiàn)。

到此這篇關(guān)于js的math中缺少的數(shù)學方法小結(jié)的文章就介紹到這了,更多相關(guān)js math缺少數(shù)學方法內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論