path: root/files/de/web/javascript/guide/numbers_and_dates/index.html

---
title: Numbers and dates
slug: Web/JavaScript/Guide/Numbers_and_dates
tags:
  - Guide
  - JavaScript
  - 'l10n:priority'
translation_of: Web/JavaScript/Guide/Numbers_and_dates
---
<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Ausdruecke_und_Operatoren", "Web/JavaScript/Guide/Text_formatting")}}</div>

<p class="summary">Dieses Kapitel ist eine Einleitung in die Nutzung von Nummern und Daten in JavaScript.</p>

<h2 id="Nummern">Nummern</h2>

<p>In JavaScript sind alle Nummern als <a class="external external-icon" href="https://en.wikipedia.org/wiki/Double-precision_floating-point_format">double-precision 64-Bit Binärformat IEEE 754</a> umgesetzt (z.b. eine Zahl zwischen -(2<sup>53</sup> -1) und 2<sup>53</sup> -1). <strong>Es gibt keinen extra Datentypen für ganze Zahlen </strong>(z. B. Integer in anderen Programmiersprachen). Neben der Repräsentation von Gleitkommazahlen hat der Nummern Typ noch drei symbolische Werte: <code>+</code>{{jsxref("Infinity")}}, <code>-</code>{{jsxref("Infinity")}}, und {{jsxref("NaN")}} (not-a-number; keine Nummer). Siehe auch in das Kapitel <a href="/de/docs/Web/JavaScript/Datenstrukturen">JavaScript Datentypen und Strukturen</a> für den Umgang mit anderen primitiven Typen in JavaScript.</p>

<p>Es gibt vier verschiedene Nummernliterale: Dezimal-, Binär-, Oktal- und Hexadezimalzahlen.</p>

<h3 id="Dezimalzahlen">Dezimalzahlen</h3>

<pre class="brush: js">1234567890
42

// Vorsichtig mit führenden Nullen in der Darstellung:

0888 // wird zu 888 Dezimal
0777 // wird im non-strict Modus zu 511 in Dezimal
</pre>

<p>Zu beachten ist, dass das Dezimalliteral mit einer 0 beginnen kann, jedoch wird die Zahl als Oktalzahl interpretiert, wenn die nächste Zahl nach der 0 kleiner als 8 ist.</p>

<h3 id="Binärzahlen">Binärzahlen</h3>

<p>Die Syntax von Binärzahlen schreibt vor, dass die Zahl mit einer 0 gefolgt von einem "B" (0b oder 0B) beginnen muss. Wenn die Ziffern nach dem 0b nicht 0 oder 1 sind, wird der folgenden <code><a href="/de/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError">SyntaxError</a></code> erzeugt: "Missing binary digits after 0b".</p>

<pre class="brush: js">var FLT_SIGNBIT  = 0b10000000000000000000000000000000; // 2147483648
var FLT_EXPONENT = 0b01111111100000000000000000000000; // 2139095040
var FLT_MANTISSA = 0B00000000011111111111111111111111; // 8388607</pre>

<h3 id="Oktalzahlen">Oktalzahlen</h3>

<p>Die Syntax von Oktalzahlen schreibt vor, dass die Nummern mit einer 0 beginnen. Dahinter sind Ziffern mit den Werten 0 bis 7 möglich. Wenn die Ziffern größer als 7 sind, wird die Zahl als Dezimalzahl interpretiert.</p>

<pre class="brush: js">var n = 0755; // 493
var m = 0644; // 420
</pre>

<p>Der Strict mode in ECMAScript 5 verbietet Oktalzahlen. Die Syntax der Oktalzahlen ist in ECMAScript 5 nicht vorhanden, jedoch wird es von allen Browser, durch eine führende 0, unterstützt: <code>0644 === 420</code> und<code> "\045" === "%"</code>. In ECMAScript 2015 sind Oktalzahlen mit dem Präfix <code>0o</code> unterstützt:</p>

<pre class="brush: js">var a = 0o10; // ES2015: 8
</pre>

<h3 id="Hexadezimalzahlen">Hexadezimalzahlen</h3>

<p>Hexadezimalzahlen können geschrieben werden, indem der Präfix <code>0x</code> oder <code>0X</code> genutzt wird. Wenn die Ziffern nach 0x nicht eines der Zeichen 0123456789ABCDEF entspricht, wird folgender <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError">SyntaxError</a></code>  erzeugt: "Identifier starts immediately after numeric literal".</p>

<pre>0xFFFFFFFFFFFFFFFFF // 295147905179352830000
0x123456789ABCDEF   // 81985529216486900
0XA                 // 10
</pre>

<h3 id="Potenzierung">Potenzierung</h3>

<pre>1E3   // 1000
2e6   // 2000000
0.1e2 // 10</pre>

<h2 id="Number_Objekt"><code>Number</code> Objekt</h2>

<p>Das vordefinierte {{jsxref("Number")}} Objekt enthält Eigenschaften für nummerische Konstanten, wie zum Beispiel Maximalwerte, not-a-number (keine Nummer) und Unendlich. Man kann die Werte dieser Eigenschaften nicht ändern. Die Eigenschaften werden folgendermaßen eingesetzt:</p>

<pre class="brush: js">var biggestNum = Number.MAX_VALUE;
var smallestNum = Number.MIN_VALUE;
var infiniteNum = Number.POSITIVE_INFINITY;
var negInfiniteNum = Number.NEGATIVE_INFINITY;
var notANum = Number.NaN;
</pre>

<p>Man verweist immer auf die Eigenschaften des vordefinierten <code>Number</code> Objekt (wie oben gezeigt) und nicht auf die Eigenschaft eines selbst erstellten <code>Number</code> Objektes.</p>

<p>Die folgende Tabelle fasst du Eigenschaften des <code>Number</code> Objektes zusammen:</p>

<table class="standard-table">
 <caption>Eigenschaften von <code>Number</code></caption>
 <thead>
  <tr>
   <th scope="col">Eigenschaft</th>
   <th scope="col">Beschreibung</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td>{{jsxref("Number.MAX_VALUE")}}</td>
   <td>Die größte repräsentierbare Zahl</td>
  </tr>
  <tr>
   <td>{{jsxref("Number.MIN_VALUE")}}</td>
   <td>Die kleinste repräsentierbare Zahl</td>
  </tr>
  <tr>
   <td>{{jsxref("Number.NaN")}}</td>
   <td>Spezieller Wert für "keine Zahl" ("not a number")</td>
  </tr>
  <tr>
   <td>{{jsxref("Number.NEGATIVE_INFINITY")}}</td>
   <td>Spezieller Wert für negativ Unendlich; wird bei einem Overflow zurückgegeben.</td>
  </tr>
  <tr>
   <td>{{jsxref("Number.POSITIVE_INFINITY")}}</td>
   <td>Spezieller Wert für positiv Unendlich; wird bei einem Overflow zurückgegeben.</td>
  </tr>
  <tr>
   <td>{{jsxref("Number.EPSILON")}}</td>
   <td>Der Unterschied zwischen eins und der kleinsten Zahl größer als eins, die als {{jsxref("Number")}} repräsentiert werden kann.</td>
  </tr>
  <tr>
   <td>{{jsxref("Number.MIN_SAFE_INTEGER")}}</td>
   <td>Kleinste sichere ganze Zahl in JavaScript.</td>
  </tr>
  <tr>
   <td>{{jsxref("Number.MAX_SAFE_INTEGER")}}</td>
   <td>Größte sichere ganze Zahl in JavaScript.</td>
  </tr>
 </tbody>
</table>

<table class="standard-table">
 <caption>Methoden von <code>Number</code></caption>
 <thead>
  <tr>
   <th>Methode</th>
   <th>Beschreibung</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td>{{jsxref("Number.parseFloat()")}}</td>
   <td>Liest eine String-Argument ein und gibt eine Floating-Point Zahl zurück.<br>
    Macht das gleiche wie die globale {{jsxref("parseFloat", "parseFloat()")}} Funktion.</td>
  </tr>
  <tr>
   <td>{{jsxref("Number.parseInt()")}}</td>
   <td>Liest eine String-Argument ein und gibt eine ganze Zahl in der spezifizierten Basis zurück.<br>
    Macht das gleiche wie die globale {{jsxref("parseInt", "parseInt()")}} Funktion.</td>
  </tr>
  <tr>
   <td>{{jsxref("Number.isFinite()")}}</td>
   <td>Erkennt, ob ein übergebener Wert eine endliche Zahl ist.</td>
  </tr>
  <tr>
   <td>{{jsxref("Number.isInteger()")}}</td>
   <td>Erkennt, ob ein übergebener Wert eine ganze Zahl ist.</td>
  </tr>
  <tr>
   <td>{{jsxref("Number.isNaN()")}}</td>
   <td>Erkennt, ob ein übergebener Wert {{jsxref("Global_Objects/NaN", "NaN")}} ist. Diese Funktion ist eine robustere Version der globalen {{jsxref("Global_Objects/isNaN", "isNaN()")}} Funktion</td>
  </tr>
  <tr>
   <td>{{jsxref("Number.isSafeInteger()")}}</td>
   <td>Erkennt, ob ein übergebener Wert eine sichere ganze Zahl ist.</td>
  </tr>
 </tbody>
</table>

<p>Der <code>Number</code> Prototyp enthält Methoden zum Zurückgeben von Informationen eines <code>Number</code> Objekts in verschiedenen Formaten. Die folgende Tabelle fasst die Methoden von <code>Number.prototype</code> zusammen:</p>

<table class="standard-table">
 <caption>Methoden von <code>Number.prototype</code></caption>
 <thead>
  <tr>
   <th scope="col">Methode</th>
   <th scope="col">Beschreibung</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td>{{jsxref("Number.toExponential", "toExponential()")}}</td>
   <td>Gibt eine String-Repräsentation der Zahl in Exponential-Notation zurück.</td>
  </tr>
  <tr>
   <td>{{jsxref("Number.toFixed", "toFixed()")}}</td>
   <td>Gibt eine String-Repräsentation der Zahl in Festkomma-Notation zurück.</td>
  </tr>
  <tr>
   <td>{{jsxref("Number.toPrecision", "toPrecision()")}}</td>
   <td>Gibt eine String-Repräsentation der Zahl in einer spezifizierten Präzision in der Festkomma-Notation zurück.</td>
  </tr>
 </tbody>
</table>

<h2 id="Math_Objekt"><code>Math</code> Objekt</h2>

<p>Das eingebaute {{jsxref("Math")}} Objekt hat Eigenschaften und Methoden für mathematische Konstanten und Funktionen. Zum Beispiel enthält die Eigenschaft <code>PI</code> des <code>Math</code> Objektes den Wert von Pi (3,141...), welche wie folgt in einer Anwendung eingesetzt wird:</p>

<pre class="brush: js">Math.PI
</pre>

<p>Genauso sind mathematische Standardfunktionen Methoden von <code>Math</code>. Dabei sind trigonometrische, logarithmische, exponentielle und ander Funktionen enthalten. Zum Beispiel wird eine trigonometrische Funktion wie folgt eingesetzt:</p>

<pre class="brush: js">Math.sin(1.56)
</pre>

<p>Alle trigonometrischen Funktionen von <code>Math</code> erwarten Argumente im Radiantenmaß.</p>

<p>Die folgende Tabelle fasst die Methoden des <code>Math</code> Objektes zusammen:</p>

<table class="standard-table">
 <caption>Methoden von <code>Math</code></caption>
 <thead>
  <tr>
   <th scope="col">Methode</th>
   <th scope="col">Beschreibung</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td>{{jsxref("Math.abs", "abs()")}}</td>
   <td>Absoluter Wert.</td>
  </tr>
  <tr>
   <td>{{jsxref("Math.sin", "sin()")}}, {{jsxref("Math.cos", "cos()")}}, {{jsxref("Math.tan", "tan()")}}</td>
   <td>Trigonometrische Standardfunktionen; Argumente im Radiantenmaß.</td>
  </tr>
  <tr>
   <td>{{jsxref("Math.asin", "asin()")}}, {{jsxref("Math.acos", "acos()")}}, {{jsxref("Math.atan", "atan()")}}, {{jsxref("Math.atan2", "atan2()")}}</td>
   <td>Inverse trigonometrische Standardfunktionen; Rückgabewert im Radiantenmaß.</td>
  </tr>
  <tr>
   <td>{{jsxref("Math.sinh", "sinh()")}}, {{jsxref("Math.cosh", "cosh()")}}, {{jsxref("Math.tanh", "tanh()")}}</td>
   <td>Hyperbolische trigonometrische Standardfunktionen; Rückgabewert im Radiantenmaß.</td>
  </tr>
  <tr>
   <td>{{jsxref("Math.asinh", "asinh()")}}, {{jsxref("Math.acosh", "acosh()")}}, {{jsxref("Math.atanh", "atanh()")}}</td>
   <td>Inverse hyperbolische trigonometrische Standardfunktionen; Rückgabewert im Radiantenmaß.</td>
  </tr>
  <tr>
   <td>
    <p>{{jsxref("Math.pow", "pow()")}}, {{jsxref("Math.exp", "exp()")}}, {{jsxref("Math.expm1", "expm1()")}}, {{jsxref("Math.log10", "log10()")}}, {{jsxref("Math.log1p", "log1p()")}}, {{jsxref("Math.log2", "log2()")}}</p>
   </td>
   <td>Exponential- und Logarithmus-Funktionen.</td>
  </tr>
  <tr>
   <td>{{jsxref("Math.floor", "floor()")}}, {{jsxref("Math.ceil", "ceil()")}}</td>
   <td>Gibt die größte/kleinste ganze Zahl kleiner/größer oder gleich dem Argument zurück.</td>
  </tr>
  <tr>
   <td>{{jsxref("Math.min", "min()")}}, {{jsxref("Math.max", "max()")}}</td>
   <td>Gibt den kleinsten oder den größten Wert aus einer mit Komma getrennten Liste von Zahlen.</td>
  </tr>
  <tr>
   <td>{{jsxref("Math.random", "random()")}}</td>
   <td>Gibt eine Zufallszahl zwischen 0 und 1 zurück.</td>
  </tr>
  <tr>
   <td>{{jsxref("Math.round", "round()")}}, {{jsxref("Math.fround", "fround()")}}, {{jsxref("Math.trunc", "trunc()")}},</td>
   <td>Rundungs- und Abschnittsfunktionen.</td>
  </tr>
  <tr>
   <td>{{jsxref("Math.sqrt", "sqrt()")}}, {{jsxref("Math.cbrt", "cbrt()")}}, {{jsxref("Math.hypot", "hypot()")}}</td>
   <td>Quadratwurzel, kubische Wurzel, Quadratwurzel von der Summe von Quadrierten Argumenten.</td>
  </tr>
  <tr>
   <td>{{jsxref("Math.sign", "sign()")}}</td>
   <td>Das Vorzeichen einer Zahl, welches Angibt, ob eine Zahl positiv, negativ oder null ist.</td>
  </tr>
  <tr>
   <td>{{jsxref("Math.clz32", "clz32()")}},<br>
    {{jsxref("Math.imul", "imul()")}}</td>
   <td>Anzahl der führenden 0-Bits in der 32-Bit Binärrepräsentation.<br>
    Das Resultat der C-Ähnlichen 32-Bit Multiplikation von 2 Argumenten.</td>
  </tr>
 </tbody>
</table>

<p>Im Gegensatz zu vielen Anderen Objekten, erzeigt man nie selber ein neues <code>Math</code> Objekt. Man benutzt immer das globale Objekt.</p>

<h2 id="Date_Objekt"><code>Date</code> Objekt</h2>

<p>JavaScript hat keinen Datums-Datentypen. Allerdings kann das {{jsxref("Date")}} Objekt und seine Methoden genutzt werden, um mit Daten und Zeiten in einer Applikation zu arbeiten. Das <code>Date</code>-Objekt hat sehr viele Methoden für das Einstellen, Abfragen und Manipulieren von Daten. Es hat keine Eigenschaften.</p>

<p>JavaScript verarbeitet Daten ähnlich wie es in Java gemacht wird. In beiden Sprachen sind viele Methoden gleich und beide Sprachen speichern das Datum als Unix Zeitstempel, also die Anzahl der Millisekunden seit dem 1. Januar 1970 00:00:00, ab.</p>

<p>Der Wertebereich eines <code>Date</code> Objektes ist zwischen -100.000.000 und 100.000.000 Tagen relativ zum 1. Januar 1970 UTC.</p>

<p>Das erstellen eines <code>Date</code> Objektes:</p>

<pre class="brush: js">var dateObjectName = new Date([parameters]);
</pre>

<p>Dabei ist <code>dateObjectName</code> der Name der Variablen, in der das erstellte <code>Date</code> Objekt gespeichert wird.</p>

<p>Unter <code>parameters</code> können folgenden Werte eingesetzt werden:</p>

<ul>
 <li>Nichts: Erstellt das aktuelle Datum mit der aktuellen Zeit. Zum Beispiel: <code>today = new Date();</code>.</li>
 <li>Eine Stringrepräsentation eines Datums mit folgenden Werten: "Monat Tag, Jahr Stunde:Minute:Sekunde". Zum Beispiel: <code>var Xmas95 = new Date("December 25, 1995 13:30:00")</code>. Wenn die Stunden, Minuten und Sekunden nicht angegeben werden, werden diese auf 0 gesetzt.</li>
 <li>Eine Menge von ganzen Zahlen für das Jahr, den Monat und den Tag. Zum Beispiel: <code>var Xmas95 = new Date(1995, 11, 25)</code>.</li>
 <li>Eine Menge von ganzen Zahlen für das Jahr, den Monat, den Tag, die Stunde, die Minute und die Sekunde. Zum Beispiel: <code>var Xmas95 = new Date(1995, 11, 25, 9, 30, 0)</code>.</li>
</ul>

<h3 id="Methoden_des_Date_Objektes">Methoden des <code>Date</code> Objektes</h3>

<p>Das Methoden des <code>Date</code> Objektes für die Behandlung von Daten und Zeiten werden in folgende Kategorien eingeteilt:</p>

<ul>
 <li>"set"-Methoden für das Einstellten von Datums- und Zeit-Werten eines <code>Date</code>-Objektes.</li>
 <li>"get"-Methoden für das Abfragen von Datums- und Zeit-Werten eines <code>Date</code>-Objektes.</li>
 <li>"to"-Methoden für das Erstellen von String-Werten eines <code>Date</code>-Objektes.</li>
 <li>"parse"- und "UTC"-Methoden für das Einlesen von String-Werten.</li>
</ul>

<p>Mit den "get"- und "set"-Methoden können Sekunden, Minuten, Stunden, Tag des Monats, Wochentag, Monat und Jahr separat eingestellt und abgefragt werden. Es gibt eine <code>getDay</code>-Methode, welche den Wochentag zurückgibt, es gibt aber keine vergleichbare <code>setDay</code>-Methode, weil der Wochentag automatisch eingestellt wird. Diese Methoden benutzen ganze Zahlen um folgende Werte darzustellen:</p>

<ul>
 <li>Sekunden und Minuten: 0 bis 59</li>
 <li>Stunden: 0 bis 23</li>
 <li>Tage: 0 (Sonntage) bis 6 (Samstag)</li>
 <li>Tag (des Monats): 1 bis 31</li>
 <li>Monat: 0 (Januar) bis 11 (Dezember)</li>
 <li>Jahr: Jahre seit 1900</li>
</ul>

<p>Angenommen, man erstellt folgendes Datum:</p>

<pre class="brush: js">var Xmas95 = new Date("December 25, 1995");
</pre>

<p>Dann gibt <code>Xmas95.getMonth()</code> 11 zurück und <code>Xmas95.getFullYear()</code> gibt 1995 zurück.</p>

<p>Die <code>getTime</code> und <code>setTime</code> Methoden sind nützlich für das Vergleichen von Daten. Die <code>getTime</code> Methode gibt die Anzahl der Millisekunden seit dem 1. Januar 1970 00:00:00 eines <code>Date</code>-Objektes zurück.</p>

<p>Der folgende Quelltext zeigt, wie die Anzahl der vergangenen Tage des aktuellen Jahres ermittelt werden kann:</p>

<pre class="brush: js">var today = new Date();
var endYear = new Date(1995, 11, 31, 23, 59, 59, 999); // Stellt den Tag und den Monat ein
endYear.setFullYear(today.getFullYear()); // Stellt das Jahr auf das aktuelle Jahr
var msPerDay = 24 * 60 * 60 * 1000; // Anzahl der Millisekunden pro Tag
var daysLeft = (endYear.getTime() - today.getTime()) / msPerDay;
var daysLeft = Math.round(daysLeft); //gibt die vergangenen Tage des aktuellen Jahres zurück
</pre>

<p>Diese Beispiel erstellt ein <code>Date</code>-Objekt namens <code>today</code>, welches das aktuelle Datum und die aktuelle Zeit enthält. Danach wird ein das <code>Date</code>-Objekt <code>endYear</code> erstellt und das Jahr wird auf das aktuelle Jahr eingestellt. Zum Schluss wird, mithilfe der Millisekunden pro Tag, die Anzahl der Tage zwischen <code>today</code> und <code>endYear</code> berechnet. Dafür wird die <code>getTime</code> Methode eingesetzt und es wird auf eine ganze Zahl von Tagen gerundet.</p>

<p>Die <code>parse</code> Methode ist nützlich, um ein <code>Date</code>-Objekt aus einem String zu erstellen. Zum Beispiel verwendet der folgende Quelltext <code>parse</code> und <code>setTime</code> um das <code>IPOdate</code> einzustellen:</p>

<pre class="brush: js">var IPOdate = new Date();
IPOdate.setTime(Date.parse("Aug 9, 1995"));
</pre>

<h3 id="Beispiel">Beispiel</h3>

<p>Im folgenden Beispiel, gibt die <code>JSClock()</code> Funktion die Zeit in dem Format einer digitalen Uhr zurück.</p>

<pre class="brush: js">function JSClock() {
  var time = new Date();
  var hour = time.getHours();
  var minute = time.getMinutes();
  var second = time.getSeconds();
  var temp = "" + ((hour &gt; 12) ? hour - 12 : hour);
  if (hour == 0)
    temp = "12";
  temp += ((minute &lt; 10) ? ":0" : ":") + minute;
  temp += ((second &lt; 10) ? ":0" : ":") + second;
  temp += (hour &gt;= 12) ? " P.M." : " A.M.";
  return temp;
}
</pre>

<p>Die <code>JSClock</code> Funktion erstellt als erstes ein neues <code>Date</code> Objekt mit dem Namen <code>time</code>. Weil dabei keine Argumente angegeben werden, wird <code>time</code> mit dem aktuellen Datum und der aktuellen Zeit erstellt. Danach werden die Methoden <code>getHours</code>, <code>getMinutes</code>, und <code>getSeconds</code> eingesetzt, um den Wert der aktuellen Stunde, Minute und Sekunde in den Variablen  <code>hour</code>, <code>minute</code>, und <code>second</code> zu speichern.</p>

<p>Die nächsten vier Statements bauen einen String-Wert mit der Zeit zusammen. Das erste Statement erstellt eine Variable <code>temp</code> und weist dieser einen Wert mit einem bedingten Ausdruck zu; wenn <code>hour</code> größer als 12 ist wird <code>hour - 12</code> zugewiesen, andernfalls nur <code>hour</code>. Wenn <code>hour</code> dann 0 ist, wird <code>hour</code> auf 12 gesetzt.</p>

<p>Die nächsten Statement hängt einen den <code>minute</code>-Wert an <code>temp</code> heran. Wenn der Wert von <code>minute</code> kleiner als 10 ist, fügt der Bedingte Ausdruck einen String mit einer Null und einem Doppelpunkt an; andernfalls wird nur ein Doppelpunkt angehängt. Danach werden die Sekunden auf die gleiche weise angehängt.</p>

<p>Zum Schluss fügt ein bedingter Ausdruck "P.M." an <code>temp</code> an, wenn die <code>hour</code> größer oder gleich 12 ist. Andernfalls wird "A.M." an <code>temp</code> angefügt.</p>

<p>{{PreviousNext("Web/JavaScript/Guide/Ausdruecke_und_Operatoren", "Web/JavaScript/Guide/Text_formatting")}}</p>