Zuweisung  nach oben

Die Zuweisung eines Wertes erfolgt in Perl durch den Zuweisungsoperator (=):

$x = 3;

Arithmetische Operatoren  nach oben

Neben den bekannten Operatoren für die mathematischen Grundrechenarten existieren noch spezielle Operatoren für die Berechnung mit Potenzbildung und Division mit Restrückgabe. Außerdem beherrscht Perl natürlich auch die Vorzeichen für numerische Werte:

#Operatoren für Grundrechenarten:
$Zahl = 1 + 2; #Addition
$Zahl = 3 - 4; #Subtraktion
$Zahl = 4 * 5; #Multiplikation
$Zahl = 6 / 7; #Division

#Potenzierung:
$Zahl = 8 ** 2; #Basis = 8 & Exponent = 2: 82

#Spezielle Form der Division mit Rest als Ergebnis (Modulo):
$Zahl = 9 % 8; #Rest der Division; hier: 1

#Vorzeichen:
$Zahl = +10; #positives Vorzeichen
$Zahl = -10; #negatives Vorzeichen

Darüber hinaus existieren in Perl spezielle Operatoren zur verkürzten Notation von Operationen, in denen der numerische Wert, welcher verändert werden soll, selbst vorkommt:

$Zahl++; 
#erhöht $Zahl um 1; verkürzt für: $Zahl = $Zahl + 1;

$Zahl += n; 
#erhöht $Zahl um n; verkürzt für: $Zahl = $Zahl + n;

$Zahl--;
#verringert $Zahl um 1; verkürzt für: $Zahl = $Zahl - 1;

$Zahl -= n;
#verringert $Zahl um n; verkürzt für: $Zahl = $Zahl - n;

$Zahl *= n;
#multipliziert $Zahl mit n; verkürzt für: $Zahl = $Zahl * n; 

$Zahl /= n;
#dividiert $Zahl durch n; verkürzt für: $Zahl = $Zahl / n;

$Zahl **= n;
#Basis $Zahl "hoch" n; verkürzt für: $Zahl = $Zahl ** n;

Die Operatoren ++ und -- werden im Übrigen auch als Inkrementationsoperator bzw. Dekrementationsoperator bezeichnet. Die Stellung dieser Operatoren bestimmt dabei, ob die Variable mit dem numerischen Wert vor (pre) oder nach (post) ihrer Auswertung um den Wert 1 erhöht bzw. verringert werden soll:

++$Zahl;
#Wert von $Zahl wird zuerst um 1 erhöht, dann $Zahl ausgewertet

$Zahl++;
#$Zahl wird zunächst ausgewertet und dann wird Wert um 1 erhöht

Dieser Zusammenhang gilt analog für den Dekrementationsoperator.

Vergleichsoperatoren  nach oben

Bei der Verwendung von Vergleichsoperatoren muss stets bedacht werden, in welchem Kontext - numerischen oder stringspezifisch - der Vergleich steht, d.h., ob Zahlen oder Strings miteinander verglichen werden sollen, da dafür verschiedene Operatoren existieren:

Vergleich von ZahlenVergleich von StringsbedeutedErgibt (wenn)
==eqgleichtrue/false (Gleichheit/Ungleichheit)
!=neungleichtrue/false (Ungleichheit/Gleichheit)
>gtLinkes Arg. größer als rechtes Arg.true/false (größer/kleiner)
<ltLinkes Arg. kleiner als rechtes Arg.true/false (kleiner/ größer)
>=geLinkes Arg. größer als-gleich rechtes Arg.true/false (größer als-gleich/kleiner)
<=leLinkes Arg. kleiner als-gleich rechtes Arg.true/false (kleiner als-gleich/größer)
<=>cmpLinkes Arg. kleiner als-gleich-größer als rechtes Arg.-1/0/-1 (kleiner/gleich/größer)

Anmerkung: Die jeweiligen Operatoren sollten nicht mit dem Trennungsoperator bei Hashes (=>, fat-comma) verwechselt werden.

Logische Operatoren  nach oben

Logische Operatoren finden überwiegend bei der Konstruktion von Kontrollstrukturen für Scripte Verwendung. Bei bedingten Anweisungen können beispielsweise die Ausführungsbedingungen verneint oder logisch miteinander verknüpft werden. Die Operatoren können dabei wahlweise als Symbol oder als Wort notiert werden, wobei letztere Variante eine intern höhere Priorität besitzt.

Verneinung

Mittels der beiden nachfolgenden Operatoren ist es möglich, eine Bedingung zu verneinen:

if(! ($Zahl == 1)) { print "Zahl ist ungleich 1"; }
#oder:
if(not ($Zahl == 1)) { print "Zahl ist ungleich 1"; }

Verknüpfung mit und

Eine logische Verknüpfung mit und ist mittels dieser Operatoren möglich, wobei die Gesamtbedingung erfüllt ist, wenn alle Einzelbedingungen erfüllt sind:

if(($Zahl1 == 1) && ($Zahl2 == 2)) 
{ print "Zahl1 ist 1 UND Zahl2 ist 2!"; }

#oder:

if(($Zahl1 == 1) and ($Zahl2 == 2)) 
{ print "Zahl1 ist 1 UND Zahl2 ist 2!"; }

Verknüpfung mit oder (inklusiv)

Bei der logischen Verknüpfung mit oder bedeutet inklusiv, dass es für die Erfüllung der Gesamtbedingung ausreicht, wenn eine der beiden Einzelbedingungen erfüllt ist:

if(($Zahl1 == 1) || ($Zahl2 == 2)) 
{ print "Zahl1 ist 1 ODER Zahl2 ist 2!"; }

#oder:

if(($Zahl1 == 1) or ($Zahl2 == 2)) 
{ print "Zahl1 ist 1 ODER Zahl2 ist 2!"; }

Verknüpfung mit oder (exklusiv)

Hierbei ist die Gesamtbedingung nur dann erfüllt, wenn eine der beiden Einzelnbedingungen erfüllt ist, aber nicht beide Einzelbedingungen zugleich erfüllt sind:

if(($Zahl1 == 1) ^ ($Zahl2 == 2)) 
{ print "Zahl1 ist 1 ODER Zahl2 ist 2!"; }

#oder:

if(($Zahl1 == 1) xor ($Zahl2 == 2)) 
{ print "Zahl1 ist 1 ODER Zahl2 ist 2, aber nicht beides!"; }

Spezielle Operatoren für Zeichenketten  nach oben

In Perl existieren zwei spezielle stringspezifische Operatoren: zum einen zur Verknüpfung und zum anderen zum Vervielfachen von Zeichenketten:

Verknüpfung von Zeichenketten

Die Verknüpfung zweier oder mehrerer Zeichenketten erfolgt mittels des Punkt-Operators (.). Das Ergebnis kann so beispielsweise in einem Skalar gespeichert werden:

$String1 = "String1";
$String2 = "String2";

$String1u2 = $String1.$String2;        #Verknüpfung beider Strings

Soll einem String lediglich ein anderer String angeknüpft, das Ergebnis wird also im beteiligten Skalar gespeichert, werden, ist dazu eine verkürzte Notation verwendbar:

$String1u2 = $String1;                
$String1u2 .= $String2;
#Anknüpfen des Wertes von $String2 an $String1u2

#verkürzt für:

$String1u2 = $String1u2.$String2;

Vervielfachung von Zeichenketten

Die Zeichenkettenvervielfachung erfolgt in Perl mithilfe des Operators x, wobei ihm die Angabe, wie oft die Zeichenkette multipliziert werden soll, folgen muss:

$String = "String";
print $String x 3; #Gibt "StringStringString" aus

Prioritäten von Operatoren  nach oben

Die verschiedenen Operatoren in Perl haben eine unterschiedliche interne Priorität.
Bei Verknüpfung von Bedingungen oder komplexeren Berechnungen ist die Kenntnis dieser Zusammenhänge von großer Bedeutung, da es dabei zu unerwünschten Ergebnissen kommen kann, wenn man die Rangfolge der Operatoren nicht mittels Einklammerung beeinflusst. Mit Klammern versehene Ausdrücke haben nämlich die höchste Priorität:

PrioritätOperator
hoch




















Gering
()
++ --
**
! ~ + (Vorzeichen) - (Vorzeichen)
=~ !~
* / % x
. + -
<< >>
< lt > gt <= le >= ge
== eq != ne <=> cmp
&
| ^
&&
||
.. (Bereiche für Arrays)
?: (spez. Syntax für Entweder-Oder-Bedingung)
= += -= *= /= **=
, => (Trennungsoperator für Listen bzw. Hashes)
not
and
or xor