Espace de noms mathématiques et BigInt

Math.sqrt, c'est-à-dire sqrt fait partie de l'espace de noms Math.

// 2 façons d'obtenir la racine carrée.
Math.sqrt(100); // 10, Méthode 1
100*(1/2); // 10, Méthode 2
8*(1/3); // 2, fonctionne également pour la racine cubique

Math.max() & Math.min() :

Math.max(23,54,12,6,32,98,87,34,11); //98
// Tape également la coercition
Math.min(23,54,12,'6',32,98,87,34,11); // 6
// N'effectue pas d'analyse
Math.min(23,54,12,'6px',32,98,87,34,11); //NaN

Constantes intégrées sur l'objet Math :

Math.PI * (Number.parseFloat('10px')**(2)); // Récupération de la zone

Générez un non n/b 1-6 :

Math.trunc(Math.random() * 6) + 1;

Générez un non aléatoire n/b avec une limite supérieure-inférieure :

const randomInt = (min, max) => Math.floor(Math.random() * (max-min)) + 1 + min;
randomInt(10,20);

// Tous ces Math.method() tapent la coercition.
Math.trunc(25.4); // 25
Math.round(25.4); // 25
Math.sol(25.4); // 25
Math.ceil(25.4); // 26

Math.floor est un meilleur choix pour les nombres négatifs.

Math.trunc(-25.4); // -25
Math.sol(-25,4); // -26

// Arrondir les décimales : .toFixed renvoie une chaîne, pas un nombre
(2.5).toFixed(0); // '3'
(2.5).toFixed(3); // '2.500'
(2.345).toFixed(2); // '2.35'

// Ajoutez un signe unaire + pour le convertir en non.
+(2.345).toFixed(2); // 2.35

// Le nombre est une primitive, donc ils n'ont pas de méthodes. DONC en coulisses, JS fera de la boxe, c'est-à-dire transformera le primitif en un non-objet, effectuera l'opération puis, lorsque l'opération sera terminée, le transformera à nouveau en primitif.

Opérateur modulaire ou restant :

5%2; // 1

8%3; // 2
8/3 ; // 2.6666666666666665

// Impair ou Pair
const isEven = n => n%2 === 0;
estMême(20);
estMême(21);
estMême(22);

Cas d'utilisation : utilisé pour travailler avec toutes les lignes impaires, paires, la nième fois, etc.

Séparateurs numériques : [ES2021]

Utilisé pour représenter de très grands nombres
Ce sont des traits de soulignement qui peuvent être placés entre les nombres. Le moteur ignore ces traits de soulignement, cela réduit la confusion pour les développeurs.
Ex. diamètre const = 287_460_000_000;
diamètre; // 287460000000

prix const = 342_25;
prix; // 34225

frais const1 = 1_500;
frais const2 = 15_00;
frais1 === frais2; // vrai

Le trait de soulignement peut être placé UNIQUEMENT entre les chiffres.
Il ne peut pas être placé à côté d'un point décimal.
Il ne peut pas non plus être placé au début ou à la fin du numéro.

const PI = 3.14_15;
PI; // 3.1415

Tous sont des exemples non valides de séparateurs numériques

const PI = 3,1415 ; // Ne peut pas être placé au début.
const PI = 3,1415 ; // Ne peut pas être placé à la fin.
const PI = 3_.1415 ; // Ne peut pas être placé à côté d'un point décimal.
const PI = 3.1415 ; // Ne peut pas être placé à côté d'un point décimal.
const PI = 3._1415; // Impossible d'en placer deux à la suite.

Conversion de chaînes en nombres :

Nombre('2500'); // 2500
Numéro('25_00'); // NaN , nous ne pouvons donc l'utiliser que lorsque des nombres sont directement attribués à une variable. Par conséquent, si un non est stocké dans la chaîne ou si vous obtenez un non d'une API, alors pour éviter les erreurs, n'utilisez pas le séparateur numérique '_'.
Il en va de même pour parseInt, c'est-à-dire que tout ce qui suit _ est supprimé comme indiqué ci-dessous :
parseInt('25_00'); // 25

GrosInt

Type spécial d'entiers, introduit dans ES2020
Les nombres sont représentés en interne sous forme de 64 bits, c'est-à-dire 64 1 ou 0 pour représenter n'importe quel nombre. Seuls 53 sont utilisés pour stocker les chiffres, les autres sont utilisés pour stocker la position du point décimal et le signe. Par conséquent, il y a une limite sur la taille du nombre, c'est-à-dire ((2*53) - 1). C’est le plus grand non que JS puisse représenter en toute sécurité. La base est 2, car nous travaillons sous forme binaire lors du stockage.
2*53 - 1; //9007199254740991
Numéro.MAX_SAFE_INTEGER ; //9007199254740991

Tout ce qui est plus grand que cela n’est pas sûr, c’est-à-dire qu’il ne peut pas être représenté avec précision. La précision sera perdue pour les nombres supérieurs à celui indiqué dans le dernier chiffre. Parfois, cela peut fonctionner, parfois non.
Numéro.MAX_SAFE_INTEGER + 1 ; //9007199254740992
Numéro.MAX_SAFE_INTEGER + 2 ; //9007199254740992
Numéro.MAX_SAFE_INTEGER + 3 ; //9007199254740994
Numéro.MAX_SAFE_INTEGER + 4 ; //9007199254740996

Si nous obtenons un non plus grand d'une API plus grande que cela, alors JS ne pourra pas le gérer. Ainsi, pour résoudre le problème ci-dessus, BigInt, un nouveau type de données primitif, a été introduit dans ES2020. Cela peut stocker des entiers aussi grands que nous le souhaitons.

An 'n' is added at the end of the no to make it a BigInt. Ex.
const num = 283891738917391283734234324223122313243249821n;
num; // 283891738917391283734234324223122313243249821n

BigInt is JS way of displaying such huge numbers.
Another way using Constructor Fn for creating BigInt number.
const x = BigInt(283891738917391283734234324223122313243249821);
x; // 283891738917391288062871194223849945790676992n

Operations: All arithmetic operators work the same with BigInt;
const x = 100n + 100n;
x; // 200n

const x = 10n * 10n;
x; // 100n

Avoid mixing BigInt numbers with regular numbers

const x = 100n;
const y = 10;
z = x*y; // Error

To make it work, use BigInt constructor Fn:
z = x * BigInt(y);
z; // 1000n

Exception to it are comparsion operators & unary + operator.

20n > 19; // true
20n === 20; // false, === prevents JS from doing type coercion. Both the LHS & RHS have different primitive types, hence results in 'false'.

typeof 20n; // 'bigint'
typeof 20; // 'number'

20n == 20; // true, as JS does type coercion to compare only the values and not the types by converting BigInt to a regular number.
Same goes for this also: 20n == '20'; // true

Exception:

BigInt number is not converted to string on using + operator.
const num = 248923874328974239473829n
"num is huge i.e. " + num; // 'num is huge i.e. 248923874328974239473829'

Note:
Math.sqrt doesn't work with BigInt.
During division of BigInts, it discards the decimal part.
10 / 3; // 3.3333333333333335
10n / 3n; // 3n
12n / 3n; // 4n

This new primitive type adds some new capabilities to JS language to make it work with huge no.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!