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 existe 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.

Un 'n' est ajouté à la fin du non pour en faire un BigInt. Ex.
const num = 283891738917391283734234324223122313243249821n;
num; // 283891738917391283734234324223122313243249821n

BigInt est le moyen JS d'afficher des nombres aussi énormes.
Une autre façon d'utiliser Constructor Fn pour créer un numéro BigInt.
const x = BigInt(283891738917391283734234324223122313243249821);
X ; // 283891738917391288062871194223849945790676992n

Opérations : tous les opérateurs arithmétiques fonctionnent de la même manière avec BigInt ;
const x = 100n 100n;
X ; // 200n

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

Évitez de mélanger les nombres BigInt avec des nombres réguliers

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

Pour que cela fonctionne, utilisez le constructeur BigInt Fn :
z = x * BigInt(y);
z; // 1000n

Les exceptions sont les opérateurs de comparaison et l’opérateur unaire.

20n> 19 ; // vrai
20n === 20 ; // false, === empêche JS d'effectuer une coercition de type. Les LHS et RHS ont tous deux des types primitifs différents, ce qui donne donc « faux ».

type de 20n ; // 'bigint'
type de 20 ; // 'numéro'

20n == 20 ; // vrai, comme JS tape la coercition pour comparer uniquement les valeurs et non les types en convertissant BigInt en un nombre régulier.
Il en va de même pour ceci : 20n == '20'; // vrai

Exception:

Le numéro BigInt n'est pas converti en chaîne lors de l'utilisation de l'opérateur.
numéro const = 248923874328974239473829n
"num est énorme, c'est-à-dire " num ; // 'num est énorme, c'est-à-dire 248923874328974239473829'

Remarque :
Math.sqrt ne fonctionne pas avec BigInt.
Lors de la division de BigInts, il supprime la partie décimale.
10/3 ; // 3.3333333333333335
10n/3n ; // 3n
12h/3h ; // 4n

Ce nouveau type primitif ajoute de nouvelles fonctionnalités au langage JS pour le faire fonctionner avec un nombre énorme de personnes.

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!