PetaPerl implementiert den vollstaendigen Satz von Perl-5-Operatoren mit identischer Semantik. Alle Operatoren wahren Perls Kontextsensitivitaet und Vorrangregeln.
| Operator | Operation | Beispiel |
|---|
+ | Addition | $a + $b |
- | Subtraktion | $a - $b |
* | Multiplikation | $a * $b |
/ | Division | $a / $b |
% | Modulo | $a % $b |
** | Potenzierung | $a ** $b |
Alle arithmetischen Operatoren wandeln Operanden in den numerischen Kontext um. Division durch Null erzeugt eine Warnung und gibt Unendlich oder NaN zurueck.
my $x = 5 + 3; # 8
my $y = 10 / 3; # 3.333...
my $z = 2 ** 10; # 1024
my $m = 17 % 5; # 2
| Operator | Operation | Beispiel |
|---|
. | Verkettung | $a . $b |
x | Wiederholung | $str x $count |
Zeichenkettenoperatoren wandeln Operanden in den Zeichenkettenkontext um.
my $str = "Hello" . " " . "World"; # "Hello World"
my $rep = "X" x 5; # "XXXXX"
my $pad = " " x 10; # 10 Leerzeichen
| Operator | Operation | Gibt zurueck |
|---|
== | Gleich | Wahr bei Gleichheit |
!= | Ungleich | Wahr bei Ungleichheit |
< | Kleiner als | Wahr wenn kleiner |
> | Groesser als | Wahr wenn groesser |
<= | Kleiner oder gleich | Wahr wenn kleiner oder gleich |
>= | Groesser oder gleich | Wahr wenn groesser oder gleich |
<=> | Dreiwegevergleich | -1, 0 oder 1 |
Numerische Vergleiche wandeln Operanden in Zahlen um.
if ($age >= 18) { ... }
my $cmp = $a <=> $b; # -1 wenn $a < $b, 0 bei Gleichheit, 1 wenn $a > $b
| Operator | Operation | Gibt zurueck |
|---|
eq | Gleich | Wahr bei Gleichheit |
ne | Ungleich | Wahr bei Ungleichheit |
lt | Kleiner als | Wahr wenn kleiner |
gt | Groesser als | Wahr wenn groesser |
le | Kleiner oder gleich | Wahr wenn kleiner oder gleich |
ge | Groesser oder gleich | Wahr wenn groesser oder gleich |
cmp | Dreiwegevergleich | -1, 0 oder 1 |
Zeichenkettenvergleiche verwenden lexikographische (Woerterbuch-)Ordnung.
if ($name eq "John") { ... }
my $cmp = $a cmp $b; # -1, 0 oder 1
| Operator | Operation | Kurzschluss | Vorrang |
|---|
&& | Und | Ja | Hoch |
| ` | | ` | Oder |
// | Definiert-oder | Ja | Hoch |
and | Und | Ja | Niedrig |
or | Oder | Ja | Niedrig |
xor | Exklusiv-oder | Nein | Niedrig |
Logische Operatoren geben den zuletzt ausgewerteten Wert zurueck, nicht nur wahr/falsch.
my $result = $x && $y; # Gibt $y zurueck wenn $x wahr, sonst $x
my $default = $user || "guest"; # Gibt "guest" zurueck wenn $user falsch
my $value = $config // 0; # Gibt 0 zurueck nur wenn $config undefiniert
Definiert-oder (//): Anders als || prueft dieser Operator nur, ob die linke Seite definiert ist, nicht ob sie wahr ist. 0 und "" sind beide falsch, aber definiert.
my $x = 0;
my $a = $x || 10; # 10 (0 ist falsch)
my $b = $x // 10; # 0 (0 ist definiert)
| Operator | Operation | Beispiel |
|---|
& | Bitweises UND | $a & $b |
| ` | ` | Bitweises ODER |
^ | Bitweises XOR | $a ^ $b |
<< | Linksverschiebung | $a << $n |
>> | Rechtsverschiebung | $a >> $n |
Bitweise Operatoren arbeiten auf Ganzzahlen. Operanden werden in vorzeichenlose Ganzzahlen umgewandelt.
my $mask = 0xFF & $value;
my $flags = $READ | $WRITE;
my $double = $x << 1;
| Operator | Operation | Kontext |
|---|
.. | Inklusiver Bereich | Erzeugt im Listenkontext eine Liste |
... | Flip-Flop | Ist im skalaren Kontext zustandsbehaftet |
my @digits = (0..9); # (0, 1, 2, ..., 9)
my @letters = ('a'..'z'); # ('a', 'b', ..., 'z')
for my $i (1..100) { ... } # Schleife von 1 bis 100
Im skalaren Kontext sind .. und ... Flip-Flop-Operatoren (zustandsbehafteter boolescher Bereich).
| Operator | Operation | Beispiel |
|---|
=~ | Abgleich | $str =~ /pattern/ |
!~ | Negativer Abgleich | $str !~ /pattern/ |
Bindungsoperatoren verbinden Zeichenketten mit Regex-Operationen.
if ($email =~ /\@/) { ... } # Enthaelt @
if ($name !~ /^\d/) { ... } # Beginnt nicht mit Ziffer
| Operator | Operation | Beispiel |
|---|
- | Negation | -$x |
+ | Unaeres Plus | +$x |
my $neg = -5;
my $pos = +$x; # Numerischer Kontext
| Operator | Operation | Beispiel |
|---|
! | Nicht | !$x |
not | Nicht (niedriger Vorrang) | not $x |
if (!$error) { ... }
die "Fehlgeschlagen" if not $ok;
| Operator | Operation | Beispiel |
|---|
~ | Bitweises Komplement | ~$x |
my $inverted = ~$bits;
| Operator | Operation | Beispiel |
|---|
\ | Referenz erzeugen | \$x, \@arr, \%hash |
my $scalar_ref = \$value;
my $array_ref = \@data;
my $hash_ref = \%config;
| Operator | Operation | Wann ausgewertet |
|---|
++$x | Praeinkrement | Nach dem Erhoehen |
--$x | Praedekrement | Nach dem Verringern |
$x++ | Postinkrement | Vor dem Erhoehen |
$x-- | Postdekrement | Vor dem Verringern |
my $x = 5;
my $a = ++$x; # $x ist 6, $a ist 6
my $b = $x++; # $x ist 7, $b ist 6
Zeichenketteninkrement: ++ auf Zeichenketten fuehrt ein “magisches Inkrement” durch (Perl-Stil).
my $s = "aa";
$s++; # "ab"
$s++; # "ac"
Dateitestoperatoren pruefen Eigenschaften von Dateien und Dateihandles. Alle geben wahr/falsch zurueck, ausser -s, das die Dateigroesse liefert.
| Operator | Test | Gibt zurueck |
|---|
-e | Existiert | Boolesch |
-r | Lesbar | Boolesch |
-w | Schreibbar | Boolesch |
-x | Ausfuehrbar | Boolesch |
-o | Gehoert effektiver UID | Boolesch |
-R | Lesbar fuer reale UID | Boolesch |
-W | Schreibbar fuer reale UID | Boolesch |
-X | Ausfuehrbar fuer reale UID | Boolesch |
-O | Gehoert realer UID | Boolesch |
-z | Groesse Null | Boolesch |
-s | Groesse ungleich Null | Groesse in Bytes oder falsch |
-f | Regulaere Datei | Boolesch |
-d | Verzeichnis | Boolesch |
-l | Symbolischer Link | Boolesch |
-p | Benannte Pipe (FIFO) | Boolesch |
-S | Socket | Boolesch |
-b | Blockspezialdatei | Boolesch |
-c | Zeichenspezialdatei | Boolesch |
-t | TTY (Terminal) | Boolesch |
-u | Setuid-Bit gesetzt | Boolesch |
-g | Setgid-Bit gesetzt | Boolesch |
-k | Sticky-Bit gesetzt | Boolesch |
-T | Textdatei | Boolesch |
-B | Binaerdatei | Boolesch |
-M | Aenderungszeit (Tage) | Zahl |
-A | Zugriffszeit (Tage) | Zahl |
-C | Inode-Aenderungszeit (Tage) | Zahl |
if (-e $file) { ... } # Datei existiert
if (-f $path && -r $path) { ... } # Regulaere Datei und lesbar
my $size = -s $file; # Groesse in Bytes
if (-d $path) { ... } # Ist Verzeichnis
Gestapelte Dateitests: -f -w -r $file prueft alle drei Bedingungen.
| Operator | Operation | Beispiel |
|---|
defined | Auf Definiertheit pruefen | defined $x |
if (defined $value) { ... }
| Operator | Operation | Beispiel |
|---|
= | Zuweisung | $x = 5 |
my $x = 10;
my ($a, $b, $c) = (1, 2, 3); # Listenzuweisung
Alle binaeren Operatoren haben zusammengesetzte Zuweisungsformen:
| Operator | Aequivalent | Beispiel |
|---|
+= | $x = $x + $y | $x += 5 |
-= | $x = $x - $y | $x -= 3 |
*= | $x = $x * $y | $x *= 2 |
/= | $x = $x / $y | $x /= 10 |
%= | $x = $x % $y | $x %= 7 |
**= | $x = $x ** $y | $x **= 2 |
.= | $x = $x . $y | $str .= "more" |
x= | $x = $x x $y | $str x= 3 |
&= | $x = $x & $y | $bits &= $mask |
| ` | =` | `$x = $x |
^= | $x = $x ^ $y | $x ^= $y |
<<= | $x = $x << $y | $x <<= 2 |
>>= | $x = $x >> $y | $x >>= 1 |
&&= | $x = $x && $y | $x &&= $default |
| ` | | =` |
//= | $x = $x // $y | $x //= 0 |
my $count = 10;
$count += 5; # 15
$count *= 2; # 30
my $path = "/home";
$path .= "/user"; # "/home/user"
$cache ||= load_data(); # Nur laden wenn $cache falsch ist
$config //= {}; # Nur zuweisen wenn $config undef ist
| Operator | Syntax | Beispiel |
|---|
? : | Bedingung | $cond ? $then : $else |
my $result = $x > 0 ? "positiv" : "nicht positiv";
my $max = $a > $b ? $a : $b;
Ternaerer Operator als Lvalue: Der ternaere Operator kann als Zuweisungsziel verwendet werden.
($x > 0 ? $pos : $neg) = 10; # Weist $pos oder $neg zu
| Syntax | Operation | Beispiel |
|---|
$arr[index] | Array-Elementzugriff | $arr[0] |
$hash{key} | Hash-Elementzugriff | $hash{name} |
@arr[indices] | Array-Scheibe | @arr[1, 3, 5] |
@hash{keys} | Hash-Scheibe | @hash{qw(a b c)} |
my $first = $arr[0];
my $value = $hash{key};
my @subset = @arr[0, 2, 4]; # Elemente 0, 2, 4
my @values = @hash{'a', 'b'}; # Werte fuer Schluessel 'a', 'b'
| Syntax | Operation | Beispiel |
|---|
->[] | Array-Dereferenzierungsindex | $aref->[0] |
->{} | Hash-Dereferenzierungsindex | $href->{key} |
->() | Methodenaufruf | $obj->method() |
my $element = $array_ref->[5];
my $value = $hash_ref->{name};
my $result = $object->method(@args);
| Operator | Operation | Verwendung |
|---|
, | Listentrennzeichen | (1, 2, 3) |
=> | Fettes Komma | key => value |
Das fette Komma (=>) quotiert Barewords auf seiner linken Seite automatisch.
my %hash = (
name => "John", # 'name' wird automatisch quotiert
age => 30,
);
Hoechster bis niedrigster Vorrang (identisch zu Perl 5):
- Terme und Listenoperatoren (links)
-> (links)++ -- (kein)** (rechts)! ~ \ unaeres + unaeres - (rechts)=~ !~ (links)* / % x (links)+ - . (links)<< >> (links)- Benannte unaere Operatoren
< > <= >= lt gt le ge (kein)== != <=> eq ne cmp ~~ (kein) – ~~ Smart Match ist teilweise implementiert& (links)| ^ (links)&& (links)|| // (links).. ... (kein)?: (rechts)= += -= usw. (rechts), => (links)- Listenoperatoren (rechts)
not (rechts)and (links)or xor (links)
Verwende Klammern, wenn der Vorrang unklar ist.
Operatoren werden standardmaessig sequenziell ausgefuehrt. PetaPerls Parallelisierung greift auf Ebene von Schleifen/map/grep, nicht bei einzelnen Operatoren.
- Bitweise Operationen werden zu nativen Maschinenbefehlen kompiliert
- Zeichenkettenverkettung kann neuen Speicher allokieren (
.= fuer Effizienz verwenden)
- Numerische Operationen werden getrennt fuer Ganzzahlen und Gleitkommazahlen optimiert