`Math` • JavaScript für ungeduldige Programmierer (ES2022-Edition)

17 `Math`

Math ist ein Objekt mit Dateneigenschaften und Methoden zur Verarbeitung von Zahlen. Man kann es als Modul für Arme betrachten: Es wurde lange vor der Einführung von Modulen in JavaScript erstellt.

17.1 Dateneigenschaften

Math.E: number ^[ES1]

Eulersche Zahl, Basis der natürlichen Logarithmen, ungefähr 2.7182818284590452354.
Math.LN10: number ^[ES1]

Der natürliche Logarithmus von 10, ungefähr 2.302585092994046.
Math.LN2: number ^[ES1]

Der natürliche Logarithmus von 2, ungefähr 0.6931471805599453.
Math.LOG10E: number ^[ES1]

Der Logarithmus von e zur Basis 10, ungefähr 0.4342944819032518.
Math.LOG2E: number ^[ES1]

Der Logarithmus von e zur Basis 2, ungefähr 1.4426950408889634.
Math.PI: number ^[ES1]

Die mathematische Konstante π, Verhältnis des Umfangs eines Kreises zu seinem Durchmesser, ungefähr 3.1415926535897932.
Math.SQRT1_2: number ^[ES1]

Die Quadratwurzel von 1/2, ungefähr 0.7071067811865476.
Math.SQRT2: number ^[ES1]

Die Quadratwurzel von 2, ungefähr 1.4142135623730951.

17.2 Potenzen, Wurzeln, Logarithmen

Math.cbrt(x: number): number ^[ES6]

Gibt die Kubikwurzel von x zurück.
```
> Math.cbrt(8)
2
```
Math.exp(x: number): number ^[ES1]

Gibt e^x zurück (e ist die Eulersche Zahl). Die Umkehrung von Math.log().
```
> Math.exp(0)
1
> Math.exp(1) === Math.E
true
```
Math.expm1(x: number): number ^[ES6]

Gibt Math.exp(x)-1 zurück. Die Umkehrung von Math.log1p(). Sehr kleine Zahlen (Brüche nahe 0) werden mit höherer Präzision dargestellt. Daher liefert diese Funktion präzisere Werte, wenn .exp() Werte nahe 1 zurückgibt.
Math.log(x: number): number ^[ES1]

Gibt den natürlichen Logarithmus von x zurück (zur Basis e, Eulersche Zahl). Die Umkehrung von Math.exp().
```
> Math.log(1)
0
> Math.log(Math.E)
1
> Math.log(Math.E ** 2)
2
```
Math.log1p(x: number): number ^[ES6]

Gibt Math.log(1 + x) zurück. Die Umkehrung von Math.expm1(). Sehr kleine Zahlen (Brüche nahe 0) werden mit höherer Präzision dargestellt. Daher können Sie dieser Funktion ein präziseres Argument übergeben, wenn das Argument für .log() nahe 1 liegt.
Math.log10(x: number): number ^[ES6]

Gibt den Logarithmus von x zur Basis 10 zurück. Die Umkehrung von 10 ** x.
```
> Math.log10(1)
0
> Math.log10(10)
1
> Math.log10(100)
2
```
Math.log2(x: number): number ^[ES6]

Gibt den Logarithmus von x zur Basis 2 zurück. Die Umkehrung von 2 ** x.
```
> Math.log2(1)
0
> Math.log2(2)
1
> Math.log2(4)
2
```
Math.pow(x: number, y: number): number ^[ES1]

Gibt x^y zurück, x hoch y. Das Gleiche wie x ** y.
```
> Math.pow(2, 3)
8
> Math.pow(25, 0.5)
5
```
Math.sqrt(x: number): number ^[ES1]

Gibt die Quadratwurzel von x zurück. Die Umkehrung von x ** 2.
```
> Math.sqrt(9)
3
```

17.3 Runden

Runden bedeutet, eine beliebige Zahl in eine ganze Zahl (eine Zahl ohne Dezimalbruch) umzuwandeln. Die folgenden Funktionen implementieren verschiedene Ansätze zum Runden.

Math.ceil(x: number): number ^[ES1]

Gibt die kleinste (am nächsten zu −∞ liegende) ganze Zahl i zurück, für die x ≤ i gilt.
```
> Math.ceil(2.1)
3
> Math.ceil(2.9)
3
```
Math.floor(x: number): number ^[ES1]

Gibt die größte (am nächsten zu +∞ liegende) ganze Zahl i zurück, für die i ≤ x gilt.
```
> Math.floor(2.1)
2
> Math.floor(2.9)
2
```
Math.round(x: number): number ^[ES1]

Gibt die ganze Zahl zurück, die x am nächsten liegt. Wenn der Dezimalbruch von x .5 ist, rundet .round() auf (zur nächstgelegenen ganzen Zahl in Richtung positive Unendlichkeit).
```
> Math.round(2.4)
2
> Math.round(2.5)
3
```
Math.trunc(x: number): number ^[ES6]

Entfernt den Dezimalbruch von x und gibt die resultierende ganze Zahl zurück.
```
> Math.trunc(2.1)
2
> Math.trunc(2.9)
2
```

Tabelle 12 zeigt die Ergebnisse der Rundungsfunktionen für einige repräsentative Eingaben.

Tabelle 12: Rundungsfunktionen von `Math`. Beachten Sie, wie sich die Dinge bei negativen Zahlen ändern, da „größer“ immer „näher an der positiven Unendlichkeit“ bedeutet.
	`-2.9`	`-2.5`	`-2.1`	`2.1`	`2.5`	`2.9`
`Math.floor`	`-3`	`-3`	`-3`	`2`	`2`	`2`
`Math.ceil`	`-2`	`-2`	`-2`	`3`	`3`	`3`
`Math.round`	`-3`	`-2`	`-2`	`2`	`3`	`3`
`Math.trunc`	`-2`	`-2`	`-2`	`2`	`2`	`2`

17.4 Trigonometrische Funktionen

Alle Winkel werden in Radiant angegeben. Verwenden Sie die folgenden beiden Funktionen, um zwischen Grad und Radiant umzurechnen.

function degreesToRadians(degrees) {
  return degrees / 180 * Math.PI;
}
assert.equal(degreesToRadians(90), Math.PI/2);

function radiansToDegrees(radians) {
  return radians / Math.PI * 180;
}
assert.equal(radiansToDegrees(Math.PI), 180);

Math.acos(x: number): number ^[ES1]

Gibt den Arkuskosinus (Umkehrfunktion des Kosinus) von x zurück.
```
> Math.acos(0)
1.5707963267948966
> Math.acos(1)
0
```
Math.acosh(x: number): number ^[ES6]

Gibt den inversen hyperbolischen Kosinus von x zurück.
Math.asin(x: number): number ^[ES1]

Gibt den Arkussinus (Umkehrfunktion des Sinus) von x zurück.
```
> Math.asin(0)
0
> Math.asin(1)
1.5707963267948966
```
Math.asinh(x: number): number ^[ES6]

Gibt den inversen hyperbolischen Sinus von x zurück.
Math.atan(x: number): number ^[ES1]

Gibt den Arkustangens (Umkehrfunktion des Tangens) von x zurück.
Math.atanh(x: number): number ^[ES6]

Gibt den inversen hyperbolischen Tangens von x zurück.
Math.atan2(y: number, x: number): number ^[ES1]

Gibt den Arkustangens des Quotienten y/x zurück.
Math.cos(x: number): number ^[ES1]

Gibt den Kosinus von x zurück.
```
> Math.cos(0)
1
> Math.cos(Math.PI)
-1
```
Math.cosh(x: number): number ^[ES6]

Gibt den hyperbolischen Kosinus von x zurück.
Math.hypot(...values: number[]): number ^[ES6]

Gibt die Quadratwurzel der Summe der Quadrate von values zurück (Satz des Pythagoras).
```
> Math.hypot(3, 4)
5
```
Math.sin(x: number): number ^[ES1]

Gibt den Sinus von x zurück.
```
> Math.sin(0)
0
> Math.sin(Math.PI / 2)
1
```
Math.sinh(x: number): number ^[ES6]

Gibt den hyperbolischen Sinus von x zurück.
Math.tan(x: number): number ^[ES1]

Gibt den Tangens von x zurück.
```
> Math.tan(0)
0
> Math.tan(1)
1.5574077246549023
```
Math.tanh(x: number); ^[ES6]

Gibt den hyperbolischen Tangens von x zurück.

17.5 Verschiedene andere Funktionen

Math.abs(x: number): number ^[ES1]

Gibt den Absolutwert von x zurück.
```
> Math.abs(3)
3
> Math.abs(-3)
3
> Math.abs(0)
0
```

Math.clz32(x: number): number ^[ES6]

Zählt die führenden Null-Bits in der 32-Bit-Ganzzahl x. Wird in DSP-Algorithmen verwendet.

> Math.clz32(0b01000000000000000000000000000000)
1
> Math.clz32(0b00100000000000000000000000000000)
2
> Math.clz32(2)
30
> Math.clz32(1)
31

Math.max(...values: number[]): number ^[ES1]

Konvertiert values in Zahlen und gibt die größte davon zurück.
```
> Math.max(3, -5, 24)
24
```
Math.min(...values: number[]): number ^[ES1]

Konvertiert values in Zahlen und gibt die kleinste davon zurück.
```
> Math.min(3, -5, 24)
-5
```

Math.random(): number ^[ES1]

Gibt eine Pseudozufallszahl n zurück, wobei 0 ≤ n < 1 gilt.

/** Returns a random integer i with 0 <= i < max */
function getRandomInteger(max) {
  return Math.floor(Math.random() * max);
}

Math.sign(x: number): number ^[ES6]

Gibt das Vorzeichen einer Zahl zurück.
```
> Math.sign(-8)
-1
> Math.sign(0)
0
> Math.sign(3)
1
```