## Ganzzahlen (Integer)

Ein int ist eine Zahl aus der Menge ℤ = {..., -2, -1, 0, 1, 2, ...}.

### Siehe auch

- Gleitkommazahlen
- Rechnen mit beliebiger Genauigkeit (BCMath)
- Rechnen mit ganzen Zahlen mit beliebiger Genauigkeit (GMP)

### Syntax

Ints können in dezimaler (Basis 10), hexadezimaler (Basis 16), oktaler (Basis 8) oder binärer (Basis 2) Schreibweise angegeben werden. Der Negationsoperator kann verwendet werden, um einen negativen int anzugeben.

Um die oktale Schreibweise zu verwenden, wird der Zahl eine `0` (Null) vorangestellt. Seit PHP 8.1.0 kann der oktalen Schreibweise auch ein `0o` oder `0O` vorangestellt werden. Um die hexadezimale Schreibweise zu verwenden, muss der Zahl `0x` vorangestellt werden, für die binäre Schreibweise `0x`.

Um die Lesbarkeit von Integer-Literalen zu verbessern, dürfen diese seit PHP 7.4.0 Unterstriche (`_`) zwischen den Ziffern enthalten. Diese Unterstriche werden von PHPs Scanner entfernt.

Beispiel #1 Integer-Literale

`<?php
$a = 1234; // Dezimalzahl
$a = 0123; // Oktalzahl (entspricht 83 dezimal)
$a = 0o123; // Oktalzahl (ab PHP 8.1.0)
$a = 0x1A; // Hexadezimalzahl (entspricht 26 dezimal)
$a = 0b11111111; // Binärzahl (entspricht 255 dezimal)
$a = 1_234_567; // Dezimalzahl (ab PHP 7.4.0)
?>`

Seit PHP 8.1.0 ist die Struktur für int-Literale formal wie folgt definiert (vorher waren die Oktalpräfixe `0o` und `0O` nicht erlaubt, und vor PHP 7.4.0 waren die Unterstriche nicht erlaubt):

    dezimal     : [1-9][0-9]*(_[0-9]+)*
                | 0

    hexadezimal : 0[xX][0-9a-fA-F]+(_[0-9a-fA-F]+)*

    oktal       : 0[oO]?[0-7]+(_[0-7]+)*

    binär       : 0[bB][01]+(_[01]+)*

    ganzzahlig  : dezimal
                | hexadezimal
                | oktal
                | binär

Die Größe eines Werts vom Typ int ist plattformabhängig, wobei der Maximalwert normalerweise bei etwa zwei Milliarden liegt (das sind 32 Bit mit Vorzeichen). Bei 64-Bit-Plattformen liegt der Maximalwert normalerweise bei etwa 9E18. PHP unterstützt keine vorzeichenlosen ints. Die Größe von int kann mit der Konstante `PHP_INT_SIZE` ermittelt werden, der maximale Wert mit der Konstante `PHP_INT_MAX` und der minimale Wert mit der Konstante `PHP_INT_MIN`.

### Integer-Überlauf

Wenn eine Zahl außerhalb der Grenzen des Typs int liegt, interpretiert PHP sie stattdessen als float. Auch eine Operation, die eine Zahl außerhalb der Grenzen des Typs int ergibt, gibt stattdessen einen Float zurück.

Beispiel #2 Integer-Überlauf

`<?php
$large_number = 50000000000000000000;
var_dump($large_number); // float(5.0E+19)
var_dump(PHP_INT_MAX + 1); // 32-bit-System: float(2147483648)
// 64-bit-System: float(9.2233720368548E+18)
?>`

### Integer-Division

In PHP gibt es keinen Operator für die Division von int. Dafür kann die Funktion intdiv() verwendet werden. Das Ergebnis von `1/2` ist der Float-Wert `0.5`. Der Wert kann in einen int umgewandelt werden, um ihn auf Null zu runden. Alternativ dazu kann die Funktion round() verwendet werden, die eine feinere Kontrolle über das Runden ermöglicht.

Beispiel #3 Divisionen

`<?php
var_dump(25/7); // float(3.5714285714286)
var_dump((int) (25/7)); // int(3)
var_dump(round(25/7)); // float(4)
?>`

### Umwandlung in Integer

Um einen Wert explizit in int umzuwandeln, kann entweder `(int)` oder `(integer)` verwendet werden. In den meisten Fällen ist das jedoch nicht nötig, weil ein Wert automatisch umgewandelt wird, wenn ein Operator, eine Funktion oder eine Kontrollstruktur ein Argument vom Typ int benötigt. Ein Wert kann auch mit der Funktion intval() in int umgewandelt werden.

Wenn eine Ressource in int umgewandelt wird, dann ist das Ergebnis die eindeutige Nummer der Ressource, die der Ressource von PHP zur Laufzeit zugewiesen wird.

Siehe auch Typumwandlung.

#### Von Booleans

`false` ergibt `0` (Null) und `true` ergibt `1` (Eins).

#### Von Gleitkommazahlen

Bei der Umwandlung von float nach int wird die Zahl abgerundet. Seit PHP 8.1.0 wird davon abgeraten, einen nicht-ganzzahligen Float in Integer umzuwandeln, weil dabei die Genauigkeit abnimmt.

Beispiel #4 Umwandlung von Float

`<?php
function foo($value): int {
return $value;
}
var_dump(foo(8.1)); // seit PHP 8.1.0: "Deprecated: Implicit conversion from float 8.1 to int loses precision"
var_dump(foo(8.1)); // bis PHP 8.1.0: 8
var_dump(foo(8.0)); // in beiden Fällen 8
var_dump((int) 8.1); // in beiden Fällen 8
var_dump(intval(8.1)); // in beiden Fällen 8
?>`

Wenn der Float-Wert außerhalb der Grenzen von int liegt (auf 32-bit-Plattformen normalerweise `+/- 2.15e+9 = 2^31` und auf 64-bit-Plattformen `+/- 9.22e+18 = 2^63`), ist das Ergebnis undefiniert. Das liegt daran, dass der Typ float nicht genau genug ist, um ein exaktes Ergebnis für den Typ int zu liefern. In diesem Fall wird keine Warnung und nicht einmal ein Hinweis ausgegeben!

> Hinweis:

> Wenn `NaN`, `Inf` und `-Inf` in int umgewandelt werden, ergibt dies immer Null.

Warnung

Eine unbekannte Bruchzahl sollte niemals in int umgewandelt werden, weil dies manchmal zu unerwarteten Ergebnissen führen kann.

`<?php
echo (int) ( (0.1+0.7) * 10 ); // gibt 7 aus!
?>`

Siehe auch den Warnhinweis zur Genauigkeit von Gleitkommazahlen.

#### Von einer Zeichenkette

Wenn eine Zeichenkette numerisch ist oder numerisch beginnt, wird sie in den entsprechenden Integer-Wert umgewandelt, andernfalls wird sie in Null (`0`) umgewandelt.

#### Von NULL

`null` wird immer in Null (`0`) umgewandelt.

#### Von anderen Typen

Achtung

Für andere Typen ist das Verhalten bei der Umwandlung in int undefiniert. Es ist nicht empfehlenswert, sich auf ein beobachtetes Verhalten zu verlassen, da es sich ohne Vorankündigung ändern kann.

`↑` and `↓` to navigate • `Enter` to select • `Esc` to close • `/` to open