Fermer

septembre 28, 2022

Fonctions mathématiques JavaScript utiles et comment les utiliser


L’objet JavaScript Math intégré comprend un certain nombre de fonctions utiles pour effectuer diverses opérations mathématiques. Plongeons-nous et regardons comment ils fonctionnent et à quoi vous pourriez les utiliser.

Math.max et Math.min

Ces fonctions font à peu près ce à quoi vous vous attendez : elles renvoient le maximum ou le minimum de la liste des arguments fournis :

Math.max(1,2,3,4,5)
<< 5

Math.min(4,71,-7,2,1,0)
<< -7

Les arguments tout il faut être du Number Type de données. Autrement, NaN seront retournés :

Math.max('a','b','c')
<< NaN

Math.min(5,"hello",6)
<< NaN

Attention cependant. JavaScript tentera de contraindre valeurs en un nombre :

Math.min(5,true,6)
<< 1

Dans cet exemple, la valeur booléenne true est contraint au nombre 1, c’est pourquoi elle est renvoyée comme valeur minimale. Si vous n’êtes pas familier avec la coercition de type, cela se produit lorsque les opérandes d’un opérateur sont de types différents. Dans ce cas, JavaScript tentera de convertir un opérande en une valeur équivalente du type de l’autre opérande. Vous pouvez en savoir plus sur la coercition de type dans JavaScript : novice à ninja, 2e éditionau chapitre 2.

Une liste de nombres doit être fournie comme argument, pas un tableau, mais vous pouvez utiliser l’opérateur de propagation (...) pour décompresser un tableau de nombres :

Math.max(...[8,4,2,1])
<< 8

La Math.max est utile pour trouver le meilleur score à partir d’une liste de scores enregistrés dans un tableau :

const scores = [23,12,52,6,25,38,19,37,76,54,24]
const highScore = Math.max(...scores)
<< 76

La Math.min est utile pour trouver le meilleur prix sur un comparateur de prix :

const prices = [19.99, 20.25, 18.57, 19,75, 25, 22.50]
const bestPrice = Math.min(...prices)
<< 18.57

Valeurs absolues

Un valeur absolue est simplement la taille du nombre, quelle que soit sa taille. Cela signifie que les nombres positifs restent les mêmes et que les nombres négatifs perdent leur signe moins. La Math.abs fonction calculera la valeur absolue de son argument :

Math.abs(5)
<< 5

Math.abs(-42)
<< 42

Math.abs(-3.14159)
<< 3.14159

Pourquoi voudriez-vous faire cela? Eh bien, parfois vous voulez calculer le différence entre deux valeurs, que vous calculez en soustrayant la plus petite de la plus grande, mais souvent vous ne saurez pas à l’avance quelle est la plus petite des deux valeurs. Pour vous déplacer, vous pouvez simplement soustraire les nombres dans n’importe quel ordre et prendre la valeur absolue :

const x = 5
const y = 8

const difference = Math.abs(x - y)
<< 3

Un exemple pratique pourrait être sur un site Web d’économie d’argent, où vous voulez savoir combien vous pourriez économiser en calculant la différence entre deux offres, puisque vous auriez affaire à des données de prix en direct et ne sauriez pas à l’avance quelle offre a été le moins cher:

const dealA = 150
const dealB = 167

const saving = Math.abs(dealA - dealB)
<< 17

Math.pow

Math.pow effectue des calculs de puissance, comme ceux-ci :

3= 81

Dans l’exemple ci-dessus, 3 est connu comme le base nombre et 4 est le exposant. Nous le lirions comme « 3 à la puissance 4 égale 81 ».

La fonction accepte deux valeurs — la base et l’exposant — et renvoie le résultat de l’élévation de la base à la puissance de l’exposant :

Math.pow(2,3)
<< 8

Math.pow(8,0)
<< 1

Math.pow(-1,-1)
<< -1

Math.pow a pratiquement été remplacé par l’opérateur d’exponentiation infixe (**) — introduit dans ES2016 — qui fait exactement la même opération :

2 ** 3
<< 8

8 ** 0
<< 1

(-1) ** (-1)
<< -1

Calcul des racines

Les racines sont l’opération inverse des puissances. Par exemple, puisque 3 au carré est 9, la racine carrée de 9 est 3.

Math.sqrt peut être utilisé pour renvoyer la racine carrée du nombre fourni en argument :

Math.sqrt(4)
<< 2

Math.sqrt(100)
<< 10

Math.sqrt(2)
<< 1.4142135623730951

Cette fonction retournera NaN si un nombre négatif ou une valeur non numérique est fourni comme argument :

Math.sqrt(-1)
<< NaN

Math.sqrt("four")
<< NaN

Mais attention, car JavaScript tentera de contraindre le type :

Math.sqrt('4') 
<< 2

Math.sqrt(true)
<< 1

Math.cbrt renvoie la racine cubique d’un nombre. Cela accepte tous les nombres, y compris les nombres négatifs. Il tentera également de contraindre le type si une valeur qui n’est pas un nombre est utilisée. S’il ne peut pas contraindre la valeur à un nombre, il renverra NaN:

Math.cbrt(1000)
<< 10

Math.cbrt(-1000)
<< -10

Math.cbrt("10")
<< 2.154434690031884

Math.cbrt(false)
<< 0

Il est possible de calculer d’autres racines en utilisant l’opérateur d’exponentiation et une puissance fractionnaire. Par exemple, la quatrième racine d’un nombre peut être trouvée en l’élevant à la puissance un quart (ou 0,25). Ainsi, le code suivant renverra la quatrième racine de 625 :

625 ** 0.25
<< 5

Pour trouver la racine cinquième d’un nombre, vous devez l’élever à la puissance un cinquième (ou 0,2) :

32 ** 0.2
<< 2

En général, pour trouver la racine nième d’un nombre, vous devez l’élever à la puissance 1/ndonc pour trouver la sixième racine d’un million, vous devez l’élever à la puissance 1/6 :

1000000 ** (1/6)
<< 9.999999999999998

Notez qu’il y a une erreur d’arrondi ici, car la réponse devrait être exactement 10. Cela se produira souvent avec des puissances fractionnaires qui ne peuvent pas être exprimées exactement en binaire. (Vous pouvez en savoir plus sur ce problème d’arrondi dans « Un guide pour arrondir les nombres en JavaScript« .)

Notez également que vous ne pouvez pas trouver les racines des nombres négatifs si la racine est paire. Cela reviendra NaN. Vous ne pouvez donc pas essayer de trouver la racine 10 de -7, par exemple (parce que 10 est pair) :

(-7) ** 0.1 
<< NaN

L’une des raisons pour lesquelles vous voudrez peut-être calculer les racines est de calculer les taux de croissance. Par exemple, disons que vous voulez multiplier par 10 vos bénéfices d’ici la fin de l’année. De combien vos bénéfices doivent-ils augmenter chaque mois ? Pour le savoir, vous devez calculer la racine 12 de 10, ou 10 à la puissance douzième :

10 ** (1/12)
<< 1.2115276586285884

Ce résultat nous indique que le facteur de croissance mensuel doit être d’environ 1,21 pour multiplier par 10 les bénéfices d’ici la fin de l’année. Ou pour le dire autrement, vous auriez besoin d’augmenter vos bénéfices de 21% chaque mois afin d’atteindre votre objectif.

Logs et exponentielles

Logarithmes – ou logs en abrégé – peut être utilisé pour trouver l’exposant d’un calcul. Par exemple, imaginez que vous vouliez résoudre l’équation suivante :

2ˣ = 100

Dans l’équation ci-dessus, x n’est certainement pas un entier, car 100 n’est pas une puissance de 2. Cela peut être résolu en utilisant des logarithmes de base 2 :

x = log²(100) = 6.64 (rounded to 2 d.p.)

La Math l’objet a un log2 méthode qui effectuera ce calcul :

Math.log2(100)
<< 6.643856189774724

Il a également un log10 méthode qui effectue les mêmes calculs, mais utilise 10 comme nombre de base :

Math.log10(100)
<< 2

Ce résultat nous dit que, pour obtenir 100, il faut élever 10 à la puissance 2.

Il existe une autre méthode de journalisation, qui est juste Math.log. Cela calcule le un algorithme naturelqui utilise Le numéro d’Eulere (environ 2,7) — comme base. Cela peut sembler être une valeur étrange à utiliser, mais cela se produit souvent dans la nature lorsque la croissance exponentielle se produit – d’où le nom de « logarithmes naturels »:

Math.log(10)
<< 4.605170185988092

Math.log(Math.E)
<< 1

Le dernier calcul montre que le nombre d’Euler (e) — qui est stocké en tant que constante Math.E — doit être élevé à la puissance 1 pour s’obtenir. Cela a du sens, car tout nombre à la puissance 1 est en fait lui-même. Les mêmes résultats peuvent être obtenus si 2 et 10 sont fournis comme arguments pour Math.log2 et Math.log10:

Math.log2(2)
<< 1

Math.log10(10)
<< 1

Pourquoi utiliser des logarithmes ? Il est courant, lorsqu’il s’agit de données qui croissent de manière exponentielle, d’utiliser une échelle logarithmique afin que le taux de croissance soit plus facile à voir. Des échelles logarithmiques ont souvent été utilisées pour mesurer le nombre de cas quotidiens de COVID-19 pendant la pandémie, car ils augmentaient si rapidement.

Si vous avez la chance d’avoir un site Web dont la popularité augmente rapidement (par exemple, doublant chaque jour), vous voudrez peut-être envisager d’utiliser une échelle logarithmique avant d’afficher un graphique pour montrer comment votre popularité augmente.

Hypoténuse

Vous vous souvenez peut-être d’avoir étudié Théorème de Pythagore à l’école. Cela indique que la longueur du côté le plus long d’un triangle rectangle (le hypoténuse) peut être trouvé en utilisant la formule suivante :

= x² + y²

Ici, x et y sont les longueurs des deux autres côtés.

La Math l’objet a un hypot méthode qui calcule la longueur de l’hypoténuse lorsqu’elle est fournie avec les deux autres longueurs comme arguments. Par exemple, si un côté est de longueur 3 et l’autre de longueur 4, nous pouvons calculer l’hypoténuse en utilisant le code suivant :

Math.hypot(3,4)
<< 5

Mais pourquoi cela serait-il utile ? Eh bien, l’hypoténuse est une mesure de la distance la plus courte entre deux points. Cela signifie que, si vous connaissez les coordonnées x et y de deux éléments sur la page, vous pouvez utiliser cette fonction pour calculer leur distance :

const ship = {x: 220, y: 100}
const boat = {x: 340, y: 50}

const distance = Math.hypot(ship.x - boat.x,ship.y - boat.y)

J’espère que ce bref tour d’horizon a été utile et vous aide à utiliser toute la puissance de l’objet JavaScript Math dans vos projets.

Lecture connexe :




Source link