Mathe-Namespace und BigInt

Math.sqrt, d. h. sqrt ist Teil des Math-Namespace.

// 2 Möglichkeiten, die Quadratwurzel zu ziehen.
Math.sqrt(100); // 10, Methode 1
100*(1/2); // 10, Methode 2
8*(1/3); // 2, funktioniert auch für die Kubikwurzel

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

Math.max(23,54,12,6,32,98,87,34,11); // 98
// Gibt auch Zwang ein
Math.min(23,54,12,'6',32,98,87,34,11); // 6
// Führt keine Analyse durch
Math.min(23,54,12,'6px',32,98,87,34,11); // NaN

Eingebaute Konstanten im Math-Objekt:

Math.PI * (Number.parseFloat('10px')**(2)); // Bereich abrufen

Generieren Sie ein Nein-S/W 1-6:

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

Generieren Sie eine zufällige Nummer s/w mit einer Ober- und Untergrenze:

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

// Alle diese Math.method() führen Typzwang aus.
Math.trunc(25.4); // 25
Math.round(25.4); // 25
Math.floor(25.4); // 25
Math.ceil(25.4); // 26

Math.floor ist für negative Zahlen die bessere Wahl.

Math.trunc(-25.4); // -25
Math.floor(-25.4); // -26

// Dezimalzahlen runden: .toFixed gibt eine Zeichenfolge zurück, keine Zahl
(2.5).toFixed(0); // '3'
(2.5).toFixed(3); // '2.500'
(2.345).toFixed(2); // '2.35'

// Fügen Sie ein unäres Zeichen hinzu, um es in ein Nein umzuwandeln.
(2.345).toFixed(2); // 2,35

// Zahl ist ein Grundelement, daher haben sie keine Methoden. SO wird JS hinter den Kulissen das Boxen durchführen, d. h. das Primitiv in ein Nicht-Objekt umwandeln, die Operation ausführen und es dann, wenn die Operation abgeschlossen ist, wieder in das Primitiv umwandeln.

Modularer oder Restbetreiber:

5 % 2; // 1

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

// Ungerade oder Gerade
const isEven = n => n%2 === 0;
isEven(20);
isEven(21);
isEven(22);

Anwendungsfall: Wird verwendet, um mit allen ungeraden Zeilen, geraden Zeilen, dem n-ten Mal usw. zu arbeiten.

Numerische Trennzeichen: [ES2021]

Wird zur Darstellung wirklich großer Zahlen verwendet
Dabei handelt es sich um Unterstriche, die zwischen Zahlen gesetzt werden können. Die Engine ignoriert diese Unterstriche, das verringert die Verwirrung für Entwickler.
Ex. const-Durchmesser = 287_460_000_000;
Durchmesser; // 287460000000

Const-Preis = 342_25;
Preis; // 34225

const fee1 = 1_500;
const fee2 = 15_00;
Gebühr1 === Gebühr2; // wahr

Unterstriche können NUR zwischen Zahlen gesetzt werden.
Es kann nicht neben einem Dezimalpunkt platziert werden.
Es kann auch nicht am Anfang oder am Ende der Nr. platziert werden.

const PI = 3.14_15;
PI; // 3.1415

Alle sind ungültige Beispiele für numerische Trennzeichen

const PI = 3.1415; // Kann nicht am Anfang platziert werden.
const PI = 3,1415; // Kann nicht am Ende platziert werden.
const PI = 3_.1415; // Kann nicht neben einem Dezimalpunkt platziert werden.
const PI = 3.1415; // Kann nicht neben einem Dezimalpunkt platziert werden.
const PI = 3._1415; // Zwei in einer Reihe können nicht platziert werden.

Konvertieren von Zeichenfolgen in Zahlen:

Number('2500'); // 2500
Zahl('25_00'); // NaN, daher können wir es nur verwenden, wenn einer Variablen direkt Zahlen zugewiesen werden. Wenn also ein „Nein“ in der Zeichenfolge gespeichert ist oder ein „Nein“ von einer API erhalten wird, verwenden Sie zur Vermeidung von Fehlern kein numerisches Trennzeichen „_“.
Ähnliches gilt für parseInt, d. h. alles nach _ wird verworfen, wie unten gezeigt:
parseInt('25_00'); // 25

BigInt

Spezieller Typ von Ganzzahlen, eingeführt in ES2020
Zahlen werden intern als 64 Bits dargestellt, d. h. 64 Einsen oder Nullen, um eine beliebige Zahl darzustellen. Nur 53 werden zum Speichern der Ziffern verwendet, die restlichen werden zum Speichern der Position des Dezimalpunkts und des Vorzeichens verwendet. Daher gibt es eine Grenze für die Größe der Zahl, d. h. ((2*53) - 1). Dies ist das größte Nein, das JS sicher vertreten kann. Die Basis ist 2, da wir beim Speichern in binärer Form arbeiten.
2*53 - 1; // 9007199254740991
Zahl.MAX_SAFE_INTEGER; // 9007199254740991

Alles, was größer ist, ist nicht sicher, d. h. es kann nicht genau dargestellt werden. Bei größeren Zahlen geht die Genauigkeit verloren, wie in der letzten Ziffer gezeigt. Manchmal funktioniert es vielleicht, manchmal aber auch nicht.
Zahl.MAX_SAFE_INTEGER 1; // 9007199254740992
Zahl.MAX_SAFE_INTEGER 2; // 9007199254740992
Zahl.MAX_SAFE_INTEGER 3; // 9007199254740994
Zahl.MAX_SAFE_INTEGER 4; // 9007199254740996

Falls wir von einer größeren API ein größeres Nein erhalten, kann JS damit nicht umgehen. Um das oben genannte Problem zu lösen, wurde in ES2020 ein neuer primitiver Datentyp BigInt eingeführt. Dadurch können beliebig große Ganzzahlen gespeichert werden.

Am Ende des Neins wird ein „n“ hinzugefügt, um es zu einem BigInt zu machen. Bsp.
const num = 283891738917391283734234324223122313243249821n;
num; // 283891738917391283734234324223122313243249821n

BigInt ist eine JS-Methode, um so große Zahlen anzuzeigen.
Eine andere Möglichkeit, den Konstruktor Fn zum Erstellen einer BigInt-Nummer zu verwenden.
const x = BigInt(283891738917391283734234324223122313243249821);
X; // 283891738917391288062871194223849945790676992n

Operationen: Alle arithmetischen Operatoren funktionieren mit BigInt;
gleich const x = 100n 100n;
X; // 200n

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

Vermeiden Sie es, BigInt-Zahlen mit regulären Zahlen zu mischen

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

Damit es funktioniert, verwenden Sie den BigInt-Konstruktor Fn:
z = x * BigInt(y);
z; // 1000n

Eine Ausnahme bilden Vergleichsoperatoren und unäre Operatoren.

20n > 19; // wahr
20n === 20; // false, === verhindert, dass JS eine Typerzwingung durchführt. Sowohl die linke als auch die rechte Seite haben unterschiedliche Grundtypen und führen daher zu „falsch“.

Typ von 20n; // 'bigint'
Typ 20; // 'Nummer'

20n == 20; // wahr, da JS Typzwang durchführt, um nur die Werte und nicht die Typen zu vergleichen, indem BigInt in eine reguläre Zahl konvertiert wird.
Das Gleiche gilt auch dafür: 20n == '20'; // wahr

Ausnahme:

BigInt-Zahl wird bei Verwendung des Operators nicht in eine Zeichenfolge konvertiert.
const num = 248923874328974239473829n
„num ist riesig, d. h.“ num; // 'Anzahl ist riesig, d. h. 248923874328974239473829'

Hinweis:
Math.sqrt funktioniert nicht mit BigInt.
Bei der Division von BigInts wird der Dezimalteil verworfen.
10 / 3; // 3.3333333333333335
10n / 3n; // 3n
12n / 3n; // 4n

Dieser neue primitive Typ fügt der JS-Sprache einige neue Funktionen hinzu, damit sie mit großer Anzahl funktioniert.

Das obige ist der detaillierte Inhalt vonMathe-Namespace und BigInt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!