Rechercher une fonction PHP

Bit-Operatoren

Inhaltsverzeichnis

Bit-Operatoren erlauben es die Prüfung und Manipulation von bestimmten Bits in einem Integer.

Bit-Operatoren
Beispiel Name Ergebnis
$a & $b Und Bits, die in $a und $b gesetzt sind, werden gesetzt.
$a | $b Oder Bits, die in $a oder $b gesetzt sind, werden gesetzt.
$a ^ $b Entweder oder (Xor) Bits, die entweder in $a oder $b, jedoch nicht in beiden gesetzt sind, werden gesetzt.
~ $a Nicht Bits, die in $a nicht gesetzt sind, werden gesetzt, und umgekehrt.
$a << $b Nach links verschieben Verschiebung der Bits von $a um $b Stellen nach links (jede Stelle entspricht einer Mulitplikation mit zwei).
$a >> $b Nach rechts verschieben Verschiebung der Bits von $a um $b Stellen nach rechts (jede Stelle entspricht einer Division durch zwei).

Bit-Verschiebungen in PHP sind arithmetisch. Bits, die an einem der Enden herausgeschoben werden, werden verworfen. Bei Links-Verschiebungen werden von rechts Nullen hereingeschoben, während das Vorzeichenbit links herausgeschoben wird, was bedeutet, dass das Vorzeichen des Operanden nicht erhalten bleibt. Bei Rechts-Verschiebungen werden Kopien des Vorzeichenbits von links hereingeschoben, so dass das Vorzeichen des Operand erhalten bleibt.

Klammern sind zu verwenden, um die gewünschte Rangfolge sicherzustellen. Beispielsweise wird bei $a & $b == true zunächst der Vergleich ausgewertet, und erst dann das Bit-Und, während bei ($a & $b) == true zunächst das Bit-Und, und erst dann der Vergleich ausgewertet wird.

Sind beide Operanden der &, | und ^ Operatoren Zeichenketten, dann wird die Operation auf den ASCII-Werten der Zeichen der Zeichenketten durchgeführt, und das Ergebnis ist wiederum eine Zeichenkette. In allen anderen Fällen werden beide Operanden nach Integer umgewandelt, und das Ergebnis ist eine Ganzzahl.

Ist der Operand des ~ Operators eine Zeichenkette, dann wird die Operation auf den ASCII-Werten der Zeichen der Zeichenkette durchgeführt, Und das Ergebnis ist wiederum eine Zeichenkette. Andernfalls werden Operand und Ergebnis als Ganzzahl behandelt.

Beide Operanden und das Ergebnis der << und >> Operatoren werden immer als Ganzzahl behandelt. 

Die error_reporting ini-Einstellung von PHP verwendet Bitwerte, was die
realitätsnahe Demonstration des Ausschaltens einzelner Bits bietet. Um alle
Fehler außer Hinweisen anzuzeigen, weist die php.ini Datei an folgendes zu tun:
E_ALL & ~E_NOTICE
      

Dies funktioniert, indem mit E_ALL begonnen wird:
00000000000000000111011111111111
Dann wird der Wert von E_NOTICE genommen...
00000000000000000000000000001000
... und dieser per ~ invertiert:
11111111111111111111111111110111
Schließlich wird UND (&) verwendet, um die Bits zu ermitteln, die in
beiden Werten gesetzt sind:
00000000000000000111011111110111
      

Eine andere Möglichkeit dies zu bewerkstelligen, ist XOR (^)
zu verwenden, um diejenigen Bits zu finden, die nur in einem der beiden Werte
gesetzt sind:
E_ALL ^ E_NOTICE
      

error_reporting kann ebenfalls verwendet werden, um zu zeigen, wie Bits gesetzt
werden. Auf folgende Weise werden nur Fehler und behebbare Fehler angezeigt:
E_ERROR | E_RECOVERABLE_ERROR
      

Dieser Vorgang kombiniert E_ERROR
00000000000000000000000000000001
und
00000000000000000001000000000000
unter Verwendung des ODER (|) Operators
um die Bits zu ermitteln, die in einem oder beiden Werten gesetzt sind:
00000000000000000001000000000001

Beispiel #1 Bitweise UND, ODER und XODER Operationen mit Ganzzahlen

<?php
/*
 * Der erste Abschnitt kann ignoriert werden;
 * er dient nur zu Formatierungszwecken, um die Ausgabe deutlicher zu machen.
 */

$format = '(%1$2d = %1$04b) = (%2$2d = %2$04b)'
        . ' %3$s (%4$2d = %4$04b)' . "\n";

echo <<<EOH
 ---------     ---------  -- ---------
 Ergebnis      Wert 1     Op Wert 2
 ---------     ---------  -- ---------
EOH;


/*
 * Hier kommen die Beispiele.
 */

$values = array(0, 1, 2, 4, 8);
$test = 1 + 4;

echo "\n Bitweises UND \n";
foreach ($values as $value) {
    $result = $value & $test;
    printf($format, $result, $value, '&', $test);
}

echo "\n Bitweises einschließendes ODER \n";
foreach ($values as $value) {
    $result = $value | $test;
    printf($format, $result, $value, '|', $test);
}

echo "\n Bitweises ausschließendes ODER (XODER) \n";
foreach ($values as $value) {
    $result = $value ^ $test;
    printf($format, $result, $value, '^', $test);
}
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

 ---------     ---------  -- ---------
 Ergebnis      Wert 1     Op Wert 2
 ---------     ---------  -- ---------
 Bitweises UND
( 0 = 0000) = ( 0 = 0000) & ( 5 = 0101)
( 1 = 0001) = ( 1 = 0001) & ( 5 = 0101)
( 0 = 0000) = ( 2 = 0010) & ( 5 = 0101)
( 4 = 0100) = ( 4 = 0100) & ( 5 = 0101)
( 0 = 0000) = ( 8 = 1000) & ( 5 = 0101)

 Bitweises einschließendes ODER
( 5 = 0101) = ( 0 = 0000) | ( 5 = 0101)
( 5 = 0101) = ( 1 = 0001) | ( 5 = 0101)
( 7 = 0111) = ( 2 = 0010) | ( 5 = 0101)
( 5 = 0101) = ( 4 = 0100) | ( 5 = 0101)
(13 = 1101) = ( 8 = 1000) | ( 5 = 0101)

 Bitweises ausschließendes ODER (XODER)
( 5 = 0101) = ( 0 = 0000) ^ ( 5 = 0101)
( 4 = 0100) = ( 1 = 0001) ^ ( 5 = 0101)
( 7 = 0111) = ( 2 = 0010) ^ ( 5 = 0101)
( 1 = 0001) = ( 4 = 0100) ^ ( 5 = 0101)
(13 = 1101) = ( 8 = 1000) ^ ( 5 = 0101)

Beispiel #2 Bitweise XODER Operationen mit Zeichenketten

<?php
echo 12 ^ 9; // Gibt '5' aus

echo "12" ^ "9"; // Gibt das Backspace-Zeichen (ASCII 8) aus
                 // ('1' (ASCII 49)) ^ ('9' (ASCII 57)) = #8

echo "hallo" ^ "hello"; // Gibt die ASCII-Werte #0 #4 #0 #0 #0 aus
                        // 'a' ^ 'e' = #4

echo 2 ^ "3"; // Gibt 1 aus
              // 2 ^ ((int)"3") == 1

echo "2" ^ 3; // Gibt 1 aus
              // ((int)"2") ^ 3 == 1
?>

Beispiel #3 Bit-Verschiebung mit Ganzzahlen

<?php
/*
 * Hier kommen die Beispiele.
 */

echo "\n--- RECHTSVERSCHIEBUNG MIT POSITIVEN GANZZAHLEN ---\n";

$val = 4;
$places = 1;
$res = $val >> $places;
p($res, $val, '>>', $places, 'Kopie des Vorzeichenbits wird links hereingeschoben');

$val = 4;
$places = 2;
$res = $val >> $places;
p($res, $val, '>>', $places);

$val = 4;
$places = 3;
$res = $val >> $places;
p($res, $val, '>>', $places, 'Bits werden rechts herausgeschoben');

$val = 4;
$places = 4;
$res = $val >> $places;
p($res, $val, '>>', $places, 'dasselbe Ergebnis wie oben; man kann nicht über 0 hinaus verschieben');


echo "\n--- RECHTSVERSCHIEBUNG MIT NEGATIVEN GANZZAHLEN ---\n";

$val = -4;
$places = 1;
$res = $val >> $places;
p($res, $val, '>>', $places, 'Kopie des Vorzeichenbits wird links hereingeschoben');

$val = -4;
$places = 2;
$res = $val >> $places;
p($res, $val, '>>', $places, 'Bits werden rechts herausgeschoben');

$val = -4;
$places = 3;
$res = $val >> $places;
p($res, $val, '>>', $places, 'dasselbe Ergebnis wie oben; man kann nicht über -1 hinaus verschieben');


echo "\n--- LINKSSVERSCHIEBUNG MIT POSITIVEN GANZZAHLEN ---\n";

$val = 4;
$places = 1;
$res = $val << $places;
p($res, $val, '<<', $places, 'Nullen werden rechts hereingeschoben');

$val = 4;
$places = (PHP_INT_SIZE * 8) - 4;
$res = $val << $places;
p($res, $val, '<<', $places);

$val = 4;
$places = (PHP_INT_SIZE * 8) - 3;
$res = $val << $places;
p($res, $val, '<<', $places, 'Vorzeichenbits werden herausgeschoben');

$val = 4;
$places = (PHP_INT_SIZE * 8) - 2;
$res = $val << $places;
p($res, $val, '<<', $places, 'Bits werden links herausgeschoben');


echo "\n--- LINKSVERSCHIEBUNG MIT NEGATIVEN GANZZAHLEN ---\n";

$val = -4;
$places = 1;
$res = $val << $places;
p($res, $val, '<<', $places, 'Nullen werden rechts hereingeschoben');

$val = -4;
$places = (PHP_INT_SIZE * 8) - 3;
$res = $val << $places;
p($res, $val, '<<', $places);

$val = -4;
$places = (PHP_INT_SIZE * 8) - 2;
$res = $val << $places;
p($res, $val, '<<', $places, 'Bits werden links herausgeschoben, einschließlich des Vorzeichenbits');


/*
 * Dieser Abschnitt kann ignoriert werden;
 * es handlet sich nur um Formatierung, um die Ausgabe deutlicher zu machen.
 */

function p($res, $val, $op, $places, $note = '') {
    $format = '%0' . (PHP_INT_SIZE * 8) . "b\n";

    printf("Ausdruck: %d = %d %s %d\n", $res, $val, $op, $places);

    echo " Dezimal:\n";
    printf("  Wert=%d\n", $val);
    printf("  Erg.=%d\n", $res);

    echo " Binär:\n";
    printf('  Wert=' . $format, $val);
    printf('  Erg.=' . $format, $res);

    if ($note) {
        echo " ANMERKUNG: $note\n";
    }

    echo "\n";
}
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe aus 32-Bit-Systemen:


--- RECHTSVERSCHIEBUNG MIT POSITIVEN GANZZAHLEN ---
Ausdruck: 2 = 4 >> 1
 Dezimal:
  Wert=4
  Erg.=2
 Binär:
  Wert=00000000000000000000000000000100
  Erg.=00000000000000000000000000000010
 ANMERKUNG: Kopie des Vorzeichenbits wird links hereingeschoben

Ausdruck: 1 = 4 >> 2
 Dezimal:
  Wert=4
  Erg.=1
 Binär:
  Wert=00000000000000000000000000000100
  Erg.=00000000000000000000000000000001

Ausdruck: 0 = 4 >> 3
 Dezimal:
  Wert=4
  Erg.=0
 Binär:
  Wert=00000000000000000000000000000100
  Erg.=00000000000000000000000000000000
 ANMERKUNG: Bits werden rechts herausgeschoben

Ausdruck: 0 = 4 >> 4
 Dezimal:
  Wert=4
  Erg.=0
 Binär:
  Wert=00000000000000000000000000000100
  Erg.=00000000000000000000000000000000
 ANMERKUNG: dasselbe Ergebnis wie oben; man kann nicht über 0 hinaus verschieben


--- RECHTSVERSCHIEBUNG MIT NEGATIVEN GANZZAHLEN ---
Ausdruck: -2 = -4 >> 1
 Dezimal:
  Wert=-4
  Erg.=-2
 Binär:
  Wert=11111111111111111111111111111100
  Erg.=11111111111111111111111111111110
 ANMERKUNG: Kopie des Vorzeichenbits wird links hereingeschoben

Ausdruck: -1 = -4 >> 2
 Dezimal:
  Wert=-4
  Erg.=-1
 Binär:
  Wert=11111111111111111111111111111100
  Erg.=11111111111111111111111111111111
 ANMERKUNG: Bits werden rechts herausgeschoben

Ausdruck: -1 = -4 >> 3
 Dezimal:
  Wert=-4
  Erg.=-1
 Binär:
  Wert=11111111111111111111111111111100
  Erg.=11111111111111111111111111111111
 ANMERKUNG: dasselbe Ergebnis wie oben; man kann nicht über -1 hinaus verschieben


--- LINKSSVERSCHIEBUNG MIT POSITIVEN GANZZAHLEN ---
Ausdruck: 8 = 4 << 1
 Dezimal:
  Wert=4
  Erg.=8
 Binär:
  Wert=00000000000000000000000000000100
  Erg.=00000000000000000000000000001000
 ANMERKUNG: Nullen werden rechts hereingeschoben

Ausdruck: 1073741824 = 4 << 28
 Dezimal:
  Wert=4
  Erg.=1073741824
 Binär:
  Wert=00000000000000000000000000000100
  Erg.=01000000000000000000000000000000

Ausdruck: -2147483648 = 4 << 29
 Dezimal:
  Wert=4
  Erg.=-2147483648
 Binär:
  Wert=00000000000000000000000000000100
  Erg.=10000000000000000000000000000000
 ANMERKUNG: Vorzeichenbits werden herausgeschoben

Ausdruck: 0 = 4 << 30
 Dezimal:
  Wert=4
  Erg.=0
 Binär:
  Wert=00000000000000000000000000000100
  Erg.=00000000000000000000000000000000
 ANMERKUNG: Bits werden links herausgeschoben


--- LINKSVERSCHIEBUNG MIT NEGATIVEN GANZZAHLEN ---
Ausdruck: -8 = -4 << 1
 Dezimal:
  Wert=-4
  Erg.=-8
 Binär:
  Wert=11111111111111111111111111111100
  Erg.=11111111111111111111111111111000
 ANMERKUNG: Nullen werden rechts hereingeschoben

Ausdruck: -2147483648 = -4 << 29
 Dezimal:
  Wert=-4
  Erg.=-2147483648
 Binär:
  Wert=11111111111111111111111111111100
  Erg.=10000000000000000000000000000000

Ausdruck: 0 = -4 << 30
 Dezimal:
  Wert=-4
  Erg.=0
 Binär:
  Wert=11111111111111111111111111111100
  Erg.=00000000000000000000000000000000
 ANMERKUNG: Bits werden links herausgeschoben, einschließlich des Vorzeichenbits

Das oben gezeigte Beispiel erzeugt folgende Ausgabe aus 64-Bit-Systemen:


--- RECHTSVERSCHIEBUNG MIT POSITIVEN GANZZAHLEN ---
Ausdruck: 2 = 4 >> 1
 Dezimal:
  Wert=4
  Erg.=2
 Binär:
  Wert=0000000000000000000000000000000000000000000000000000000000000100
  Erg.=0000000000000000000000000000000000000000000000000000000000000010
 ANMERKUNG: Kopie des Vorzeichenbits wird links hereingeschoben

Ausdruck: 1 = 4 >> 2
 Dezimal:
  Wert=4
  Erg.=1
 Binär:
  Wert=0000000000000000000000000000000000000000000000000000000000000100
  Erg.=0000000000000000000000000000000000000000000000000000000000000001

Ausdruck: 0 = 4 >> 3
 Dezimal:
  Wert=4
  Erg.=0
 Binär:
  Wert=0000000000000000000000000000000000000000000000000000000000000100
  Erg.=0000000000000000000000000000000000000000000000000000000000000000
 ANMERKUNG: Bits werden rechts herausgeschoben

Ausdruck: 0 = 4 >> 4
 Dezimal:
  Wert=4
  Erg.=0
 Binär:
  Wert=0000000000000000000000000000000000000000000000000000000000000100
  Erg.=0000000000000000000000000000000000000000000000000000000000000000
 ANMERKUNG: dasselbe Ergebnis wie oben; man kann nicht über 0 hinaus verschieben


--- RECHTSVERSCHIEBUNG MIT NEGATIVEN GANZZAHLEN ---
Ausdruck: -2 = -4 >> 1
 Dezimal:
  Wert=-4
  Erg.=-2
 Binär:
  Wert=1111111111111111111111111111111111111111111111111111111111111100
  Erg.=1111111111111111111111111111111111111111111111111111111111111110
 ANMERKUNG: Kopie des Vorzeichenbits wird links hereingeschoben

Ausdruck: -1 = -4 >> 2
 Dezimal:
  Wert=-4
  Erg.=-1
 Binär:
  Wert=1111111111111111111111111111111111111111111111111111111111111100
  Erg.=1111111111111111111111111111111111111111111111111111111111111111
 ANMERKUNG: Bits werden rechts herausgeschoben

Ausdruck: -1 = -4 >> 3
 Dezimal:
  Wert=-4
  Erg.=-1
 Binär:
  Wert=1111111111111111111111111111111111111111111111111111111111111100
  Erg.=1111111111111111111111111111111111111111111111111111111111111111
 ANMERKUNG: dasselbe Ergebnis wie oben; man kann nicht über -1 hinaus verschieben


--- LINKSSVERSCHIEBUNG MIT POSITIVEN GANZZAHLEN ---
Ausdruck: 8 = 4 << 1
 Dezimal:
  Wert=4
  Erg.=8
 Binär:
  Wert=0000000000000000000000000000000000000000000000000000000000000100
  Erg.=0000000000000000000000000000000000000000000000000000000000001000
 ANMERKUNG: Nullen werden rechts hereingeschoben

Ausdruck: 4611686018427387904 = 4 << 60
 Dezimal:
  Wert=4
  Erg.=4611686018427387904
 Binär:
  Wert=0000000000000000000000000000000000000000000000000000000000000100
  Erg.=0100000000000000000000000000000000000000000000000000000000000000

Ausdruck: -9223372036854775808 = 4 << 61
 Dezimal:
  Wert=4
  Erg.=-9223372036854775808
 Binär:
  Wert=0000000000000000000000000000000000000000000000000000000000000100
  Erg.=1000000000000000000000000000000000000000000000000000000000000000
 NANMERKUNGTE: Vorzeichenbits werden herausgeschoben

Ausdruck: 0 = 4 << 62
 Dezimal:
  Wert=4
  Erg.=0
 Binär:
  Wert=0000000000000000000000000000000000000000000000000000000000000100
  Erg.=0000000000000000000000000000000000000000000000000000000000000000
 ANMERKUNG: Bits werden links herausgeschoben


--- LINKSVERSCHIEBUNG MIT NEGATIVEN GANZZAHLEN ---
Ausdruck: -8 = -4 << 1
 Dezimal:
  Wert=-4
  Erg.=-8
 Binär:
  Wert=1111111111111111111111111111111111111111111111111111111111111100
  Erg.=1111111111111111111111111111111111111111111111111111111111111000
 ANMERKUNG: Nullen werden rechts hereingeschoben

Ausdruck: -9223372036854775808 = -4 << 61
 Dezimal:
  Wert=-4
  Erg.=-9223372036854775808
 Binär:
  Wert=1111111111111111111111111111111111111111111111111111111111111100
  Erg.=1000000000000000000000000000000000000000000000000000000000000000

Ausdruck: 0 = -4 << 62
 Dezimal:
  Wert=-4
  Erg.=0
 Binär:
  Wert=1111111111111111111111111111111111111111111111111111111111111100
  Erg.=0000000000000000000000000000000000000000000000000000000000000000
 ANMERKUNG: Bits werden links herausgeschoben, einschließlich des Vorzeichenbits

Warnung

Vor PHP 7.0.0 war das Verhalten von Bitverschiebungen um Werte größer oder gleich der Breite eines long integer oder um negative Zahlen nicht definiert. Anders ausgedrückt: wenn PHP 5.x verwendet wird, dürfen nicht mehr als um 31 Bits auf einem 32-bit System, und nicht mehr als um 63 Bits auf einem 64-bit System verschoben werden.

Für die bitweise Manipulation von Zahlen größer als PHP_INT_MAX, sind die Funktion der GMP Extension zu verwenden.

Siehe auch pack(), unpack(), gmp_and(), gmp_or(), gmp_xor(), gmp_testbit(), gmp_clrbit()

Finde eine PHP-Funktion

Deutsche Übersetzung

Sie haben gebeten, diese Seite auf Deutsch zu besuchen. Momentan ist nur die Oberfläche übersetzt, aber noch nicht der gesamte Inhalt.

Wenn Sie mir bei Übersetzungen helfen wollen, ist Ihr Beitrag willkommen. Alles, was Sie tun müssen, ist, sich auf der Website zu registrieren und mir eine Nachricht zu schicken, in der Sie gebeten werden, Sie der Gruppe der Übersetzer hinzuzufügen, die Ihnen die Möglichkeit gibt, die gewünschten Seiten zu übersetzen. Ein Link am Ende jeder übersetzten Seite zeigt an, dass Sie der Übersetzer sind und einen Link zu Ihrem Profil haben.

Vielen Dank im Voraus.

Dokument erstellt 30/01/2003, zuletzt geändert 26/10/2018
Quelle des gedruckten Dokuments:https://www.gaudry.be/de/php-rf-language.operators.bitwise.html

Die Infobro ist eine persönliche Seite, deren Inhalt in meiner alleinigen Verantwortung liegt. Der Text ist unter der CreativeCommons-Lizenz (BY-NC-SA) verfügbar. Weitere Informationen auf die Nutzungsbedingungen und dem Autor.

Referenzen

  1. Zeigen Sie - html-Dokument Sprache des Dokuments:fr Manuel PHP : http://php.net

Diese Verweise und Links verweisen auf Dokumente, die während des Schreibens dieser Seite konsultiert wurden, oder die zusätzliche Informationen liefern können, aber die Autoren dieser Quellen können nicht für den Inhalt dieser Seite verantwortlich gemacht werden.
Der Autor Diese Website ist allein dafür verantwortlich, wie die verschiedenen Konzepte und Freiheiten, die mit den Nachschlagewerken gemacht werden, hier dargestellt werden. Denken Sie daran, dass Sie mehrere Quellinformationen austauschen müssen, um das Risiko von Fehlern zu reduzieren.

Inhaltsverzeichnis Haut