From 4b1a9203c547c019fc5398082ae19a3f3d4c3efe Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 8 Dec 2020 14:41:15 -0500 Subject: initial commit --- .../reference/global_objects/math/acos/index.html | 103 +++++++++++ .../reference/global_objects/math/acosh/index.html | 98 ++++++++++ .../reference/global_objects/math/asin/index.html | 103 +++++++++++ .../reference/global_objects/math/asinh/index.html | 99 ++++++++++ .../reference/global_objects/math/atan/index.html | 105 +++++++++++ .../reference/global_objects/math/atan2/index.html | 113 ++++++++++++ .../reference/global_objects/math/cbrt/index.html | 98 ++++++++++ .../reference/global_objects/math/ceil/index.html | 170 +++++++++++++++++ .../reference/global_objects/math/clz32/index.html | 112 ++++++++++++ .../reference/global_objects/math/cos/index.html | 98 ++++++++++ .../reference/global_objects/math/cosh/index.html | 102 +++++++++++ .../reference/global_objects/math/e/index.html | 83 +++++++++ .../reference/global_objects/math/exp/index.html | 95 ++++++++++ .../reference/global_objects/math/expm1/index.html | 94 ++++++++++ .../reference/global_objects/math/floor/index.html | 137 ++++++++++++++ .../global_objects/math/fround/index.html | 112 ++++++++++++ .../reference/global_objects/math/hypot/index.html | 128 +++++++++++++ .../reference/global_objects/math/imul/index.html | 92 ++++++++++ .../reference/global_objects/math/index.html | 201 +++++++++++++++++++++ .../reference/global_objects/math/ln10/index.html | 83 +++++++++ .../reference/global_objects/math/ln2/index.html | 83 +++++++++ .../reference/global_objects/math/log/index.html | 113 ++++++++++++ .../reference/global_objects/math/log10/index.html | 101 +++++++++++ .../global_objects/math/log10e/index.html | 85 +++++++++ .../reference/global_objects/math/log1p/index.html | 102 +++++++++++ .../reference/global_objects/math/log2/index.html | 101 +++++++++++ .../reference/global_objects/math/log2e/index.html | 83 +++++++++ .../global_objects/math/math.random/index.html | 112 ++++++++++++ .../reference/global_objects/math/max/index.html | 118 ++++++++++++ .../reference/global_objects/math/min/index.html | 112 ++++++++++++ .../reference/global_objects/math/pi/index.html | 81 +++++++++ .../reference/global_objects/math/pow/index.html | 113 ++++++++++++ .../reference/global_objects/math/round/index.html | 99 ++++++++++ .../reference/global_objects/math/sign/index.html | 115 ++++++++++++ .../reference/global_objects/math/sin/index.html | 97 ++++++++++ .../reference/global_objects/math/sinh/index.html | 102 +++++++++++ .../reference/global_objects/math/sqrt/index.html | 99 ++++++++++ .../global_objects/math/sqrt1_2/index.html | 84 +++++++++ .../reference/global_objects/math/sqrt2/index.html | 82 +++++++++ .../reference/global_objects/math/tan/index.html | 102 +++++++++++ .../reference/global_objects/math/tanh/index.html | 93 ++++++++++ .../reference/global_objects/math/trunc/index.html | 125 +++++++++++++ 42 files changed, 4428 insertions(+) create mode 100644 files/de/web/javascript/reference/global_objects/math/acos/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/acosh/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/asin/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/asinh/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/atan/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/atan2/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/cbrt/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/ceil/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/clz32/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/cos/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/cosh/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/e/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/exp/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/expm1/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/floor/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/fround/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/hypot/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/imul/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/ln10/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/ln2/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/log/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/log10/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/log10e/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/log1p/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/log2/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/log2e/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/math.random/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/max/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/min/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/pi/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/pow/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/round/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/sign/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/sin/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/sinh/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/sqrt/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/sqrt1_2/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/sqrt2/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/tan/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/tanh/index.html create mode 100644 files/de/web/javascript/reference/global_objects/math/trunc/index.html (limited to 'files/de/web/javascript/reference/global_objects/math') diff --git a/files/de/web/javascript/reference/global_objects/math/acos/index.html b/files/de/web/javascript/reference/global_objects/math/acos/index.html new file mode 100644 index 0000000000..3512f639b1 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/acos/index.html @@ -0,0 +1,103 @@ +--- +title: Math.acos() +slug: Web/JavaScript/Reference/Global_Objects/Math/acos +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/acos +--- +
{{JSRef}}
+ +

Die Funktion Math.acos() gibt den Arkuskosinus (im Radiantenmaß) einer Zahl zurück:

+ +

∀x∊[-1;1],Math.acos(x)=arccos(x)= das gleiche y∊[0;π]derart, dasscos(y)=x\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.acos}(x)} = \arccos(x) = \text{ das gleiche } \; y \in [0; \pi] \, \text{derart, dass} \; \cos(y)

+ +
{{EmbedInteractiveExample("pages/js/math-acos.html")}}
+ + + +

Syntax

+ +
Math.acos(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl.
+
+ +

Rückgabewert

+ +

Der Arkuskosinus (im Radiantenmaß) der übergebenen Zahl, wenn diese zwischen -1 und 1 ist. Anderfalls wird {{jsxref("NaN")}} zurückgegeben.

+ +

Beschreibung

+ +

Die acos Methode gibt einen numerischen Wert zwischen 0 und {{jsxref("Math/PI", "Pi")}} im Radiantenmaß für x Werte zwischen -1 und 1 zurück.  Wenn der übergebene Wert außerhalb dieses Bereiches liegt, wird {{jsxref("NaN")}} zurückgegeben.

+ +

Weil acos eine statische Methode von Math ist, kann dieses immer mit Math.acos() genutzt werden, ohne dass ein Objekt von Math erstellt werden muss (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Beispiel: Math.acos benutzen

+ +
Math.acos(-2);  // NaN
+Math.acos(-1);  // 3.141592653589793
+Math.acos(0);   // 1.5707963267948966
+Math.acos(0.5); // 1.0471975511965979
+Math.acos(1);   // 0
+Math.acos(2);   // NaN
+
+ +

Für Werte kleiner -1 oder größer 1 gibt Math.acos {{jsxref("Global_Objects/NaN", "NaN")}} zurück.

+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.2', 'Math.acos')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.acos', 'Math.acos')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.acos', 'Math.acos')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.acos")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/acosh/index.html b/files/de/web/javascript/reference/global_objects/math/acosh/index.html new file mode 100644 index 0000000000..46703ec486 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/acosh/index.html @@ -0,0 +1,98 @@ +--- +title: Math.acosh() +slug: Web/JavaScript/Reference/Global_Objects/Math/acosh +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/acosh +--- +
{{JSRef}}
+ +

Die Funktion Math.acosh() gibt den hyperbolischen Arkuskosinus einer Zahl zurück:

+ +

∀x≥1,Math.acosh(x)=arcosh(x)= das Ergebnis y≥0so  dasscosh(y)=x\forall x \geq 1, \mathtt{\operatorname{Math.acosh}(x)} = \operatorname{arcosh}(x) = \text{ the unique } \; y \geq 0 \; \text{such that} \; \cosh(y) = x

+ +
{{EmbedInteractiveExample("pages/js/math-acosh.html")}}
+ + + +

Syntax

+ +
Math.acosh(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl.
+
+ +

Rückgabewert

+ +

Der hyperbolische Arkuskosinus der übergebenen Zahl. Wenn die Zahl kleiner als 1 ist, wird {{jsxref("NaN")}} zurückgegeben.

+ +

Beschreibung

+ +

Weil acosh() eine statische Methode von Math ist, muss diese immer mit Math.acosh() genutzt werden, ohne dass ein Objekt von Math erstellt wird (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Verwendung von Math.acosh()

+ +
Math.acosh(-1); // NaN
+Math.acosh(0);  // NaN
+Math.acosh(0.5) // NaN
+Math.acosh(1);  // 0
+Math.acosh(2);  // 1.3169578969248166
+
+ +

Für Werte kleiner 1 Math.acosh() gibt Math.acosh {{jsxref("NaN")}} zurück.

+ +

Polyfill

+ +

Für x≥1x \geq 1 gilt: arcosh(x)=ln(x+x2-1)\operatorname {arcosh} (x) = \ln \left(x + \sqrt{x^{2} - 1} \right), daher kann dieses mit der folgenden Funktion emuliert werden:

+ +
Math.acosh = Math.acosh || function(x) {
+  return Math.log(x + Math.sqrt(x * x - 1));
+};
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES6', '#sec-math.acosh', 'Math.acosh')}}{{Spec2('ES6')}}Initiale Definition.
{{SpecName('ESDraft', '#sec-math.acosh', 'Math.acosh')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.acosh")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/asin/index.html b/files/de/web/javascript/reference/global_objects/math/asin/index.html new file mode 100644 index 0000000000..bf69f52450 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/asin/index.html @@ -0,0 +1,103 @@ +--- +title: Math.asin() +slug: Web/JavaScript/Reference/Global_Objects/Math/asin +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/asin +--- +
{{JSRef}}
+ +

Die Funktion Math.asin() gibt den Arkussinus (im Radiantenmaß) einer Zahl zurück:

+ +

∀x∊[-1;1],Math.asin(x)=arcsin(x)= das Ergebnis y∊[-π2;π2]so  dasssin(y)=x\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.asin}(x)} = \arcsin(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \sin(y) = x

+ +
{{EmbedInteractiveExample("pages/js/math-asin.html")}}
+ + + +

Syntax

+ +
Math.asin(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl.
+
+ +

Rückgabewert

+ +

Der Arkussinus (im Radiantenmaß) der übergebenen Zahl, die zwischen -1 und 1 liegt. Andernfalls wird {{jsxref("NaN")}} zurückgegeben.

+ +

Beschreibung

+ +

Die Math.asin() Methode gibt einen numerischen Wert zwischen -π2-\frac{\pi}{2} und π2\frac{\pi}{2} im Radiantenmaß für x Werte zwischen -1 und 1 zurück. Wenn der übergebene Wert außerhalb dieses Bereiches liegt, wird {{jsxref("NaN")}} zurückgegeben.

+ +

Weil asin() eine statische Methode von Math ist, muss diese immer mit Math.asin() genutzt werden, ohne dass ein Objekt von Math erstellt wird (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Verwendung von Math.asin()

+ +
Math.asin(-2);  // NaN
+Math.asin(-1);  // -1.5707963267948966 (-pi/2)
+Math.asin(0);   // 0
+Math.asin(0.5); // 0.5235987755982989
+Math.asin(1);   // 1.5707963267948966 (pi/2)
+Math.asin(2);   // NaN
+
+ +

Für Werte kleiner -1 oder größer als 1 gibt Math.asin() {{jsxref("NaN")}} zurück.

+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.3', 'Math.asin')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.asin', 'Math.asin')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.asin', 'Math.asin')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.asin")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/asinh/index.html b/files/de/web/javascript/reference/global_objects/math/asinh/index.html new file mode 100644 index 0000000000..fa5e1d0472 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/asinh/index.html @@ -0,0 +1,99 @@ +--- +title: Math.asinh() +slug: Web/JavaScript/Reference/Global_Objects/Math/asinh +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/asinh +--- +
{{JSRef}}
+ +

Die Funktion Math.asinh() gibt den hyperbolische Arkussinus (im Radiantenmaß) einer Zahl zurück:

+ +

Math.asinh(x)=arcsinh(x)= das Ergebnis yso  dasssinh(y)=x\mathtt{\operatorname{Math.asinh}(x)} = \operatorname{arsinh}(x) = \text{ the unique } \; y \; \text{such that} \; \sinh(y) = x

+ +
{{EmbedInteractiveExample("pages/js/math-asinh.html")}}
+ + + +

Syntax

+ +
Math.asinh(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl.
+
+ +

Rückgabewert

+ +

Der hyperbolische Arkussinus der übergebenen Zahl.

+ +

Beschreibung

+ +

Weil asinh() eine statische Methode von Math ist, muss diese immer mit Math.asinh() genutzt werden, ohne dass ein Objekt von Math erstellt wird (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Verwendung von Math.asinh()

+ +
Math.asinh(1);  // 0.881373587019543
+Math.asinh(0);  // 0
+
+ +

Polyfill

+ +

Es gilt: arsinh(x)=ln(x+x2+1). Daher kann asinh mit der folgenden Funktion emuliert werden:

+ +
Math.asinh = Math.asinh || function(x) {
+  if (x === -Infinity) {
+    return x;
+  } else {
+    return Math.log(x + Math.sqrt(x * x + 1));
+  }
+};
+
+ +

Die formale Korrektheit hängt von einer Reihe von Problemen mit Floating-Point-Berechnungen ab. Genaue Ergebnisse erfordern die Behandlung von positiven/negativen, kleinen/großen Argumenten, wie es in glibc oder GNU Scientific Library vorhanden ist.

+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES6', '#sec-math.asinh', 'Math.asinh')}}{{Spec2('ES6')}}Initiale Definition.
{{SpecName('ESDraft', '#sec-math.asinh', 'Math.asinh')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.asinh")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/atan/index.html b/files/de/web/javascript/reference/global_objects/math/atan/index.html new file mode 100644 index 0000000000..1c37c3dcc4 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/atan/index.html @@ -0,0 +1,105 @@ +--- +title: Math.atan() +slug: Web/JavaScript/Reference/Global_Objects/Math/atan +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan +--- +
{{JSRef}}
+ +

Die Funktion Math.atan() gibt den Arkustangens (im Radiantenmaß) einer Zahl zurück:

+ +

Math.atan(x)=arctan(x)= das Ergebnis y∊[-π2;π2]so  dasstan(y)=x\mathtt{\operatorname{Math.atan}(x)} = \arctan(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \tan(y) = x

+ +
{{EmbedInteractiveExample("pages/js/math-atan.html")}}
+ + + +

Syntax

+ +
Math.atan(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl.
+
+ +

Rückgabewert

+ +

Der Arkustangens (im Radiantenmaß) der übergebenen Zahl.

+ +

Beschreibung

+ +

Die Math.atan() Methode gibt einen numerischen Wert zwischen -π2-\frac{\pi}{2} und π2\frac{\pi}{2} im Radiantenmaß zurück.

+ +

Weil atan() eine statische Methode von Math ist, muss diese immer mit Math.atan() genutzt werden, ohne dass ein Objekt von Math erstellt wird (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Verwendung von Math.atan()

+ +
Math.atan(1);   // 0.7853981633974483
+Math.atan(0);   // 0
+Math.atan(-0);  // -0
+
+Math.atan(Infinity);   //  1.5707963267948966
+Math.atan(-Infinity);  // -1.5707963267948966
+
+// The angle that the line [(0,0);(x,y)] forms with the x-axis in a Cartesian coordinate system
+Math.atan(y / x);
+ +

Beachten Sie, dass es manchmal aus stilistischen Gründen gewollt ist, dass ±Infinity vermieden werden soll. In diesen Fällen kann die Funktion {{jsxref("Math.atan2()")}} mit 0 als zweiten Parameter bessere Ergebnisse liefern.

+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.4', 'Math.atan')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.atan', 'Math.atan')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.atan', 'Math.atan')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.atan")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/atan2/index.html b/files/de/web/javascript/reference/global_objects/math/atan2/index.html new file mode 100644 index 0000000000..5848a76898 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/atan2/index.html @@ -0,0 +1,113 @@ +--- +title: Math.atan2() +slug: Web/JavaScript/Reference/Global_Objects/Math/atan2 +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan2 +--- +
{{JSRef}}
+ +

Die Funktion Math.atan2() gibt den Arkustangens (im Radiantenmaß) des Quotienten der Parameter zurück.

+ +
{{EmbedInteractiveExample("pages/js/math-atan2.html")}}
+ + + +

Syntax

+ +
Math.atan2(y, x)
+ +

Parameter

+ +
+
y
+
Eine Zahl.
+
x
+
Eine zweite Zahl.
+
+ +

Rückgabewert

+ +

Der Arkustangens des Quotienten der übergebenen Parameter.

+ +

Beschreibung

+ +

Die Math.atan2() Methode gibt einen numerischen Wert zwischen -π und π zurück, welcher den Winkel Theta eines (x, y) Punktes wiedergibt. Dies ist der Radius entgegen dem Uhrzeigersinn, gemessen in Radianten, zwischen der positiven x Achse, und des Punktes (x, y). Beachte, dass bei der Funktion der erste Parameter die y Koordinate und der zweite die x Koordinate ist.

+ +

Ein einfaches Diagramm welches den zurückgegebenen Winkel von atan2(y, x) zeigt

+ +

Bei Math.atan2() wird x und y separat übergeben, bei Math.atan() hingegen wird das Verhältnis der zwei Parameter übergeben.

+ +

Weil atan2() eine statische Methode von Math ist, muss diese immer mit Math.atan2() genutzt werden, ohne dass ein Objekt von Math erstellt wird (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Verwendung von Math.atan2()

+ +
Math.atan2(90, 15); // 1.4056476493802699
+Math.atan2(15, 90); // 0.16514867741462683
+
+Math.atan2(±0, -0);               // ±PI.
+Math.atan2(±0, +0);               // ±0.
+Math.atan2(±0, -x);               // ±PI for x > 0.
+Math.atan2(±0, x);                // ±0 for x > 0.
+Math.atan2(-y, ±0);               // -PI/2 for y > 0.
+Math.atan2(y, ±0);                // PI/2 for y > 0.
+Math.atan2(±y, -Infinity);        // ±PI for finite y > 0.
+Math.atan2(±y, +Infinity);        // ±0 for finite y > 0.
+Math.atan2(±Infinity, x);         // ±PI/2 for finite x.
+Math.atan2(±Infinity, -Infinity); // ±3*PI/4.
+Math.atan2(±Infinity, +Infinity); // ±PI/4.
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.5', 'Math.atan2')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.atan2', 'Math.atan2')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.atan2', 'Math.atan2')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.atan2")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/cbrt/index.html b/files/de/web/javascript/reference/global_objects/math/cbrt/index.html new file mode 100644 index 0000000000..a24c572eb7 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/cbrt/index.html @@ -0,0 +1,98 @@ +--- +title: Math.cbrt() +slug: Web/JavaScript/Reference/Global_Objects/Math/cbrt +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/cbrt +--- +
{{JSRef}}
+ +

Die Funktion Math.cbrt() gibt die Kubikwurzel einer Zahl zurück:

+ +

Math.cbrt(x)=x3=das  Ergebnisyso  dassy3=x\mathtt{Math.cbrt(x)} = \sqrt[3]{x} = \text{the unique} \; y \; \text{such that} \; y^3 = x

+ +
{{EmbedInteractiveExample("pages/js/math-cbrt.html")}}
+ + + +

Syntax

+ +
Math.cbrt(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl.
+
+ +

Rückgabewert

+ +

Die Kubikwurzel der übergebenen Zahl.

+ +

Beschreibung

+ +

Weil cbrt() eine statische Methode von Math ist, muss diese immer mit Math.cbrt() genutzt werden, ohne dass ein Objekt von Math erstellt wird (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Verwendung von Math.cbrt()

+ +
Math.cbrt(NaN); // NaN
+Math.cbrt(-1); // -1
+Math.cbrt(-0); // -0
+Math.cbrt(-Infinity); // -Infinity
+Math.cbrt(0); // 0
+Math.cbrt(1); // 1
+Math.cbrt(Infinity); // Infinity
+Math.cbrt(null); // 0
+Math.cbrt(2);  // 1.2599210498948734
+ +

Polyfill

+ +

Für x≥0x \geq 0 gilt x3=x1/3\sqrt[3]{x} = x^{1/3} so dass diese Funktion wie folgt emuliert werden kann:

+ +
if (!Math.cbrt) {
+  Math.cbrt = function(x) {
+    var y = Math.pow(Math.abs(x), 1/3);
+    return x < 0 ? -y : y;
+  };
+}
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES6', '#sec-math.cbrt', 'Math.cbrt')}}{{Spec2('ES6')}}Initiale Definition.
{{SpecName('ESDraft', '#sec-math.cbrt', 'Math.cbrt')}}{{Spec2('ESDraft')}}
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.cbrt")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/ceil/index.html b/files/de/web/javascript/reference/global_objects/math/ceil/index.html new file mode 100644 index 0000000000..06cf4808e7 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/ceil/index.html @@ -0,0 +1,170 @@ +--- +title: Math.ceil() +slug: Web/JavaScript/Reference/Global_Objects/Math/ceil +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/ceil +--- +
{{JSRef}}
+ +

Die Funktion Math.ceil() gibt die nächste Ganzzahl, die größer oder gleich der gegebenen Zahl ist, zurück.

+ +
{{EmbedInteractiveExample("pages/js/math-ceil.html")}}
+ + + +

Syntax

+ +
Math.ceil(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl.
+
+ +

Rückgabewert

+ +

Die kleinste ganze Zahl größer oder gleich der übergebenen Zahl.

+ +

Beschreibung

+ +

Weil ceil() eine statische Methode von Math ist, muss diese immer mit Math.ceil() genutzt werden, ohne dass ein Objekt von Math erstellt wird (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Verwendung von Math.ceil()

+ +

Das folgende Beispiel zeigt den exemplarischen Einsatz von Math.ceil().

+ +
Math.ceil(.95);    // 1
+Math.ceil(4);      // 4
+Math.ceil(7.004);  // 8
+Math.ceil(-0.95);  // -0
+Math.ceil(-4);     // -4
+Math.ceil(-7.004); // -7
+
+ +

Dezimales anpassen

+ +
// Closure
+(function() {
+  /**
+   * Decimal adjustment of a number.
+   *
+   * @param {String}  type  The type of adjustment.
+   * @param {Number}  value The number.
+   * @param {Integer} exp   The exponent (the 10 logarithm of the adjustment base).
+   * @returns {Number} The adjusted value.
+   */
+  function decimalAdjust(type, value, exp) {
+    // If the exp is undefined or zero...
+    if (typeof exp === 'undefined' || +exp === 0) {
+      return Math[type](value);
+    }
+    value = +value;
+    exp = +exp;
+    // If the value is not a number or the exp is not an integer...
+    if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
+      return NaN;
+    }
+    // Shift
+    value = value.toString().split('e');
+    value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp)));
+    // Shift back
+    value = value.toString().split('e');
+    return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp));
+  }
+
+  // Decimal round
+  if (!Math.round10) {
+    Math.round10 = function(value, exp) {
+      return decimalAdjust('round', value, exp);
+    };
+  }
+  // Decimal floor
+  if (!Math.floor10) {
+    Math.floor10 = function(value, exp) {
+      return decimalAdjust('floor', value, exp);
+    };
+  }
+  // Decimal ceil
+  if (!Math.ceil10) {
+    Math.ceil10 = function(value, exp) {
+      return decimalAdjust('ceil', value, exp);
+    };
+  }
+})();
+
+// Round
+Math.round10(55.55, -1);   // 55.6
+Math.round10(55.549, -1);  // 55.5
+Math.round10(55, 1);       // 60
+Math.round10(54.9, 1);     // 50
+Math.round10(-55.55, -1);  // -55.5
+Math.round10(-55.551, -1); // -55.6
+Math.round10(-55, 1);      // -50
+Math.round10(-55.1, 1);    // -60
+// Floor
+Math.floor10(55.59, -1);   // 55.5
+Math.floor10(59, 1);       // 50
+Math.floor10(-55.51, -1);  // -55.6
+Math.floor10(-51, 1);      // -60
+// Ceil
+Math.ceil10(55.51, -1);    // 55.6
+Math.ceil10(51, 1);        // 60
+Math.ceil10(-55.59, -1);   // -55.5
+Math.ceil10(-59, 1);       // -50
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
ECMAScript 1st Edition.StandardInitiale Definition. Implementiert in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.6', 'Math.ceil')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.ceil', 'Math.ceil')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.ceil', 'Math.ceil')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.ceil")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/clz32/index.html b/files/de/web/javascript/reference/global_objects/math/clz32/index.html new file mode 100644 index 0000000000..ac7c78c4a7 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/clz32/index.html @@ -0,0 +1,112 @@ +--- +title: Math.clz32() +slug: Web/JavaScript/Reference/Global_Objects/Math/clz32 +tags: + - ECMAScript 2015 + - Java + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/clz32 +--- +
{{JSRef}}
+ +

Die Math.clz32() Funktion zählt die führenden Nullbits in der 32-Bit binär Repräsentation einer Nummer.

+ +
{{EmbedInteractiveExample("pages/js/math-clz32.html")}}
+ + + +

Syntax

+ +
Math.clz32(x)
+ +

Parameter

+ +
+
x
+
Eine Nummer.
+
+ +

Rückgabewert

+ +

Die Anzahl der führenden Nullbits in der 32-Bit binör Repräsentation der übergebenen Zahl.

+ +

Beschreibung

+ +

"clz32" steht für CountLeadingZeroes32 (AnzahlFührenderNullen32).

+ +

Wenn x keine Nummer ist, wird x in eine Nummer konvertiert. Danach wird diese Nummer in einen 32-Bit vorzeichenlose Ganzzahl (unsigned integer) konvertiert.

+ +

Wenn die konvertierte 32-Bit vorzeichenlose Zahl 0 ist, so wird die Funktion 32 zurück geben, weil alle Bits 0 sind.

+ +

Diese Funktion ist nützlich für Systeme, die in zu JavaScript kompilieren (z. B. Emscripten).

+ +

Beispiele

+ +

Einsatz von Math.clz32()

+ +
Math.clz32(1);                // 31
+Math.clz32(1000);             // 22
+Math.clz32();                 // 32
+
+[NaN, Infinity, -Infinity, 0, -0, null, undefined, 'foo', {}, []].filter(
+function(n) {
+  return Math.clz32(n) !== 32
+});                           // []
+
+Math.clz32(true);             // 31
+Math.clz32(3.5);              // 30
+
+ +

Polyfill

+ +

Der folgende Polyfill ist der effizienteste.

+ +
if (!Math.clz32) {
+  Math.clz32 = function(x) {
+    // Let n be ToUint32(x).
+    // Let p be the number of leading zero bits in 
+    // the 32-bit binary representation of n.
+    // Return p.    
+    if (x == null || x === 0) {
+      return 32;
+    }
+    return 31 - Math.floor(Math.log(x >>> 0) * Math.LOG2E);
+  };
+}
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES2015', '#sec-math.clz32', 'Math.clz32')}}{{Spec2('ES2015')}}Initiale Definition.
{{SpecName('ESDraft', '#sec-math.clz32', 'Math.clz32')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.clz32")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/cos/index.html b/files/de/web/javascript/reference/global_objects/math/cos/index.html new file mode 100644 index 0000000000..300908a90b --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/cos/index.html @@ -0,0 +1,98 @@ +--- +title: Math.cos() +slug: Web/JavaScript/Reference/Global_Objects/Math/cos +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/cos +--- +
{{JSRef}}
+ +

Die Math.cos() Funktion gibt den {{interwiki("wikipedia", "Cosinus")}} eines Winkels zurück. Der Winkel muss im {{interwiki("wikipedia", "Bogenmaß")}} angegeben werden. Der Wert ist  length adjacent length hypotenuse .

+ +
{{EmbedInteractiveExample("pages/js/math-cos.html")}}
+ + + +

Syntax

+ +
Math.cos(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl im Winkelmaß (rad).
+
+ +

Rückgabewert

+ +

Der Cosinus der übergebenen Zahl.

+ +

Beschreibung

+ +

Die Math.cos() Funktion gibt einen nummerischen Wert zwischen -1 und 1 zurück. Dieser repräsentiert den Cosinus des Winkels.

+ +

Weil cos() eine statische Funktion von Math ist, wird es immer als Math.cos() eingesetzt, jedoch nicht als Methode eines erzeugten Math Objektes (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Einsatz von Math.cos()

+ +
Math.cos(0);           // 1
+Math.cos(1);           // 0.5403023058681398
+
+Math.cos(Math.PI);     // -1
+Math.cos(2 * Math.PI); // 1
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationenStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.7', 'Math.cos')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.cos', 'Math.cos')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.cos', 'Math.cos')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.cos")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/cosh/index.html b/files/de/web/javascript/reference/global_objects/math/cosh/index.html new file mode 100644 index 0000000000..9b24cbbeaf --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/cosh/index.html @@ -0,0 +1,102 @@ +--- +title: Math.cosh() +slug: Web/JavaScript/Reference/Global_Objects/Math/cosh +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/cosh +--- +
{{JSRef}}
+ +

Die Math.cosh() Funktion gibt den Cosinus Hyperbolicus einer Zahl zurück. Dieser kann mit dem Einsatz der {{jsxref("Math.E", "Eulerschen Zahl", "", 1)}} folgendermaßen berechnet werden:

+ +

Math.cosh(x)=ex+e-x2\mathtt{\operatorname{Math.cosh(x)}} = \frac{e^x + e^{-x}}{2}

+ +
{{EmbedInteractiveExample("pages/js/math-cosh.html")}}
+ + + +

Syntax

+ +
Math.cosh(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl.
+
+ +

Rückgabewert

+ +

Der hyperbolische Cosinus der übergebenen Zahl.

+ +

Beschreibung

+ +

Weil cosh() eine statische Funktion von Math ist, wird es immer als Math.cosh() eingesetzt, jedoch nicht als Methode eines erzeugten Math Objektes (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Einsatz von Math.cosh()

+ +
Math.cosh(0);  // 1
+Math.cosh(1);  // 1.5430806348152437
+Math.cosh(-1); // 1.5430806348152437
+
+ +

Polyfill

+ +

Diese Funktion kann mit Hilfe der Funktion {{jsxref("Math.exp()")}} emuliert werden:

+ +
Math.cosh = Math.cosh || function(x) {
+  return (Math.exp(x) + Math.exp(-x)) / 2;
+}
+
+ +

Oder nur mit einem Aufruf der {{jsxref("Math.exp()")}} Funktion:

+ +
Math.cosh = Math.cosh || function(x) {
+  var y = Math.exp(x);
+  return (y + 1 / y) / 2;
+};
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES6', '#sec-math.cosh', 'Math.cosh')}}{{Spec2('ES6')}}Initiale Definition.
{{SpecName('ESDraft', '#sec-math.cosh', 'Math.cosh')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.cosh")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/e/index.html b/files/de/web/javascript/reference/global_objects/math/e/index.html new file mode 100644 index 0000000000..1ba5bd74d5 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/e/index.html @@ -0,0 +1,83 @@ +--- +title: Math.E +slug: Web/JavaScript/Reference/Global_Objects/Math/E +tags: + - JavaScript + - Math + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/E +--- +
{{JSRef}}
+ +

Die Math.E Eigenschaft repräsentiert die Basis des natürlichen Logarithmus, was gerundet 2,718 ist.

+ +

Math.E=e≈2,718\mathtt{\mi{Math.E}} = e \approx 2,718

+ +
{{EmbedInteractiveExample("pages/js/math-e.html")}}
+ + + +
{{js_property_attributes(0,0,0)}}
+ +

Beschreibung

+ +

Weil E eine statische Eigenschaft von Math ist, muss immer Math.E genutzt werden, ohne dass ein Math Objekt erstellt wird (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Einsatz von Math.E

+ +

Die folgende Funktion gibt e zurück:

+ +
function getNapier() {
+   return Math.E
+}
+
+getNapier() // 2.718281828459045
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition.
{{SpecName('ES5.1', '#sec-15.8.1.1', 'Math.E')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.e', 'Math.E')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.e', 'Math.E')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.E")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/exp/index.html b/files/de/web/javascript/reference/global_objects/math/exp/index.html new file mode 100644 index 0000000000..df215203d8 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/exp/index.html @@ -0,0 +1,95 @@ +--- +title: Math.exp() +slug: Web/JavaScript/Reference/Global_Objects/Math/exp +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/exp +--- +
{{JSRef}}
+ +

Die Math.exp() Funktion gibt ex zurück, wobei x der Parameter ist. e ist die {{jsxref("Math.E", "Eulersche Zahl", "", 1)}}, die Basis des natürlichen Logarithmus.

+ +
{{EmbedInteractiveExample("pages/js/math-exp.html")}}
+ + + +

Syntax

+ +
Math.exp(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl.
+
+ +

Rückgabewert

+ +

Die Zahl, die ex repräsentiert, wobei e die {{jsxref("Math.E", "Eulersche Zahl", "", 1)}} ist und x die übergebene Zahl ist.

+ +

Beschreibung

+ +

Weil exp() eine statische Funktion von Math ist, wird es immer als Math.exp() eingesetzt, jedoch nicht als Methode eines erzeugten Math Objektes (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Einsatz von Math.exp()

+ +
Math.exp(-1); // 0.36787944117144233
+Math.exp(0);  // 1
+Math.exp(1);  // 2.718281828459045
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusComment
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.8', 'Math.exp')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.exp', 'Math.exp')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.exp', 'Math.exp')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.exp")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/expm1/index.html b/files/de/web/javascript/reference/global_objects/math/expm1/index.html new file mode 100644 index 0000000000..b257953d87 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/expm1/index.html @@ -0,0 +1,94 @@ +--- +title: Math.expm1() +slug: Web/JavaScript/Reference/Global_Objects/Math/expm1 +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/expm1 +--- +
{{JSRef}}
+ +

Die Math.expm1() Funktion gibt ex - 1 zurück, wobei x der Parameter ist. e ist die {{jsxref("Math.E", "Eulersche Zahl", "", 1)}}, die Basis des natürlichen Logarithmus.

+ +
{{EmbedInteractiveExample("pages/js/math-expm1.html")}}
+ + + +

Syntax

+ +
Math.expm1(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl.
+
+ +

Rückgabewert

+ +

Die Zahl, die ex - 1 repräsentiert, wobei e die {{jsxref("Math.E", "Eulersche Zahl", "", 1)}} und x die übergebene Zahl ist.

+ +

Beschreibung

+ +

Weil expm1() eine statische Funktion von Math ist, wird es immer als Math.expm1() eingesetzt, jedoch nicht als Methode eines erzeugten Math Objektes (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Einsatz von Math.expm1()

+ +
Math.expm1(-1); // -0.6321205588285577
+Math.expm1(0);  // 0
+Math.expm1(1);  // 1.718281828459045
+
+ +

Polyfill

+ +

Diese Funktion kann mit Hilfe der Funktion {{jsxref("Math.exp()")}} emitiert werden:

+ +
Math.expm1 = Math.expm1 || function(x) {
+  return Math.exp(x) - 1;
+};
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusComment
{{SpecName('ES6', '#sec-math.expm1', 'Math.expm1')}}{{Spec2('ES6')}}Initiale Definition.
{{SpecName('ESDraft', '#sec-math.expm1', 'Math.expm1')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.expm1")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/floor/index.html b/files/de/web/javascript/reference/global_objects/math/floor/index.html new file mode 100644 index 0000000000..68f8bf86fa --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/floor/index.html @@ -0,0 +1,137 @@ +--- +title: Math.floor() +slug: Web/JavaScript/Reference/Global_Objects/Math/floor +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/floor +--- +
{{JSRef}}
+ +

Die Math.floor() Funktion gibt den größten Integer zurück, der kleiner oder gleich der gegeben Nummer ist. (Abrunden) 

+ +
{{EmbedInteractiveExample("pages/js/math-floor.html")}}
+ + + +

Syntax

+ +
Math.floor(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl.
+
+ +

Rückgabewert

+ +

Eine größte ganze Zahl, die kleiner oder gleich der übergebenen Zahl ist.

+ +

Beschreibung

+ +

Weil floor() eine statische Methode von Math ist, wird sie immer als Math.floor() aufgerufen und nicht als eine Methode eines erstellten Math Objektes (Math ist kein Konstruktor).

+ +
+

Hinweis: Math.floor(null) gibt 0, aber nicht {{jsxref("NaN")}}, zurück.

+
+ +

Beispiele

+ +

Einsatz von Math.floor()

+ +
Math.floor(45.95);   // 45
+Math.floor(45.05);   // 45
+Math.floor(4);       // 4
+Math.floor(-45.05);  // -46
+Math.floor(-45.95);  // -46
+
+ +

Dezimale Justierung

+ +
/**
+ * Decimal adjustment of a number.
+ *
+ * @param {String}  type  The type of adjustment.
+ * @param {Number}  value The number.
+ * @param {Integer} exp   The exponent (the 10 logarithm of the adjustment base).
+ * @returns {Number} The adjusted value.
+ */
+function decimalAdjust(type, value, exp) {
+  // If the exp is undefined or zero...
+  if (typeof exp === 'undefined' || +exp === 0) {
+    return Math[type](value);
+  }
+  value = +value;
+  exp = +exp;
+  // If the value is not a number or the exp is not an integer...
+  if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
+    return NaN;
+  }
+  // Shift
+  value = value.toString().split('e');
+  value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp)));
+  // Shift back
+  value = value.toString().split('e');
+  return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp));
+}
+
+// Decimal round
+const round10 = (value, exp) => decimalAdjust('round', value, exp);
+// Decimal floor
+const floor10 = (value, exp) => decimalAdjust('floor', value, exp);
+// Decimal ceil
+const ceil10 = (value, exp) => decimalAdjust('ceil', value, exp);
+
+// Round
+round10(55.55, -1);   // 55.6
+round10(55.549, -1);  // 55.5
+round10(55, 1);       // 60
+round10(54.9, 1);     // 50
+round10(-55.55, -1);  // -55.5
+round10(-55.551, -1); // -55.6
+round10(-55, 1);      // -50
+round10(-55.1, 1);    // -60
+// Floor
+floor10(55.59, -1);   // 55.5
+floor10(59, 1);       // 50
+floor10(-55.51, -1);  // -55.6
+floor10(-51, 1);      // -60
+// Ceil
+ceil10(55.51, -1);    // 55.6
+ceil10(51, 1);        // 60
+ceil10(-55.59, -1);   // -55.5
+ceil10(-59, 1);       // -50
+
+ +

Spezifikationen

+ + + + + + + + + + +
Spezifikation
{{SpecName('ESDraft', '#sec-math.floor', 'Math.floor')}}
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.floor")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/fround/index.html b/files/de/web/javascript/reference/global_objects/math/fround/index.html new file mode 100644 index 0000000000..de905d6637 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/fround/index.html @@ -0,0 +1,112 @@ +--- +title: Math.fround() +slug: Web/JavaScript/Reference/Global_Objects/Math/fround +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/fround +--- +
{{JSRef}}
+ +

Die Math.fround() Funktion gibt die am nächsten gelegenen 32 Bit einfach genaue Repräsentation einer {{jsxref("Number")}}.

+ +
{{EmbedInteractiveExample("pages/js/math-fround.html")}}
+ + + +

Syntax

+ +
var singleFloat = Math.fround(doubleFloat)
+ +

Parameter

+ +
+
doubleFloat
+
Eine {{jsxref("Number")}}. Wenn der Parameter von einem anderen Typ ist, wird dieser zu einer Zahl konvertiert oder wenn er nicht konvertiert werden kann {{jsxref("NaN")}}.
+
+ +

Rückgabewert

+ +

Die am nächsten gelegenen 32 Bit einfach genaue Repräsentation einer Floatingpoint-Nummer, der übergebenen Zahl.

+ +

Beschreibung

+ +

JavaScript benutzt intern 64 Bit double Gleitkommazahlen, welche eine hohe Präzision haben. Manchmal ist es gewollt mit 32 Bit Gleitkommazahlen zu arbeiten, zum Beispiel, wenn von einem von einem {{jsxref("Float32Array")}} gelesen wird. Das kann verwirrend sein: Prüfen einer 64 Bit Gleitkommazahl und einer 32 Bit Gleitkommazahl auf Gleichheit kann fehlschlagen, auch wenn sie scheinbar identisch sind.

+ +

Um das zu beheben, kann Math.fround() eingesetzt werden um 64 Bit Gleitkommazahlen in 32 Bit Gleitkommazahlen umzuwandeln. Intern wird JavaScript die Zahl als 64 Bit Gleitkommazahl benutzen, es wird jedoch ein "Runden zu geraden Zahlen" (round to even) an der 23. Stelle der Mantisse vorgenommen und alle folgenden Stellen der Mantisse auf 0 gesetzt. Wenn die Zahl außerhalb des 32 Bit Gleitkommazahlenbereiches liegt wird {{jsxref("Infinity")}} oder -Infinity zurückgegeben.

+ +

Weil fround() eine statische Funktion von Math ist, wird es immer als Math.fround() eingesetzt, jedoch nicht als Methode eines erzeugten Math Objektes (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Einsatz von Math.fround()

+ +

Die Zahl 1-5 kan präzise im Binärsystem dargestellt werden und ist identisch in 32 Bit und 64 Bit:

+ +
Math.fround(1.5);        // 1.5
+Math.fround(1.5) === 1.5 // true
+ +

Die Zahl 1.337 kan nicht präzise in Binärsystem dargestellt werden und unterscheidet sich in 32 Bit und 64 Bit:

+ +
Math.fround(1.337);           //1.3370000123977661
+Math.fround(1.337) === 1.337; // false
+
+ +

21502^150 ist zu groß für eine 32 Bit Gleitkommazahl, weshalb Infinity zurückgegeben wird.

+ +
2 ** 150;              // 1.42724769270596e+45
+Math.fround(2 ** 150); // Infinity
+
+ +

Wenn der Parameter nicht zu einer Zahl konvertiert werden kann, oder keine Zahl ist (NaN), gibt Math.fround() NaN zurück:

+ +
Math.fround('abc'); // NaN
+Math.fround(NaN);   // NaN
+
+ +

Polyfill

+ +

Diese Funktion kann emuliert werden, wenn {{jsxref("Float32Array")}} verfügbar ist:

+ +
Math.fround = Math.fround || (function (array) {
+  return function(x) {
+    return array[0] = x, array[0];
+  };
+})(Float32Array(1));
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES6', '#sec-math.fround', 'Math.fround')}}{{Spec2('ES6')}}Initiale Definition.
{{SpecName('ESDraft', '#sec-math.fround', 'Math.fround')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.fround")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/hypot/index.html b/files/de/web/javascript/reference/global_objects/math/hypot/index.html new file mode 100644 index 0000000000..b88861e06d --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/hypot/index.html @@ -0,0 +1,128 @@ +--- +title: Math.hypot() +slug: Web/JavaScript/Reference/Global_Objects/Math/hypot +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/hypot +--- +
{{JSRef}}
+ +

Die Math.hypot() Funktion gibt die Quadratwurzel von der Summe der quadrierten Argumente zurück. Das bedeutet

+ +

Math.hypot(v1,v2,…,vn)=∑i=1nvi2=v12+v22+…+vn2\mathtt{\operatorname{Math.hypot}(v_1, v_2, \dots, v_n)} = \sqrt{\sum_{i=1}^n v_i^2} = \sqrt{v_1^2 + v_2^2 + \dots + v_n^2}

+ +
{{EmbedInteractiveExample("pages/js/math-hypot.html")}}
+ + + +

Syntax

+ +
Math.hypot([value1[, value2[, ...]]])
+ +

Parameter

+ +
+
value1, value2, ...
+
Zahlen.
+
+ +

Rückgabewert

+ +

Die Quadratwurzel der Summe der quadrierten übergebenen Parameter. Wenn ein Parameter nicht in eine Zahl konvertiert werden kann, wird {{jsxref("NaN")}} zurückgegeben.

+ +

Beschreibung

+ +

Das Berechnen der Hypotenuse eines rechtwinkligen Dreiecks oder die Größe einer komplexen Zahl verwendet die Formel Math.sqrt (v1 * v1 + v2 * v2), wobei v1 und v2 entweder die Seiten des Dreiecks oder die reellen und komplexen Werte sind. Zum Berechnen der Entfernung in 2 oder mehr Dimensionen fügt man einfach weitere Quadrate innerhalb des Quadratwurzelzeichens ein, wie z. B. Math.sqrt (v1 * v1 + v2 * v2 + v3 * v3 + v4 * v4).

+ +

Diese Funktion macht es ein bisschen einfacher und schneller, man kann einfach Math.hypot(v1, v2) , or Math.hypot(v1, v2, v3, v4, ...) aufrufen.

+ +

Sie vermeidet zudem ein Problem, wenn Zahlen sehr groß werden. Die größte Zahl, die in JavaScript dargestellt werden kann ist Number.MAX_VALUE = 1.797...e+308. Wenn die Zahlen größer als 1e154 sind, wird das Quadrieren dieser zu dem ergebnis Infinity führen und das Ergebnis zerstören. Zum Beispiel: Math.sqrt(1e200*1e200 + 1e200*1e200) = Infinity. Wenn hypot() stattdessen benutzt wird bekommt man ein gutes Ergebnis: Math.hypot(1e200, 1e200) = 1.4142...e+200. Diese gilt auch für sehr kleine Zahlen. Math.sqrt(1e-200*1e-200 + 1e-200*1e-200) = 0, wohingegen Math.hypot(1e-200, 1e-200) =1.4142...e-200 eine gute Lösung ist.

+ +

Weil hypot() eine statische Funktion von Math ist, wird es immer als Math.hypot() eingesetzt, jedoch nicht als Methode eines erzeugten Math Objektes (Math ist kein Konstruktor).

+ +

Wenn kein Argument übergeben wird, ist das Ergebnis +0.

+ +

Wenn einer der übergebenen Parameter nicht zu einer Zahl konvertiert werden kann, ist das Ergebnis {{jsxref("NaN")}}.

+ +

Wenn nur ein Argument übergeben wird, so sind die Ergebnisse der Funktionen Math.hypot() und {{jsxref("Math.abs()")}} gleich.

+ +

Beispiele

+ +

Einsatz von Math.hypot()

+ +
Math.hypot(3, 4);        // 5
+Math.hypot(3, 4, 5);     // 7.0710678118654755
+Math.hypot();            // 0
+Math.hypot(NaN);         // NaN
+Math.hypot(3, 4, 'foo'); // NaN, +'foo' => NaN
+Math.hypot(3, 4, '5');   // 7.0710678118654755, +'5' => 5
+Math.hypot(-3);          // 3, das gleiche wie Math.abs(-3)
+
+ +

Polyfill

+ +

Diese Funktion kann folgendermaßen emuliert werden:

+ +
Math.hypot = Math.hypot || function() {
+  var y = 0, i = arguments.length;
+  while (i--) y += arguments[i] * arguments[i];
+  return Math.sqrt(y);
+};
+
+ +

Ein Polyfill der Underflows und Overflows vermeidet:

+ +
Math.hypot = function (x, y) {
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=896264#c28
+  var max = 0;
+  var s = 0;
+  for (var i = 0; i < arguments.length; i += 1) {
+    var arg = Math.abs(Number(arguments[i]));
+    if (arg > max) {
+      s *= (max / arg) * (max / arg);
+      max = arg;
+    }
+    s += arg === 0 && max === 0 ? 0 : (arg / max) * (arg / max);
+  }
+  return max === 1 / 0 ? 1 / 0 : max * Math.sqrt(s);
+};
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES2015', '#sec-math.hypot', 'Math.hypot')}}{{Spec2('ES2015')}}Initiale Definition.
{{SpecName('ESDraft', '#sec-math.hypot', 'Math.hypot')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.hypot")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/imul/index.html b/files/de/web/javascript/reference/global_objects/math/imul/index.html new file mode 100644 index 0000000000..ea3bc9abf3 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/imul/index.html @@ -0,0 +1,92 @@ +--- +title: Math.imul() +slug: Web/JavaScript/Reference/Global_Objects/Math/imul +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/imul +--- +
{{JSRef}}
+ +

Die Math.imul() Funktion führt eine C ähnliche 32-Bit Multiplikation der zwei Parameter durch.

+ +
{{EmbedInteractiveExample("pages/js/math-imul.html")}}
+ + + +

Syntax

+ +
Math.imul(a, b)
+ +

Parameter

+ +
+
a
+
Erste Nummer.
+
b
+
Zweite Nummer.
+
+ +

Rückgabewert

+ +

Das Resultat der C-ähnlichen 32-Bit Multiplikation der übergebenen Parameter.

+ +

Beschreibung

+ +

Math.imul() erlaubt es schnelle 32-Bit Ganzzahlmultiplikationen mit C ähnlicher Semantik durchzuführen. Diese Funktion ist nützlich für Projekte wie Emscripten. Weil imul() eine statische Methode von Math ist, muss man immer Math.imul() benutzen und nicht als Methode eines Math Objektes, das man erzeugt (Math ist kein Konstruktor). Wenn normale JavaScript Gleitkommazahlen in imul eingesetzt werden, wird die Performance beeinträchtigt. Das ist wegen der Umwandlung von Gleitkommazahlen zu ganzen Zahlen für die Multiplikation und die anschließende Rückkonvertierung des Ergebnisses in eine Gleitkommazahl. Der Grund warum imul existiert, ist, dass esin (nur) einem Fall schneller ist: AsmJS. AsmJS erlaubt JIST-Optimierungen für einfache Implementierung von ganzen Zahlen in JavaScript. Multiplizieren von zwei Zahlen mit imul, die intern als Integer dargestellt sind (was nur mit AsmJS funktioniert) ist der einzige Grund, wo Math.imul die Performance im Browsern steigern kann.

+ +

Beispiele

+ +

Einsatz von Math.imul()

+ +
Math.imul(2, 4);          // 8
+Math.imul(-1, 8);         // -8
+Math.imul(-2, -2);        // 4
+Math.imul(0xffffffff, 5); // -5
+Math.imul(0xfffffffe, 5); // -10
+
+ +

Polyfill

+ +

Diese Funktionalität kann durch folgende Funktion emuliert werden:

+ +
Math.imul = Math.imul || function(a, b) {
+  var aHi = (a >>> 16) & 0xffff;
+  var aLo = a & 0xffff;
+  var bHi = (b >>> 16) & 0xffff;
+  var bLo = b & 0xffff;
+  // the shift by 0 fixes the sign on the high part
+  // the final |0 converts the unsigned value into a signed value
+  return ((aLo * bLo) + (((aHi * bLo + aLo * bHi) << 16) >>> 0) | 0);
+};
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES6', '#sec-math.imul', 'Math.imul')}}{{Spec2('ES6')}}Initial definition.
{{SpecName('ESDraft', '#sec-math.imul', 'Math.imul')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.imul")}}

diff --git a/files/de/web/javascript/reference/global_objects/math/index.html b/files/de/web/javascript/reference/global_objects/math/index.html new file mode 100644 index 0000000000..7dd7493568 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/index.html @@ -0,0 +1,201 @@ +--- +title: Math +slug: Web/JavaScript/Reference/Global_Objects/Math +tags: + - JavaScript + - Math + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math +--- +
{{JSRef}}
+ +

Math ist ein Standardobjekt, das Eigenschaften und Methoden für mathematische Konstanten und Funktionen besitzt. Es ist kein Funktionsobjekt.

+ +

Beschreibung

+ +

Im Unterschied zu den anderen globalen Objekten hat Math keinen Konstruktor. Alle Eigenschaften und Methoden von Math sind statisch. Um die Konstante Pi zu erreichen, wird Math.PI genutzt. Die Sinusfunktion wird mit Math.sin(x) ausgeführt, wobei x der Methodenparameter ist. Konstanten sind so präzise wie der Typ number in JavaScript.

+ +

Eigenschaften

+ +
+
{{jsxref("Math.E")}}
+
Eulersche Zahl und die Basis für den natürlichen Logarithmus (gerundet 2,718).
+
+ +
+
{{jsxref("Math.LN2")}}
+
Natürlicher Logarithmus von 2 (gerundet 0,693).
+
{{jsxref("Math.LN10")}}
+
Natürlicher Logarithmus von 10 (gerundet 2,303).
+
{{jsxref("Math.LOG2E")}}
+
Logarithmus zur Basis 2 von der Eulerschen Zahl (gerundet 1,443).
+
{{jsxref("Math.LOG10E")}}
+
Logarithmus zur Basis 10 von der Eulerschen Zahl (gerundet 0,434).
+
{{jsxref("Math.PI")}}
+
Kreiszahl Pi, welche als Verhältnis zwischen Kreisumfang und Durchmesser definiert ist (gerundet 3,14159).
+
{{jsxref("Math.SQRT1_2")}}
+
Quadratwurzel aus 1/2 oder 1 geteilt durch die Quadratwurzel von 2 (gerundet 0,707).
+
{{jsxref("Math.SQRT2")}}
+
Quadratwurzel aus 2 (gerundet 1,414).
+
+ +

Methoden

+ +
Anmerkung: Die trigonometrischen Funktionen (sin(), cos(), tan(), asin(), acos(), atan(), atan2()) erwarten Parameter und geben Rückgabewerte im Bogenmaß zurück. Um dieses in das Gradmaß umzurechnen, teilt man durch (Math.PI / 180) und multipliziert das Ergebnis mit der Bogenmaß.
+ +
Anmerkung: Bei vielen mathematischen Funktionen ist die Präzision implementationsabhängig. Das bedeutet, dass es bei verschiedenen Browsern verschiedene Ergebnisse geben kann. Auch in der gleichen JavaScript-Umgebung auf verschiedenen Betriebssystemen oder Architekturen können Abweichungen entstehen.
+ +
+
+ +
+
{{jsxref("Global_Objects/Math/abs", "Math.abs(x)")}}
+
Gibt den Betrag einer Zahl zurück.
+
{{jsxref("Global_Objects/Math/acos", "Math.acos(x)")}}
+
Gibt den Arcus Cosinus einer Zahl zurück.
+
{{jsxref("Global_Objects/Math/acosh", "Math.acosh(x)")}}
+
Gibt den Areacosinus Hyperbolicus einer Zahl zurück.
+
{{jsxref("Global_Objects/Math/asin", "Math.asin(x)")}}
+
Gibt den Arcus Sinus einer Zahl zurück.
+
{{jsxref("Global_Objects/Math/asinh", "Math.asinh(x)")}}
+
Gibt den Areasinus Hyperbolicus einer Zahl zurück.
+
{{jsxref("Global_Objects/Math/atan", "Math.atan(x)")}}
+
Gibt den Arcus Tangens einer Zahl zurück.
+
{{jsxref("Global_Objects/Math/atanh", "Math.atanh(x)")}}
+
Gibt den Areatangens Hyperbolicus einer Zahl zurück.
+
{{jsxref("Global_Objects/Math/atan2", "Math.atan2(y, x)")}}
+
Gibt den Arcus Tangens aus dem Quotienten der Argumente zurück.
+
{{jsxref("Global_Objects/Math/cbrt", "Math.cbrt(x)")}}
+
Gibt die Kubikwurzel einer Zahl zurück.
+
{{jsxref("Global_Objects/Math/ceil", "Math.ceil(x)")}}
+
Gibt die kleinste ganze Zahl zurück, die größer oder gleich dem Parameter ist.
+
{{jsxref("Global_Objects/Math/clz32", "Math.clz32(x)")}}
+
Gibt die Anzahl der voranstehenden 0-Bits einer 32-Bit-Repräsentation zurück.
+
{{jsxref("Global_Objects/Math/cos", "Math.cos(x)")}}
+
Gibt den Cosinus einer Zahl zurück.
+
{{jsxref("Global_Objects/Math/cosh", "Math.cosh(x)")}}
+
Gibt den Cosinus Hyperbolicus einer Zahl zurück.
+
{{jsxref("Global_Objects/Math/exp", "Math.exp(x)")}}
+
Gibt Ex zurück, wobei x der Parameter und E die Eulersche Zahl ist.
+
{{jsxref("Global_Objects/Math/expm1", "Math.expm1(x)")}}
+
Gibt exp(x) - 1 zurück.
+
{{jsxref("Global_Objects/Math/floor", "Math.floor(x)")}}
+
Rundet eine Zahl auf eine ganze Zahl ab.
+
{{jsxref("Global_Objects/Math/fround", "Math.fround(x)")}}
+
Gibt die am nächsten liegende einfache genaue Gleitkommazahl des Parameters zurück.
+
{{jsxref("Global_Objects/Math/hypot", "Math.hypot([x[,y[,…]]])")}}
+
Gibt die Quadratwurzel aus der Summe der quadrierten Parameterwerte zurück.
+
{{jsxref("Global_Objects/Math/imul", "Math.imul(x)")}}
+
Gibt das Ergebnis einer 32-Bit-Ganzzahlmultiplikation zurück.
+
{{jsxref("Global_Objects/Math/log", "Math.log(x)")}}
+
Gibt den natürlichen Logarithmus (loge oder ln) einer Zahl zurück.
+
{{jsxref("Global_Objects/Math/log1p", "Math.log1p(x)")}}
+
Gibt den natürlichen Logarithmus (loge oder ln) einer mit 1 addierten Zahl zurück.
+
{{jsxref("Global_Objects/Math/log10", "Math.log10(x)")}}
+
Gibt den Logarithmus zur Basis 10 einer Zahl zurück.
+
{{jsxref("Global_Objects/Math/log2", "Math.log2(x)")}}
+
Gibt den Logarithmus zur Basis 2 einer Zahl zurück.
+
{{jsxref("Global_Objects/Math/max", "Math.max([x[,y[,…]]])")}}
+
Gibt die größte von null oder mehr Zahlen zurück.
+
{{jsxref("Global_Objects/Math/min", "Math.min([x[,y[,…]]])")}}
+
Gibt die kleinste von null oder mehr Zahlen zurück.
+
{{jsxref("Global_Objects/Math/pow", "Math.pow(x,y)")}}
+
Gibt die Potenz zweier Zahlen zurück (xy).
+
{{jsxref("Global_Objects/Math/random", "Math.random()")}}
+
Gibt eine Pseudozufallszahl zwischen 0 und 1 zurück.
+
{{jsxref("Global_Objects/Math/round", "Math.round(x)")}}
+
Gibt den ganzzahlig gerundeten Wert des Parameters zurück.
+
+ +
+
{{jsxref("Global_Objects/Math/sign", "Math.sign(x)")}}
+
Gibt das Vorzeichen (positiv, negativ, 0) von x zurück.
+
{{jsxref("Global_Objects/Math/sin", "Math.sin(x)")}}
+
Gibt den Sinus einer Zahl zurück.
+
{{jsxref("Global_Objects/Math/sinh", "Math.sinh(x)")}}
+
Gibt den Sinus Hyperbolicus einer Zahl zurück.
+
{{jsxref("Global_Objects/Math/sqrt", "Math.sqrt(x)")}}
+
Gibt die positive Quadratwurzel einer Zahl zurück.
+
{{jsxref("Global_Objects/Math/tan", "Math.tan(x)")}}
+
Gibt den Tangens einer Zahl zurück.
+
{{jsxref("Global_Objects/Math/tanh", "Math.tanh(x)")}}
+
Gibt den Tangens Hyperbolicus einer Zahl zurück.
+
Math.toSource() {{Non-standard_inline() }}
+
Gibt die Zeichenkette "Math" zurück.
+
{{jsxref("Global_Objects/Math/trunc", "Math.trunc(x)")}}
+
Gibt den ganzzahligen Teil der Zahl x, ohne jede Nachkommastellen, zurück.
+
+ +

Das Math Objekt erweitern

+ +

Wie die meisten der Standard-JavaScript Objekte kann auch das Math Objekt um benutzerdefinierten Eigenschaften und Methoden erweitert werden. Zum Erweitern des Math Objektes wird nicht prototype genutzt. Stattdessen wird Math direkt erweitert.

+ +
Math.propName = propValue;
+Math.methodName = methodRef;
+ +

Im folgenden Beispiel wird eine Methode zum Math Objekt hinzugefügt, welche den größten gemeinsamen Teiler von einer Liste von Argumenten ermittelt.

+ +
/* Variadic function -- Returns the greatest common divisor of a list of arguments */
+Math.gcd = function () {
+  if(arguments.length == 2) {
+    if(arguments[1] == 0) {
+      return arguments[0];
+    } else {
+      return Math.gcd(arguments[1], arguments[0] % arguments[1]);
+    }
+  } else if (arguments.length > 2) {
+    var result = Math.gcd(arguments[0], arguments[1]);
+    for (var i = 2; i < arguments.length; i++) {
+      result = Math.gcd(result, arguments[i]);
+    }
+    return result;
+  }
+}
+ +

Zum Ausprobieren:

+ +
console.log(Math.gcd(20, 30, 15, 70, 40)); // `5`
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.8', 'Math')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math-object', 'Math')}}{{Spec2('ES6')}}Die neuen Methoden {{jsxref("Math.log10()", "log10()")}}, {{jsxref("Math.log2()", "log2()")}}, {{jsxref("Math.log1p()", "log1p()")}}, {{jsxref("Math.expm1()", "expm1()")}}, {{jsxref("Math.cosh()", "cosh()")}}, {{jsxref("Math.sinh()", "sinh()")}}, {{jsxref("Math.tanh()", "tanh()")}}, {{jsxref("Math.acosh()", "acosh()")}}, {{jsxref("Math.asinh()", "asinh()")}}, {{jsxref("Math.atanh()", "atanh()")}}, {{jsxref("Math.hypot()", "hypot()")}}, {{jsxref("Math.trunc()", "trunc()")}}, {{jsxref("Math.sign()", "sign()")}}, {{jsxref("Math.imul()", "imul()")}}, {{jsxref("Math.fround()", "fround()")}}, {{jsxref("Math.cbrt()", "cbrt()")}} und {{jsxref("Math.clz32()", "clz32()")}} hinzugefügt.
{{SpecName('ESDraft', '#sec-math-object', 'Math')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/ln10/index.html b/files/de/web/javascript/reference/global_objects/math/ln10/index.html new file mode 100644 index 0000000000..b43f317ef4 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/ln10/index.html @@ -0,0 +1,83 @@ +--- +title: Math.LN10 +slug: Web/JavaScript/Reference/Global_Objects/Math/LN10 +tags: + - JavaScript + - Math + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN10 +--- +
{{JSRef}}
+ +

Die Math.LN10 Eigenschaft repräsentiert den natürlichen Logarithmus von 10, was gerundet 2,302 ist:

+ +

Math.LN10=ln(10)≈2,302\mathtt{\mi{Math.LN10}} = \ln(10) \approx 2,302

+ +
{{EmbedInteractiveExample("pages/js/math-ln10.html")}}
+ + + +
{{js_property_attributes(0,0,0)}}
+ +

Beschreibung

+ +

Weil LN10 eine statische Eigenschaft von Math ist, kann diese immer über Math.LN10 erreicht werden, ohne dass ein Objekt von Math erstellt werden muss (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Einsatz von Math.LN10

+ +

Die folgende Funktion gibt das Ergebnis des natürlichen Logarithmus von 10 zurück:

+ +
function getNatLog10() {
+   return Math.LN10
+}
+
+getNatLog10() // 2.302585092994046
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0
{{SpecName('ES5.1', '#sec-15.8.1.2', 'Math.LN10')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.ln10', 'Math.LN10')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.ln10', 'Math.LN10')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.LN10")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/ln2/index.html b/files/de/web/javascript/reference/global_objects/math/ln2/index.html new file mode 100644 index 0000000000..5577b36c74 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/ln2/index.html @@ -0,0 +1,83 @@ +--- +title: Math.LN2 +slug: Web/JavaScript/Reference/Global_Objects/Math/LN2 +tags: + - JavaScript + - Math + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN2 +--- +
{{JSRef}}
+ +

Die Math.LN2 Eigenschaft repräsentiert den natürlichen Logarithmus von 2, was gerundet 0,693 ist:

+ +

Math.LN2=ln(2)≈0,693\mathtt{\mi{Math.LN2}} = \ln(2) \approx 0,693

+ +
{{EmbedInteractiveExample("pages/js/math-ln2.html")}}
+ + + +
{{js_property_attributes(0,0,0)}}
+ +

Beschreibung

+ +

Weil LN2 eine statische Eigenschaft von Math ist, kann diese immer mit Math.LN2 erreicht werden, ohne dass ein Objekt von Math erstellt werden muss (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Einsatz von Math.LN2

+ +

Die folgende Funktion gibt den Logarithmus zur Basis 2 von einer Zahl zurück. Dabei wird Math.LN2 benutzt:

+ +
function getLog2(x) {
+  return Math.log(x) / Math.LN2;
+}
+
+getLog2(256) // 8
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0
{{SpecName('ES5.1', '#sec-15.8.1.3', 'Math.LN2')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.ln2', 'Math.LN2')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.ln2', 'Math.LN2')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.LN2")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/log/index.html b/files/de/web/javascript/reference/global_objects/math/log/index.html new file mode 100644 index 0000000000..d4502d50e2 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/log/index.html @@ -0,0 +1,113 @@ +--- +title: Math.log() +slug: Web/JavaScript/Reference/Global_Objects/Math/log +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log +--- +
{{JSRef}}
+ +

Die Math.log() Funktion gibt den natürlichen Logarithmus (Logarithmus zur Basis {{jsxref("Math.E", "e")}}) einer Zahl zurück. Das bedeutet

+ +

∀x>0,Math.log(x)=ln(x)=ysodass ey=x\forall x > 0, \mathtt{\operatorname{Math.log}(x)} = \ln(x) = \text{the unique} \; y \; \text{such that} \; e^y = x

+ +

Die JavaScript Function Math.log() ist gleichbedeutend zu der mathematischen Funktion ln(x).

+ +
{{EmbedInteractiveExample("pages/js/math-log.html")}}
+ + + +

Syntax

+ +
Math.log(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl.
+
+ +

Rückgabewert

+ +

Der natürliche Logarithmus (Basis {{jsxref("Math.E", "e")}}) der übergebenen Zahl. Wenn die Zahl negativ ist, wird {{jsxref("NaN")}} zurückgegeben.

+ +

Beschreibung

+ +

Wenn der Wert von x negativ ist, so gibt die Funktion immer {{jsxref("NaN")}} zurück.

+ +

Weil log() eine statische Funktion von Math ist, wird es immer als Math.log() eingesetzt, jedoch nicht als Methode eines erzeugten Math Objektes (Math ist kein Konstruktor).

+ +

Wenn der natürliche Logarithmus von 2 und 10 gebraucht wird, gibt es die Konstanten {{jsxref("Math.LN2")}} und {{jsxref("Math.LN10")}}. Wenn ein Logarithmus zur Basis 2 oder 10 gebracht wird, gibt es die Funktionen {{jsxref("Math.log2()")}} und {{jsxref("Math.log10()")}}. Wenn der Logarithmus zu einer anderen Basis gebraucht wird, benutzt man Math.log(x) / Math.log(andereBasis) wie im Beispiel unten. Manchmal möchte man 1 / Math.log(andereBasis) vorberechnen.

+ +

Beispiele

+ +

Einsatz von Math.log()

+ +
Math.log(-1); // NaN, weil negativ
+Math.log(0);  // -Infinity
+Math.log(1);  // 0
+Math.log(10); // 2.302585092994046
+
+ +

Einsatz von  Math.log() mit unterschiedlichen Basen

+ +

Die folgende Funktion gibt den Logarithmus von y zur Basis x zurück (logx y):

+ +
function getBaseLog(x, y) {
+  return Math.log(y) / Math.log(x);
+}
+
+ +

Wenn getBaseLog(10, 1000) ausgeführt wird, ist das Ergebnis 2.9999999999999996. Diese Zahl ist nah an 3 und kommt durch Rundungsfehler bei Fließkommazahlen.

+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.10', 'Math.log')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-math.log', 'Math.log')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-math.log', 'Math.log')}}{{Spec2('ESDraft')}}
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.log")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/log10/index.html b/files/de/web/javascript/reference/global_objects/math/log10/index.html new file mode 100644 index 0000000000..fad6ea0996 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/log10/index.html @@ -0,0 +1,101 @@ +--- +title: Math.log10() +slug: Web/JavaScript/Reference/Global_Objects/Math/log10 +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log10 +--- +
{{JSRef}}
+ +
Die Math.log10() Funktion gibt den Logarithmus zur Basis 10 zurück. Das bedeutet
+ +

∀x>0,Math.log10(x)=log10(x)=yso das10y=x\forall x > 0, \mathtt{\operatorname{Math.log10}(x)} = \log_10(x) = \text{the unique} \; y \; \text{such that} \; 10^y = x

+ +
{{EmbedInteractiveExample("pages/js/math-log10.html")}}
+ + + +

Syntax

+ +
Math.log10(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl.
+
+ +

Rückgabewert

+ +

Den Logarithmus zur Basis 10 der gegebenen Zahl. Wenn die Zahl negativ ist, wird {{jsxref("NaN")}} zurückgegeben.

+ +

Beschreibung

+ +

Wenn der Wert von x negativ ist, so gibt die Funktion immer NaN zurück.

+ +

Weil log10() eine statische Funktion von Math ist, wird es immer als Math.log10() eingesetzt, jedoch nicht als Methode eines erzeugten Math Objektes (Math ist kein Konstruktor).

+ +

Diese Funktion ist äquivalent zu Math.log(x) / Math.log(10). Für log10(e) gibt es die Konstante {{jsxref("Math.LOG10E")}} welche 1 / {{jsxref("Math.LN10")}} ist.

+ +

Beispiele

+ +

Einsatz von Math.log10()

+ +
Math.log10(2);      // 0.3010299956639812
+Math.log10(1);      // 0
+Math.log10(0);      // -Infinity
+Math.log10(-2);     // NaN
+Math.log10(100000); // 5
+
+ +

Polyfill

+ +

Diese Funktion kann folgendermaßen emitiert werden:

+ +
Math.log10 = Math.log10 || function(x) {
+  return Math.log(x) * Math.LOG10E;
+};
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES2015', '#sec-math.log10', 'Math.log10')}}{{Spec2('ES2015')}}Initiale Definition.
{{SpecName('ESDraft', '#sec-math.log10', 'Math.log10')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.log10")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/log10e/index.html b/files/de/web/javascript/reference/global_objects/math/log10e/index.html new file mode 100644 index 0000000000..28d609df71 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/log10e/index.html @@ -0,0 +1,85 @@ +--- +title: Math.LOG10E +slug: Web/JavaScript/Reference/Global_Objects/Math/LOG10E +tags: + - JavaScript + - Math + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG10E +--- +
{{JSRef}}
+ +

Die Math.LOG10E Eigenschaft repräsentiert den Logarithmus zur Basis 10 von e, was gerundet 0,434 ist:

+ +

Math.LOG10E=log10(e)≈0,434\mathtt{\mi{Math.LOG10E}} = \log_10(e) \approx 0,434

+ +
{{EmbedInteractiveExample("pages/js/math-log10e.html")}}
+ + + +

{{js_property_attributes(0,0,0)}}

+ +

Beschreibung

+ +

Weil LOG10E eine statische Eigenschaft von Math ist, kann diese immer über Math.LOG10E erreicht werden, ohne dass ein Objekt erstellt werden muss (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Einsatz von Math.LOG10E

+ +

Die folgende Funktion gibt den Logarithmus zur Basis 10 von e zurück.

+ +
function getLog10e() {
+   return Math.LOG10E
+}
+
+getLog10e() // 0.4342944819032518
+ +

Spezifikationen

+ +

{{Spec2('ES1')}}

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.1.5', 'Math.LOG10E')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.log10e', 'Math.LOG10E')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.log10e', 'Math.LOG10E')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.LOG10E")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/log1p/index.html b/files/de/web/javascript/reference/global_objects/math/log1p/index.html new file mode 100644 index 0000000000..a63eab6b6f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/log1p/index.html @@ -0,0 +1,102 @@ +--- +title: Math.log1p() +slug: Web/JavaScript/Reference/Global_Objects/Math/log1p +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log1p +--- +
{{JSRef}}
+ +

Die Math.log1p() Funktion gibt den natürlichen Logarithmus (Logarithmus zur Basis {{jsxref("Math.E", "e")}}) von 1 + x zurück. Das bedeutet

+ +

∀x>-1,Math.log1p(x)=ln(1+x)\forall x > -1, \mathtt{\operatorname{Math.log1p}(x)} = \ln(1 + x)

+ +
{{EmbedInteractiveExample("pages/js/math-log1p.html")}}
+ + + +

Syntax

+ +
Math.log1p(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl.
+
+ +

Rückgabewert

+ +

Den natürliche Logarithmus (zur Basis {{jsxref("Math.E", "e")}}) von 1 plus der gegebenen Zahl. Wenn die Zahl kleiner als -1 ist, wird {{jsxref("NaN")}} zurückgegeben.

+ +

Beschreibung

+ +

Für sehr kleine Zahlen für x kann das Addieren mit 1 zu verlusten in der Präzision führen. Die Zahlen in JavaScript haben eine Genauigkeit von 15 Stellen. 1 + 1e-15 = 1.000000000000001, aber 1 + 1e-16 = 1.000000000000000 und damit exakt 1.0 in dieser Arithmetik, weil Ziffern nach der 15 Stelle gerundet werden.

+ +

Wenn log(1 + x) berechnet wird, bekommt man ein Ergebnis sehr na an x, wenn x klein ist (das ist der Grund, warum es 'natürlicher' Logarithmus heißt). Wenn Math.log(1 + 1.1111111111e-15) berechnet wird sollte man ein Ergebnis nah an 1.1111111111e-15 bekommt. Stattdessen berechnet man den Logarithmus von 1.00000000000000111022 (die Rundung geschieht im Binärsystem und ist manchmal unschön) un erhält das Ergebnis 1.11022...e-15 mit nur 3 korrekten Stellen. Wenn stattdessen Math.log1p(1.1111111111e-15) berechnet wird, bekommt man ein besseres Ergebnis von 1.1111111110999995e-15 mit 15 korrekten Stellen in der Präzision (aktuell 16 in diesem Fall).

+ +

Wenn der Wert von x kleiner als -1 ist, gibt die Funktion immer den Wert {{jsxref("NaN")}} zurück.

+ +

Weil log1p() eine statische Funktion von Math ist, wird es immer als Math.log1p() eingesetzt, jedoch nicht als Methode eines erzeugten Math Objektes (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Einsatz von Math.log1p()

+ +
Math.log1p(1);  // 0.6931471805599453
+Math.log1p(0);  // 0
+Math.log1p(-1); // -Infinity
+Math.log1p(-2); // NaN
+
+ +

Polyfill

+ +

Diese Funktion kann folgendermaßen emuliert werden:

+ +
Math.log1p = Math.log1p || function(x) {
+  return Math.log(1 + x);
+};
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES2015', '#sec-math.log1p', 'Math.log1p')}}{{Spec2('ES2015')}}Initiale Definition.
{{SpecName('ESDraft', '#sec-math.log1p', 'Math.log1p')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.log1p")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/log2/index.html b/files/de/web/javascript/reference/global_objects/math/log2/index.html new file mode 100644 index 0000000000..de98c13128 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/log2/index.html @@ -0,0 +1,101 @@ +--- +title: Math.log2() +slug: Web/JavaScript/Reference/Global_Objects/Math/log2 +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log2 +--- +
{{JSRef}}
+ +

Die Math.log2() Funktion gibt den Logarithmus zur Basis 2 zurück. Das bedeutet

+ +

∀x>0,Math.log2(x)=log2(x)=yso das2y=x\forall x > 0, \mathtt{\operatorname{Math.log2}(x)} = \log_2(x) = \text{the unique} \; y \; \text{such that} \; 2^y = x

+ +
{{EmbedInteractiveExample("pages/js/math-log2.html")}}
+ + + +

Syntax

+ +
Math.log2(x)
+ +

Parameters

+ +
+
x
+
Eine Zahl.
+
+ +

Rückgabewert

+ +

Den Logarithmus zur Basis 2 der gegebenen Zahl. Wenn die Zahl negativ ist, wird {{jsxref("NaN")}} zurückgegeben.

+ +

Beschreibung

+ +

Wenn der Wert von x negativ ist, so gibt die Funktion immer NaN zurück.

+ +

Weil log2() eine statische Funktion von Math ist, wird es immer als Math.log2() eingesetzt, jedoch nicht als Methode eines erzeugten Math Objektes (Math ist kein Konstruktor).

+ +

Diese Funktion ist äquivalent zu Math.log(x) / Math.log(2). Für log2(e) gibt es die Konstante {{jsxref("Math.LOG2E")}} welche 1 / {{jsxref("Math.LN2")}} ist.

+ +

Beispiele

+ +

Einsatz von Math.log2()

+ +
Math.log2(3);    // 1.584962500721156
+Math.log2(2);    // 1
+Math.log2(1);    // 0
+Math.log2(0);    // -Infinity
+Math.log2(-2);   // NaN
+Math.log2(1024); // 10
+
+ +

Polyfill

+ +

Diese Funktion kann mit folgender Funktion emitiert werden. Es kann sein, dass diese Funktion bei einigen eingabewerten ungenau (ungefähr 1 << 29) ist. Schachtel die Funktion in {{jsxref("Math.round()")}} wenn mit Bitmasken gearbeitet wird.

+ +
Math.log2 = Math.log2 || function(x) {
+  return Math.log(x) * Math.LOG2E;
+};
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES2015', '#sec-math.log2', 'Math.log2')}}{{Spec2('ES2015')}}Initiale Definition.
{{SpecName('ESDraft', '#sec-math.log2', 'Math.log2')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.log2")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/log2e/index.html b/files/de/web/javascript/reference/global_objects/math/log2e/index.html new file mode 100644 index 0000000000..2f302bf4a2 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/log2e/index.html @@ -0,0 +1,83 @@ +--- +title: Math.LOG2E +slug: Web/JavaScript/Reference/Global_Objects/Math/LOG2E +tags: + - JavaScript + - Math + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG2E +--- +
{{JSRef}}
+ +

Die Math.LOG2E Eigenschaft repräsentiert den Logarithmus zur Basis 2 von e, was gerundet 1,443 ist:

+ +

Math.LOG2E=log2(e)≈1,442\mathtt{\mi{Math.LOG2E}} = \log_2(e) \approx 1,442

+ +
{{EmbedInteractiveExample("pages/js/math-log2e.html")}}
+ + + +
{{js_property_attributes(0,0,0)}}
+ +

Beschreibung

+ +

Weil LOG2E eine statische Eigenschaft von Math ist, kann diese immer über Math.LOG2E erreicht werden, ohne dass ein Objekt erstellt werden muss (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Einsatz von Math.LOG2E

+ +

Die folgende Funktion gibt den Logarithmus zur Basis 2 von e zurück.

+ +
function getLog2e() {
+   return Math.LOG2E
+}
+
+getLog2e() // 1.4426950408889634
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.1.4', 'Math.LOG2E')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.log2e', 'Math.LOG2E')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.log2e', 'Math.LOG2E')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.LOG2E")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/math.random/index.html b/files/de/web/javascript/reference/global_objects/math/math.random/index.html new file mode 100644 index 0000000000..6097229c1a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/math.random/index.html @@ -0,0 +1,112 @@ +--- +title: Math.random() +slug: Web/JavaScript/Reference/Global_Objects/Math/math.random +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/random +--- +
{{JSRef}}
+ +

Die Math.random() Funktion gibt eine Pseudozufallszahl in Form einer Gleitkommazahl im Bereich von 0 - 1 (0 inklusiv, aber 1 nicht) annähernd gleichverteilt zurück, die dann zur gewünschten Größe skaliert werden kann. Die Zufallszahl wird von der Implementierung bestimmt; sie kann nicht vom Benutzer ausgewählt oder zurückgesetzt werden.

+ +
{{EmbedInteractiveExample("pages/js/math-random.html")}}
+ +
+

Math.random() stellt keine kryprografisch sicheren Zufallszahlen bereit. Verwenden Sie sie auf keinen Fall für etwas, das  in Verbindung mit Sicherheit steht. Benutzen Sie stattdessen die Web Crypto API, genauer gesagt die {{domxref("RandomSource.getRandomValues()", "window.crypto.getRandomValues()")}}-Methode.

+
+ +

Syntax

+ +
Math.random()
+ +

Rückgabewert

+ +

Eine pseudozufällige Gleitkommazahl zwischen 0 (inklusiv) und 1 (exklusiv).

+ +

Beispiele

+ +

Beachten Sie, dass, weil Zahlen in JavaScript IEEE 754 Gleitkommazahlen sind, mit dem Verhalten zur nächsten geraden Zahl zu runden, die Bereiche für die folgenden Funktionen - mit Ausnahme für Math.random() selbst - nicht exakt sind.
+ Wenn extrem große Grenzen (253 oder höher) gewählt werden, ist es in äußerst seltenen Fällen möglich, dass die eigentlich ausgeschlossenen Obergrenzen mit eingerechnet werden.

+ +

Erzeugt eine Zufallszahl zwischen 0 (inklusive) und 1 (exklusive)

+ +
function getRandom() {
+  return Math.random();
+}
+
+ +

Erzeugt eine Zufallszahl zwischen zwei Zahlen

+ +

Das Beispiel gibt eine zufällige Zahl zwischen zwei Zahlen zurück. Der Rückgabewert is größer oder gleich min und kleiner als max.

+ +
function getRandomArbitrary(min, max) {
+  return Math.random() * (max - min) + min;
+}
+
+ +

Erzeugt eine ganze Zufallszahl zwischen zwei Zahlen

+ +

Das Beispiel gibt eine zufällige ganze Zahl zwischen den spezifizierten Werten zurück. Der Wert ist nicht kleiner als min (oder der nächstgrößeren ganzen Zahl von min, wenn min keine ganze Zahl ist) und ist kleiner als  (aber nicht gleich) max.

+ +
function getRandomInt(min, max) {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(Math.random() * (max - min)) + min;
+}
+
+ +
+

Es könnte verlockend sein, Math.round() zu verwenden, um das Ergebnis zu erreichen, aber das würde dazu führen, dass die zufälligen Zahlen einer ungleichmäßigen Verteilung folgen würden, die möglicherweise nicht den geforderten Bedürfnisse entsprechen würde.

+
+ +

Erzeugt eine ganze Zufallszahl zwischen zwei Zahlen (inklusiv)

+ +

Die obere getRandomInt() Funktion hat ein inklusives Minimum und ein exklusives Maximum. Was ist, wenn sowohl das Minimum als auch das Maximum inklusive sein sollen? Die getRandomIntInclusive() Funktion ermöglicht dieses:

+ +
function getRandomIntInclusive(min, max) {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(Math.random() * (max - min +1)) + min;
+}
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. JavaScript 1.0 (nur auf UNIX) / JavaScript 1.1 (auf allen Plattformen).
{{SpecName('ES5.1', '#sec-15.8.2.14', 'Math.random')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-math.random', 'Math.random')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-math.random', 'Math.random')}}{{Spec2('ESDraft')}}
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.random")}}

diff --git a/files/de/web/javascript/reference/global_objects/math/max/index.html b/files/de/web/javascript/reference/global_objects/math/max/index.html new file mode 100644 index 0000000000..e1ac3eba01 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/max/index.html @@ -0,0 +1,118 @@ +--- +title: Math.max() +slug: Web/JavaScript/Reference/Global_Objects/Math/max +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/max +--- +
{{JSRef}}
+ +

Die Funktion Math.max() gibt die größte von 0 oder mehr Zahlen zurück.

+ +
{{EmbedInteractiveExample("pages/js/math-max.html")}}
+ + + +

Syntax

+ +
Math.max([wert1[, wert2[, ...]]])
+ +

Parameter

+ +
+
wert1, wert2, ...
+
Zahlen.
+
+ +

Rückgabewert

+ +

Die größte der übergebenen Zahlen. Wenn mindestens ein Parameter nicht zu einer Zahl konvertiert werden kann, wird {{jsxref("NaN")}} zurückgegeben.

+ +

Beschreibung

+ +

Weil max() eine statische Methode von Math ist, kann nur Math.max() verwendet werden. Eine Verwendung mit Math als instanziertem Objekt ist nicht möglich (Math ist kein constructor).

+ +

Wenn keine Argumente übergeben wurden ist der Rückgabewert -{{jsxref("Infinity")}}.

+ +

Wenn mindestens eines der Argumente nicht in eine Zahl umgewandelt werden kann, ist der Rückgabewert {{jsxref("NaN")}}.

+ +

Beispiele

+ +

Einsatz von Math.max()

+ +
Math.max(10, 20);   //  20
+Math.max(-10, -20); // -10
+Math.max(-10, 20);  //  20
+
+ +

Das größte Element in einem Array ermitteln

+ +

{{jsxref("Array.prototype.reduce", "Array.reduce()")}} kann ebenfalls benutzt werden, um das Maximum eines Arrays zu erhalten, indem jeder Wert verglichen wird.

+ +
var arr = [1, 2, 3];
+var max = arr.reduce(function(a, b) {
+  return Math.max(a, b);
+});
+
+ +

Die folgende Funktion benutzt {{jsxref("Function.prototype.apply()")}}, um den maximalen Wert eines numerischen Arrays zu finden. getMaxOfArray([1, 2, 3]) entspricht Math.max(1, 2, 3), aber getMaxOfArray() kann programmatisch erstellte Arrays jeder Art annehmen.

+ +
function getMaxOfArray(numArray) {
+  return Math.max.apply(null, numArray);
+}
+
+ +

Alternativ ist es mit dem neuen {{jsxref("Operators/Spread_operator", "spread Operator")}} viel einfacher, den maximalen Wert eines Arrays herauszufinden.

+ +
var arr = [1, 2, 3];
+var max = Math.max(...arr);
+
+ +

Bei dem Einsatz des {{jsxref("Operators/Spread_operator", "spread Operator")}} oder apply kann der Aufruf fehlschlagen oder ein ungültiges Ergebnis herauskommen, wenn das Array zu viele Elemente hat. Das liegt daran, dass versucht wird die Elemente des Arrays als Parameter einer Funktion zu übergeben. Siehe für mehr Details im Abschnitt Einsatz von apply und standard Funktionen nach. Die reduce Lösung hat dieses Problem nicht.

+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. In JavaScript 1.0 implementiert.
{{SpecName('ES5.1', '#sec-15.8.2.11', 'Math.max')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.max', 'Math.max')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.max', 'Math.max')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.max")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/min/index.html b/files/de/web/javascript/reference/global_objects/math/min/index.html new file mode 100644 index 0000000000..9cd666fda3 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/min/index.html @@ -0,0 +1,112 @@ +--- +title: Math.min() +slug: Web/JavaScript/Reference/Global_Objects/Math/min +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/min +--- +
{{JSRef}}
+ +

Die Math.min() Funktion gibt den Wert der kleinsten übergebenen Zahl zurück oder {{jsxref("NaN")}}, wenn ein Parameter keine Zahl ist und auch nicht in eine Zahl konvertiert werden kann.

+ +
{{EmbedInteractiveExample("pages/js/math-min.html")}}
+ + + +

Syntax

+ +
Math.min([value1[, value2[, ...]]])
+ +

Parameter

+ +
+
value1, value2, ...
+
Zahlen.
+
+ +

Rückgabewert

+ +

Die kleinste der übergebenen Zahlen. Wenn nur ein Parameter nicht zu einer Zahl konvertiert werden kann, wird {{jsxref("NaN")}} zurückgegeben.

+ +

Beschreibung

+ +

Da min() eine statische Eigenschaft von Math ist, muss immer Math.min() genutzt werden, ohne dass ein Math-Objekt erstellt wird (Math ist kein Konstruktor).

+ +

Ohne Übergabeparameter wird {{jsxref("Infinity")}} zurückgegeben.

+ +

Wenn mindestens ein Übergabeparameter nicht in eine Zahl konvertiert werden kann wird {{jsxref("NaN")}} zurückgegeben.

+ +

Beispiele

+ +

Einsatz von Math.min()

+ +

Dies findet den kleinsten Wert aus x und y und weist diesen z zu.

+ +
var x = 10, y = -20;
+var z = Math.min(x, y);
+
+ +

Wert mittels Math.min() begrenzen

+ +

Math.min() wird oftmals verwendet um einen Wert so zu begrenzen, dass dieser nicht größer als ein gesetztes Limit werden kann. So kann dies

+ +
var x = f(foo);
+
+if (x > limit) {
+  x = limit;
+}
+
+ +

auch folgendermaßen formuliert werden

+ +
var x = Math.min(f(foo), limit);
+
+ +

Analog kann {{jsxref("Math.max()")}} verwendet werden um einen Mindestwert zu realisieren.

+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.12', 'Math.min')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.min', 'Math.min')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.min', 'Math.min')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.min")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/pi/index.html b/files/de/web/javascript/reference/global_objects/math/pi/index.html new file mode 100644 index 0000000000..4a07aadc15 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/pi/index.html @@ -0,0 +1,81 @@ +--- +title: Math.PI +slug: Web/JavaScript/Reference/Global_Objects/Math/PI +tags: + - JavaScript + - Math + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/PI +--- +
{{JSRef}}
+ +

Die Math.PI Eigenschaft repräsentiert die Kreiszahl Pi, welche als Verhältnis zwischen Kreisumfang und Durchmesser definiert ist und gerundet die Zahl 3,14159 ist.

+ +

Math.PI=π≈3,14159\mathtt{\mi{Math.PI}} = \pi \approx 3,14159

+ +
{{EmbedInteractiveExample("pages/js/math-pi.html")}}
+ + + +
{{js_property_attributes(0,0,0)}}
+ +

Beschreibung

+ +

Weil PI eine statische Eigenschaft von Math ist, muss immer Math.PI genutzt werden, ohne dass ein Math Objekt erstellt wird (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Einsatz von Math.PI

+ +

Die folgende Funktion benutzt Math.PI, um aus einem Radius den Umfrang eines Kreises zu berechnen:

+ +
function calculateCircumference(radius) {
+  return Math.PI * (radius + radius);
+}
+
+calculateCircumference(1);  // 6.283185307179586
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.1.6', 'Math.PI')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.pi', 'Math.PI')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.pi', 'Math.PI')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.PI")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/pow/index.html b/files/de/web/javascript/reference/global_objects/math/pow/index.html new file mode 100644 index 0000000000..5966acd81f --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/pow/index.html @@ -0,0 +1,113 @@ +--- +title: Math.pow() +slug: Web/JavaScript/Reference/Global_Objects/Math/pow +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/pow +--- +
{{JSRef}}
+ +

Die Funktion Math.pow() gibt die Potenz der Basis mit dem Exponenten an (BasisExponent)

+ +
{{EmbedInteractiveExample("pages/js/math-pow.html")}}
+ + + +

Syntax

+ +
Math.pow(Basis, Exponent)
+ +

Parameter

+ +
+
Basis
+
Basis (auch: die Grundzahl).
+
Exponent
+
der Exponent (auch: die Hochzahl).
+
+ +

Rückgabewert

+ +

Eine Zahl, die die Basis potenziert mit dem Exponenten repräsentiert.

+ +

Beschreibung

+ +

Weil pow() eine statische Funktion von Math ist, wird es immer als Math.pow() eingesetzt, jedoch nicht als Methode eines erzeugten Math Objektes (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Benutzung von Math.pow()

+ +
// einfach
+Math.pow(7, 2);    // 49
+Math.pow(7, 3);    // 343
+Math.pow(2, 10);   // 1024
+// Brüche als Exponenten
+Math.pow(4, 0.5);  // 2 (Wurzel aus 4)
+Math.pow(8, 1/3);  // 2 (Kubikwurzel aus 8)
+Math.pow(2, 0.5);  // 1.4142135623730951 (Wurzel aus 2)
+Math.pow(2, 1/3);  // 1.2599210498948732 (Kubikwurzel aus 2)
+// Negative Exponenten
+Math.pow(7, -2);   // 0.02040816326530612 (1/49)
+Math.pow(8, -1/3); // 0.5
+// Negative Basis
+Math.pow(-7, 2);   // 49 (Das Quadrat ist positiv)
+Math.pow(-7, 3);   // -343 (kann negativ sein)
+Math.pow(-7, 0.5); // NaN (negative Zahlen haben keine Quadratwurzel)
+// auch wegen Grenzen bei der Gleitkomma Berechnung,
+// Negative Basis mit Bruch als Exponent gibt immer NaN zurück
+Math.pow(-7, 1/3); // NaN
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}} +

Initiale Deffinition, Implementiert in JavaScript 1.0.

+
{{SpecName('ES5.1', '#sec-15.8.2.13', 'Math.pow')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.pow', 'Math.pow')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.pow', 'Math.pow')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.pow")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/round/index.html b/files/de/web/javascript/reference/global_objects/math/round/index.html new file mode 100644 index 0000000000..8e009bf6cb --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/round/index.html @@ -0,0 +1,99 @@ +--- +title: Math.round() +slug: Web/JavaScript/Reference/Global_Objects/Math/round +tags: + - JavaScript + - Math + - Method + - Number + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/round +--- +

{{JSRef}}
+ Die Math.round() Funktion gibt die nächstgelegenen Ganzzahl einer Zahl zurück.

+ +
{{EmbedInteractiveExample("pages/js/math-round.html")}}
+ + + +

Syntax

+ +
Math.round(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl.
+
+ +

Rückgabewert

+ +

Den Wert der gegebenen Zahl, der zur nächsten ganzen Zahl gerundet wird.

+ +

Beschreibung

+ +

Wenn der Nachkommateil des Argumentes größer als 0.5 ist, wird das Argument zur nächsten ganzen Zahl, deren Absolutwert größer ist, gerundet. Wenn der Nachkommateil kleiner als 0.5 ist, wird auf die nächsten ganzen Zahl, deren Absolutwert kleiner ist, gerundet. Wenn der Nachkommateil genau 0.5 ist, wird auf die nächst größere ganze Zahl aufgerundet (in Richtung +∞). Das Verhalten bei 0.5 ist anders als bei vielen anderen Programmiersprachen, welche in der Regel zur nächsten ganzen Zahl, welche weiter entfernt von 0 liegt, runden (das kann zu unterschiedlichen Ergebnissen bei negativen Zahlen mit einem exakten Nachkommateil von 0.5 führen).

+ +

Weil round() eine statische Methode von Math ist, benutzt man als Aufruf immer Math.round() und nicht in dem man zunächst ein Math-Objekt erzeugt um anschliessend die round()-Methode aufzurufen (Math ist kein Konstruktor).

+ +

Beispiele

+ +
Math.round(20.49);  // 20
+Math.round(20.5);   // 21
+Math.round(42);     // 42
+Math.round(-20.5);  // -20
+Math.round(-20.51); // -21
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
ECMAScript 1st Edition.{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.15', 'Math.round')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.round', 'Math.round')}}{{Spec2('ES6')}} +

 

+
{{SpecName('ESDraft', '#sec-math.round', 'Math.round')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.round")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/sign/index.html b/files/de/web/javascript/reference/global_objects/math/sign/index.html new file mode 100644 index 0000000000..26a4085eb1 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/sign/index.html @@ -0,0 +1,115 @@ +--- +title: Math.sign() +slug: Web/JavaScript/Reference/Global_Objects/Math/sign +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sign +--- +
{{JSRef}}
+ +

Die Math.sign() Funktion gibt das Vorzeichen einer Zahl zurück, welches angibt, ob eine Zahl positiv, negativ oder 0 ist.

+ +
{{EmbedInteractiveExample("pages/js/math-sign.html")}}
+ + + +

Syntax

+ +
Math.sign(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl.
+
+ +

Rückgabewert

+ +

Eine Zahl, die das Vorzeichen des übergebenen Wertes repräsentiert. Wenn der Parameter eine positive Zahl ist, eine negative Zahl ist oder eine Null (0) ist, wird die Funktion 1, -1, 0 oder -0 zurückgeben. Andernfalls wird {{jsxref("NaN")}} zurückgegeben.

+ +

Beschreibung

+ +

Weil sign() eine statische Funktion von Math ist, wird sie immer als Math.sign() eingesetzt, jedoch nicht als Methode eines erzeugten Math Objektes (Math ist kein Konstruktor).

+ +

Diese Funktion hat die 5 möglichen Rückgabewerte 1, -1, 0, -0 und NaN, welche "positive Zahlen", "negative Zahlen", "positiv 0", "negativ 0" und {{jsxref("NaN")}} repräsentieren.

+ +

Der Übergebeparameter dieser Funktion wird implizit zu einem number-Type konvertiert.

+ +

Beispiele

+ +

Einsatz von Math.sign()

+ +
Math.sign(3);     //  1
+Math.sign(-3);    // -1
+Math.sign('-3');  // -1
+Math.sign(0);     //  0
+Math.sign(-0);    // -0
+Math.sign(NaN);   // NaN
+Math.sign('foo'); // NaN
+Math.sign();      // NaN
+
+ +

Polyfill

+ +
if (!Math.sign) {
+  Math.sign = function(x) {
+    // If x is NaN, the result is NaN.
+    // If x is -0, the result is -0.
+    // If x is +0, the result is +0.
+    // If x is negative and not -0, the result is -1.
+    // If x is positive and not +0, the result is +1.
+    return ((x > 0) - (x < 0)) || +x;
+    // A more aesthetical persuado-representation is shown below
+    //
+    // ( (x > 0) ? 0 : 1 )  // if x is negative then negative one
+    //          +           // else (because you cant be both - and +)
+    // ( (x < 0) ? 0 : -1 ) // if x is positive then positive one
+    //         ||           // if x is 0, -0, or NaN, or not a number,
+    //         +x           // Then the result will be x, (or) if x is
+    //                      // not a number, then x converts to number
+  };
+}
+ +

In diesem Polyfill ist keine weitere Typumwandlung nötig, um aus (x > 0) oder (x < 0) Zahlen zu machen, weil das Subtrahieren voneinander eine Typkonvertierung von boolean zu Zahlen erzwingt.

+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusComment
{{SpecName('ES6', '#sec-math.sign', 'Math.sign')}}{{Spec2('ES6')}}Initiale Definition.
{{SpecName('ESDraft', '#sec-math.sign', 'Math.sign')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.sign")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/sin/index.html b/files/de/web/javascript/reference/global_objects/math/sin/index.html new file mode 100644 index 0000000000..69a7a2f559 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/sin/index.html @@ -0,0 +1,97 @@ +--- +title: Math.sin() +slug: Web/JavaScript/Reference/Global_Objects/Math/sin +tags: + - JavaScript + - Math + - Meth + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sin +--- +
{{JSRef}}
+ +

Die Math.sin() Funktion gibt den Sinus einer Zahl zurück.

+ +
{{EmbedInteractiveExample("pages/js/math-sin.html")}}
+ + + +

Syntax

+ +
Math.sin(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl im Bogenmaß (rad).
+
+ +

Rückgabewert

+ +

Den Sinus der übergebenen Zahl.

+ +

Beschreibung

+ +

Die Math.sin() Funktion gibt einen nummerischen Wert zwischen -1 und 1 zurück. Dieser repräsentiert den Sinus des Winkels.

+ +

Weil sin() eine statische Funktion von Math ist, wird es immer als Math.sin() eingesetzt, jedoch nicht als Methode eines erzeugten Math Objektes (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Einsatz von Math.sin()

+ +
Math.sin(0);           // 0
+Math.sin(1);           // 0.8414709848078965
+
+Math.sin(Math.PI / 2); // 1
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.16', 'Math.sin')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.sin', 'Math.sin')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.sin', 'Math.sin')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.sin")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/sinh/index.html b/files/de/web/javascript/reference/global_objects/math/sinh/index.html new file mode 100644 index 0000000000..99e8d1e3c6 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/sinh/index.html @@ -0,0 +1,102 @@ +--- +title: Math.sinh() +slug: Web/JavaScript/Reference/Global_Objects/Math/sinh +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sinh +--- +
{{JSRef}}
+ +

Die Math.sinh() Funktion gibt den Sinus Hyperbolicus einer Zahl zurück. Dieser kann mit dem Einsatz der {{jsxref("Math.E", "Eulerschen Zahl", "", 1)}} folgendermaßen berechnet werden:

+ +

Math.sinh(x)=ex-e-x2\mathtt{\operatorname{Math.sinh(x)}} = \frac{e^x - e^{-x}}{2}

+ +
{{EmbedInteractiveExample("pages/js/math-sinh.html")}}
+ + + +

Syntax

+ +
Math.sinh(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl.
+
+ +

Rückgabewert

+ +

Den Sinus Hyperbolicus der übergebenen Zahl.

+ +

Beschreibung

+ +

Weil sinh() eine statische Funktion von Math ist, wird es immer als Math.sinh() eingesetzt, jedoch nicht als Methode eines erzeugten Math Objektes (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Einsatz von Math.sinh()

+ +
Math.sinh(0); // 0
+Math.sinh(1); // 1.1752011936438014
+
+ +

Polyfill

+ +

Diese Funktion kann mit Hilfe der Funktion {{jsxref("Math.exp()")}} emuliert werden:

+ +
Math.sinh = Math.sinh || function(x) {
+  return (Math.exp(x) - Math.exp(-x)) / 2;
+}
+
+ +

Oder nur mit einem Aufruf der {{jsxref("Math.exp()")}} Funktion:

+ +
Math.sinh = Math.sinh || function(x) {
+  var y = Math.exp(x);
+  return (y - 1 / y) / 2;
+}
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES2015', '#sec-math.sinh', 'Math.sinh')}}{{Spec2('ES2015')}}Initiale Definition.
{{SpecName('ESDraft', '#sec-math.sinh', 'Math.sinh')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.sinh")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/sqrt/index.html b/files/de/web/javascript/reference/global_objects/math/sqrt/index.html new file mode 100644 index 0000000000..a7ad903569 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/sqrt/index.html @@ -0,0 +1,99 @@ +--- +title: Math.sqrt() +slug: Web/JavaScript/Reference/Global_Objects/Math/sqrt +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sqrt +--- +
{{JSRef}}
+ +

Die Math.sqrt() Funktion gibt die Quadratwurzel einer Zahl zurück. Diese Ist Mathematisch folgendermaßen definiert:

+ +

∀x≥0,Math.sqrt(x)=x=einy≥0so dasy2=x\forall x \geq 0, \mathtt{Math.sqrt(x)} = \sqrt{x} = \text{the unique} \; y \geq 0 \; \text{such that} \; y^2 = x

+ +
{{EmbedInteractiveExample("pages/js/math-sqrt.html")}}
+ + + +

Syntax

+ +
Math.sqrt(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl.
+
+ +

Rückgabewert

+ +

Die Quadratwurzel der übergebenen Zahl. Wenn der Parameter negativ ist, wird {{jsxref("NaN")}} zurückgegeben.

+ +

Beschreibung

+ +

Wenn der Wert von x negativ ist, gibt Math.sqrt() {{jsxref("NaN")}} zurück.

+ +

Weil sqrt() eine statische Funktion von Math ist, wird es immer als Math.sqrt() eingesetzt, jedoch nicht als Methode eines erzeugten Math Objektes (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Einsatz von Math.sqrt()

+ +
Math.sqrt(9); // 3
+Math.sqrt(2); // 1.414213562373095
+
+Math.sqrt(1);  // 1
+Math.sqrt(0);  // 0
+Math.sqrt(-1); // NaN
+Math.sqrt(-0); // -0
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.17', 'Math.sqrt')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.sqrt', 'Math.sqrt')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.sqrt', 'Math.sqrt')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.sqrt")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/sqrt1_2/index.html b/files/de/web/javascript/reference/global_objects/math/sqrt1_2/index.html new file mode 100644 index 0000000000..19e1a24f4d --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/sqrt1_2/index.html @@ -0,0 +1,84 @@ +--- +title: Math.SQRT1_2 +slug: Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2 +tags: + - JavaScript + - Math + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2 +--- +
{{JSRef}}
+ +

Die Math.SQRT1_2 Eigenschaft repräsentiert die Quadratwurzel aus 1/2, welche gerundet 0,707 ist:

+ +

Math.SQRT1_2=12=12≈0,707\mathtt{\mi{Math.SQRT1_2}} = \sqrt{\frac{1}{2}} = \frac{1}{\sqrt{2}} \approx 0,707

+ +
{{EmbedInteractiveExample("pages/js/math-sqrt1_2.html")}}
+ + + +
{{js_property_attributes(0,0,0)}}
+ +

Beschreibung

+ +

Weil SQRT1_2 eine statische Eigenschaft von Math ist, muss immer Math.SQRT1_2 genutzt werden, ohne dass ein Math Objekt erstellt wird (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Einsatz von Math.SQRT1_2

+ +

Die folgende Funktion gibt die Quadratwurzel aus 1/2 zurück:

+ +
function getRoot1_2() {
+   return Math.SQRT1_2
+}
+
+getRoot1_2() // 0.7071067811865476
+ +

+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.1.7', 'Math.SQRT1_2')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.sqrt1_2', 'Math.SQRT1_2')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.sqrt1_2', 'Math.SQRT1_2')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.SQRT1_2")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/sqrt2/index.html b/files/de/web/javascript/reference/global_objects/math/sqrt2/index.html new file mode 100644 index 0000000000..14b748c555 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/sqrt2/index.html @@ -0,0 +1,82 @@ +--- +title: Math.SQRT2 +slug: Web/JavaScript/Reference/Global_Objects/Math/SQRT2 +tags: + - JavaScript + - Math + - Property + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT2 +--- +
{{JSRef}}
+ +

Die Math.SQRT2 Eigenschaft repräsentiert die Quadratwurzel aus 2, welche gerundet 1,414 ist:

+ +

Math.SQRT2=2≈1,414\mathtt{\mi{Math.SQRT2}} = \sqrt{2} \approx 1,414

+ +
{{EmbedInteractiveExample("pages/js/math-sqrt2.html")}}
+ + + +
{{js_property_attributes(0,0,0)}}
+ +

Beschreibung

+ +

Weil SQRT2 eine statische Eigenschaft von Math ist, muss immer Math.SQRT2 genutzt werden, ohne dass ein Math-Objekt erstellt wird (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Einsatz von Math.SQRT2

+ +

Die folgende Funktion gibt die Quadratwurzel aus 2 zurück:

+ +
function getRoot2() {
+   return Math.SQRT2
+}
+
+getRoot2() // 1.4142135623730951
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.1.8', 'Math.SQRT2')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.sqrt2', 'Math.SQRT2')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.sqrt2', 'Math.SQRT2')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.SQRT2")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/tan/index.html b/files/de/web/javascript/reference/global_objects/math/tan/index.html new file mode 100644 index 0000000000..92102e3ae2 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/tan/index.html @@ -0,0 +1,102 @@ +--- +title: Math.tan() +slug: Web/JavaScript/Reference/Global_Objects/Math/tan +tags: + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/tan +--- +
{{JSRef}}
+ +

Die Math.tan() Funktion gibt den Tangens einer Zahl.

+ +
{{EmbedInteractiveExample("pages/js/math-tan.html")}}
+ + + +

Syntax

+ +
Math.tan(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl im Winkelmaß (rad).
+
+ +

Rückgabewert

+ +

Den Tangens der übergebenen Zahl.

+ +

Beschreibung

+ +

Die Math.tan() Funktion gibt einen numerischen Wert zurück, welcher den Tangens eines Winkels repräsentiert.

+ +

Weil tan() eine statische Funktion von Math ist, wird es immer als Math.tan() eingesetzt, jedoch nicht als Methode eines erzeugten Math Objektes (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Einsatz von Math.tan()

+ +
Math.tan(1); // 1.5574077246549023
+
+ +

Weil die Math.tan() Funktion Werte im Winkelmaß erwartet, es aber oftmals einfacher ist mit Winkeln zu rechnen, nutzt die folgende Funktion Winkel (in Grad) und Convertiert diese in das Winkelmaß: 

+ +
function getTanDeg(deg) {
+  var rad = deg * Math.PI/180;
+  return Math.tan(rad);
+}
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.18', 'Math.tan')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.tan', 'Math.tan')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.tan', 'Math.tan')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.tan")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/tanh/index.html b/files/de/web/javascript/reference/global_objects/math/tanh/index.html new file mode 100644 index 0000000000..7bfa025f4e --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/tanh/index.html @@ -0,0 +1,93 @@ +--- +title: Math.tanh() +slug: Web/JavaScript/Reference/Global_Objects/Math/tanh +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/tanh +--- +
{{JSRef}}
+ +

Die Math.tanh() Funktion gibt den Tangens Hyperbolicus einer Zahl zurück. Dieser kann folgendermaßen errechnet werden:

+ +

tanhx=sinhxcoshx=ex-e-xex+e-x=e2x-1e2x+1\tanh x = \frac{\sinh x}{\cosh x} = \frac {e^x - e^{-x}} {e^x + e^{-x}} = \frac{e^{2x} - 1}{e^{2x}+1}

+ +
{{EmbedInteractiveExample("pages/js/math-tanh.html")}}
+ +

Syntax

+ +
Math.tanh(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl.
+
+ +

Rückgabewert

+ +

Den Tangens Hyperbolicus der übergebenen Zahl.

+ +

Beschreibung

+ +

Weil tanh() eine statische Funktion von Math ist, wird es immer als Math.tanh() eingesetzt, jedoch nicht als Methode eines erzeugten Math Objektes (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Einsatz von Math.tanh()

+ +
Math.tanh(0);        // 0
+Math.tanh(Infinity); // 1
+Math.tanh(1);        // 0.7615941559557649
+
+ +

Polyfill

+ +

Diese Funktion kann mit Hilfe der Funktion {{jsxref("Math.exp()")}} emuliert werden:

+ +
Math.tanh = Math.tanh || function(x){
+    var a = Math.exp(+x), b = Math.exp(-x);
+    return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (a + b);
+}
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES2015', '#sec-math.tanh', 'Math.tanh')}}{{Spec2('ES2015')}}Initiale Definition.
{{SpecName('ESDraft', '#sec-math.tanh', 'Math.tanh')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.tanh")}}

+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/math/trunc/index.html b/files/de/web/javascript/reference/global_objects/math/trunc/index.html new file mode 100644 index 0000000000..43aa34b2d7 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/math/trunc/index.html @@ -0,0 +1,125 @@ +--- +title: Math.trunc() +slug: Web/JavaScript/Reference/Global_Objects/Math/trunc +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Method + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/trunc +--- +
{{JSRef}}
+ +

Die Math.trunc() Funktion gibt den ganzzahligen Teil einer Zahl zurück, indem alle Nachkommastellen entfernt werden.

+ +
{{EmbedInteractiveExample("pages/js/math-trunc.html")}}
+ + + +

Syntax

+ +
Math.trunc(x)
+ +

Parameter

+ +
+
x
+
Eine Zahl.
+
+ +

Rückgabewert

+ +

Den ganzzahligen Teil der übergebenen Zahl.

+ +

Beschreibung

+ +

Im Gegensatz zu den drei Math Funktionen {{jsxref("Math.floor()")}}, {{jsxref("Math.ceil()")}} und {{jsxref("Math.round()")}} arbeitet Math.trunc() sehr einfach. Sie entfernt den Punkt und die Ziffern rechts davon, ohne zu beachten, ob es sich um eine positive oder negative Nummer handelt.

+ +

Beim übergeben eines Parameters wird dieser implizit in einen Nummern-Typ konvertiert.

+ +

Weil trunc() eine statische Funktion von Math ist, wird es immer als Math.trunc() eingesetzt, jedoch nicht als Methode eines erzeugten Math Objektes (Math ist kein Konstruktor).

+ +

Beispiele

+ +

Einsatz von Math.trunc()

+ +
Math.trunc(13.37);    // 13
+Math.trunc(42.84);    // 42
+Math.trunc(0.123);    //  0
+Math.trunc(-0.123);   // -0
+Math.trunc('-1.123'); // -1
+Math.trunc(NaN);      // NaN
+Math.trunc('foo');    // NaN
+Math.trunc();         // NaN
+
+ +

Polyfill

+ +
if(!Math.trunc) {
+  Math.trunc = function(v) {
+    v = +v;
+    if(!isFinite(v)) return v;
+
+    return (v - v % 1)   ||   (v < 0 ? -0 : v === 0 ? v : 0);
+
+    // returns:
+    //  0        ->  0
+    // -0        -> -0
+    //  0.2      ->  0
+    // -0.2      -> -0
+    //  0.7      ->  0
+    // -0.7      -> -0
+    //  Infinity ->  Infinity
+    // -Infinity -> -Infinity
+    //  NaN      ->  NaN
+    //  null     ->  0
+  };
+}
+ +

oder:

+ +
if(!Math.trunc) {
+  Math.trunc = function(v) {
+    return v < 0 ? Math.ceil(v) : Math.floor(v);
+  }
+}
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES2015', '#sec-math.trunc', 'Math.trunc')}}{{Spec2('ES2015')}}Initiale Definition.
{{SpecName('ESDraft', '#sec-math.trunc', 'Math.trunc')}}{{Spec2('ESDraft')}}
+ +

Browserkompatibilität

+ + + +

{{Compat("javascript.builtins.Math.trunc")}}

+ +

Siehe auch

+ + -- cgit v1.2.3-54-g00ecf