Direkt zum Inhalt | Direkt zur Navigation

Benutzerspezifische Werkzeuge

This is SunRain Plone Theme

Sektionen

Sie sind hier: Startseite / Perl / Bit-Operatoren

Bit-Operatoren

bitoperationen mit Perl

Einführung

Bit-Operatoren sind vergleichbar mit den logischen Operatoren aus der Schaltalgebra, Boolesche Algebra und in der Steuerungstechnik.
Folgenden Operatoren stehen zur Verfügung:

op1 & op2

Der AND-Operator vergleicht zwei Bits und erzeugt ein Ergebnis von 1,
wenn beide Bits 1 sind, andernfalls wird 0 zurückgegeben..

1 0 1 0 10
0 1 1 0 6
0 0 1 0  

 

op1 | op2
Der OR-Operator vergleicht zwei Bits und erzeugt ein Ergebnis von 1,
wenn bei einem Bit eine Flag gesetzt wurde (1 hat) , andernfalls wird 0 zurückgegeben.
1 0 1 0 10
0 1 1 0 6
1 1 1 0  
op1 ^ op2 Der EXKLUSIV-ODER-Operator vergleicht zwei Bits und gibt 1 zurück, falls die zwei Bits unterschiedlich sind. Wenn Sie gleich sind, wird 0 zurückgegeben.
1 0 1 0 10
0 1 1 0 6
1 1 0 0  

 

op1 >> op2 Der SHIFT RIGHT Operator bewegt die Bits auf die rechte Seite, verwirft das rechte Bit, und weist das linke Bits den Wert 0. Jede Bewegung auf die rechte Seite teilt op1 durch die Hälfte.  
op1 << op2 Der SHIFT LEFT Operator bewegt die Bits auf die linke Seite, verwirft die linken Bits, und ordnet den rechten Bits den Wert 0 zu. Jede Bewegung auf die linke Seite multipliziert op1 um 2.  
~op1     Der COMPLEMENT-Operator wird verwendet, um alle Bits des Operanden umzukehren.  

Hinweis Die Operanden mit dem bitweisen Operator, müssen ganze Zahlen sein.

Bitweise Operatoren werden verwendet, um einzelne Bits in einem Operanden zu ändern.
Ein einzelnes Byte von Computer-Speicher-, enthät 8-Bit , die den Status true / false von 8 Flags darstellen können.
Jedes Bit oder Flag als boolesche Variable, kann eine von zwei Zuständen haben : true / false.

Diese Variable wird normalerweise verwendet, um den Status von etwas zeigen. Zum Beispiel können Computer-Dateien als schreibgeschützt markiert werden.

So haben Sie vielleicht ein $ReadOnly Variable, deren Aufgabe es ist, den "Nur-Lese-Status" einer Datei zu halten.
Diese Variable wird eine Flag-Variable genannt, weil.
Wenn $ReadOnly einen wahren Wert hat (entsprechend einem Fußball-Schiedsrichter, der die Flagge hochhält), dann sagt die Variable:
"Ändern Sie diese Datei nicht."

Wenn Sie mehr als eine Flag-Variable haben, kann es effizienter sein, eine einzelne zu Variable zu verwenden, um den Wert von mehr als einen Flag anzuzeigen. Das nächste Beispiel zeigt Ihnen, wie Sie dies tun können:

Beispiel: Mit dem & (und), | (oder) und ^ (xor) Operators

Der erste Schritt zur Verwendung der bitweisen Operatoren, mehr als eine Flagge in einer einzigen Variablen anzuzeigen ist es, die Bedeutung der Bits, die Sie verwenden möchten zu definieren. Die Abbildung zeigt ein Beispiel von 8 Bits, die verwendet werden, um die Attribute eines Textes auf dem Display zu kontrollieren.
kurisv fett blinken unterstrichen Future use Future use Future use Future use Attribute
7 6 5 4 3 2 1 0 Byte Position
128 64 32 16 8 4 2 1 Wert

Die Bit-Definition eines Textattribut in der Variable $textAttr

Die variable $TextAttr können Sie verwenden, um die Text Attribute zu steuern. Sie können das Attribut "kursiv" setzen, indem Sie $TextAttr den Wert 128 zuweisen:

$textAttr = 128;

Das Bitmuster 128 entspricht dem Binär Wert 10000000. Das Bit, das eingeschaltet wird, entspricht der "kursiv" Position in $TextAttr.

Nun setzen wir die beiden Attribute kursiv und unterstrichen zur gleichen Zeit. Die "unterstreichung" hat den Wert 16, das dem Bitmuster 00010000 entspricht. Sie wissen bereits, der Wert für kursiv entspricht 128. So verwenden wir den Operator OR, um die beiden Werte zu kombinieren.

$textAttr = 128 | 16;
$textAttr = 10000000 | 00010000;

$TextAttr hat jetzt einen Wert von 144 (oder 10010000 als Bitmuster) zugewiesen bekommen. Dies setzt sowohl die Attribute kursiv als auch unterstrichen.

kurisv fett blinken unterstrichen Future use Future use Future use Future use Attribute
128 64 32 16 8 4 2 1 Wert
1 0 0 0 0 0 0 0 128
0 0 0 1 0 0 0 0 16
  144

Der nächste Schritt könnte sein, das kursiv Attribut auszuschalten. Dies kann mit der EXKLUSIV-ODER-Operator erfolgen:

$textAttr = $textAttr ^ 128;

Beispiel: Verwenden der >> und << Operatoren

Die "bitweise" Shift-Operatoren wird verwendet, um alle Bits im Operanden nach links oder rechts, mit einer bestimmte Anzahl zu verschieben.

my $firstVar = 128;
my $secondVar = $firstVar >> 2;
print("$secondVar\n");

Die Durchführung:

  • Weisen Sie einen Wert von 128 der $firstVar.
  • Verschiebung der Bits in $firstVar um zwei Plätze nach rechts und
  • Weisen Sie den neuen Wert zu $secondVar.
  • Ausgabe der $secondVart Variabel.

Das Programm erzeugt die folgende Ausgabe:

32

1 0 0 0 0 0 0 0 128
0 0 0 1         32

Schauen wir uns die Bitmuster der Variablen vor und nach der "shift operation" an.
Zuerst wird $firstVar 128 oder 10000000 zugewiesen.
Dann wird der Wert in $firstVar nach links verschoben um zwei Plätze.
So wird der neue Wert 00100000 oder 32, die $secondVar zugeordnet ist.

Das rechte Bits des Wertes sind verloren gegangen, wenn die Bits nach rechts verschoben werden.

Beim nächsten Beispiel wird die Variable 128 um drei Plätze nach links verschieben.

my $firstVar = 128;
my $secondVar = $firstVar << 3;
print $secondVar;

Die Durchführung:

  • Weisen Sie einen Wert von 128 der $firstVar.
  • Verschiebung der Bits in $firstVar um drei Plätze nach links und
  • Weisen Sie den neuen Wert zu $secondVar.
  • Ausgabe der $secondVart Variabel.

Das Programm erzeugt die folgende Ausgabe:

1024

1024 512 256 128 64 32 16 8 4 2 1  
      1 0 0 0 0 0 0 0 128
1 0 0 0 0 0 1         1024

Der Wert von 1024 überschreitet die Grenzen der 8 Bits.

Dies wurde getan, um Ihnen zu zeigen, dass die Anzahl der Bits für die Nutzung nicht auf ein Byte beschränkt ist.

Ein Perl Beispiel für & (und), | (oder) und ^ (xor) Operators

#!/usr/bin/perl -w
use strict;

my $bit_1 = "10";
my $bit_2 = "6";
my $bin_1 = dec2bin($bit_1);
my $bin_2 = dec2bin($bit_2)
 
my $and = $bit_1 & $bit_2;
print "and\n";
print "$bin_1\n";
print "$bin_2\n";
print "----\n";
print dec2bin($and) . "\n";

 

1010
0110
----
0010

my $or = $bit_1 | $bit_2;
print "\nor\n";
print "$bin_1\n";
print "$bin_2\n";
print "----\n";
print dec2bin($or) . "\n";

1010
0110
----
1110

my $xor = int($bit_1) ^ int($bit_2);
print "\nxor\n";
print "$bin_1\n";
print "$bin_2\n";
print "----\n";
print dec2bin($xor) . "\n";

1010
0110
----
1100

sub dec2bin {
    my $str = unpack("B32", pack("N", shift));
    my $bits = "4";
    $str =~ s/^0+(?=\d)//;
    my $length = length($str);
    for(my $i = $length; $i < $bits; $i++) {
        $str = sprintf("0%s",$str);
    }
    return $str;
}
 

Ein beispiel aus der Praxis:

Wir möchten überprüfen:

  1. ob eine Datei vorhanden ist
  2. ob diese Datei ein schreibrecht hat
  3. ob diese Datei einen Inhalt hat

Dafür definieren wir eine BIT-Mask

vorhanden schreibrecht Inhalt reserviert 14
8 4 2 1
1 1 1 0
  1. Sind alle 3 Bedingungen erfüllt, so haben wir den binär Wert von "14".
  2. Wir erzeugen die Datei:
    1. touch bit-test.txt
    2. chmod 444 bit-test.txt

Die Datei ist jetzt vorhanden, hat aber kein schreibtrechte und hat keinen Inhalt:

-r--r--r--. 1 ake ake 0 Mar 26 09:14 bit-test.txt

#!/usr/bin/perl -w
use strict;
my $bit_mask = "14";
my $bit_controll = {
    '2' => "Inhalt vorhanden",
    '4' => "kann geschrieben werden",
    '8' => "Datei ist vorhanden"
};
my $file = "bit-test.txt";
my $bit_summary = 0;

 

system("rm $file")if(-f $file);;
$bit_summary = testfile($file);
print_bit_summary($bit_summary);
print_msg('bit_mask' => $bit_mask, 'bit_controll' => $bit_controll);

0-> 0
nein: Inhalt vorhanden
nein: kann geschrieben werden
nein: Datei ist vorhanden

system("touch $file");
system("chmod 444 $file");
$bit_summary = testfile($file);
print_bit_summary($bit_summary);
print_msg('bit_mask' => $bit_mask, 'bit_controll' => $bit_controll);

8-> 1000
nein: Inhalt vorhanden
nein: kann geschrieben werden
ja  : Datei ist vorhanden

system("chmod 644 $file");
$bit_summary = testfile($file);
print_bit_summary($bit_summary);
print_msg('bit_mask' => $bit_mask, 'bit_controll' => $bit_controll);

12-> 1100
nein: Inhalt vorhanden
ja  : kann geschrieben werden
ja  : Datei ist vorhanden

system("echo \"hello\" > $file");
$bit_summary = testfile($file);
print_bit_summary($bit_summary);
print_msg('bit_mask' => $bit_mask, 'bit_controll' => $bit_controll);

14-> 1110
ja  : Inhalt vorhanden
ja  : kann geschrieben werden
ja  : Datei ist vorhanden

system("chmod 000 $file");
$bit_summary = testfile($file);
print_bit_summary($bit_summary);
print_msg('bit_mask' => $bit_mask, 'bit_controll' => $bit_controll);

10-> 1010
ja  : Inhalt vorhanden
nein: kann geschrieben werden
ja  : Datei ist vorhanden

sub dec2bin {
    my $str = unpack("B32", pack("N", shift));
    $str =~ s/^0+(?=\d)//;   # otherwise you'll get leading zeros
    return $str;
}
sub testfile{
    my $file = shift;
    my $bit_summary = 0;
    $bit_summary = $bit_summary | 8 if(-e $file);
    $bit_summary = $bit_summary | 4 if(-w $file);
    $bit_summary = $bit_summary | 2 if(-s $file);
    return $bit_summary;
}
sub print_bit_summary{
    my $bin_summary = dec2bin(shift);
    print "$bit_summary-> ". dec2bin($bit_summary) . "\n";
}
sub print_msg{
    my (%arg) =  @_;
    my $bit_mask = $arg{'bit_mask'};
    my $bit_controll = $arg{'bit_controll'};
    for(my $i = "1"; $i <= $bit_mask; $i++) {
        my $check =  $bit_summary & $i;
        my $msg = $bit_controll-> {$i};
        if($i == $check){
            print "ja  : $msg\n"if($msg);
        } else {
            print "nein: $msg\n"if($msg);
        }
    }
}

 

 

 

Artikelaktionen

abgelegt unter: ,
Kommentieren

Sie können einen Kommentar abgeben, indem Sie das untenstehende Formular ausfüllen. Nur Text. Web- und E-Mailadressen werden in anklickbare Links umgewandelt. Kommentare werden moderiert.

Enter the word