In diesem Beitrag lernen Sie den Befehl expr kennen, welcher unter Linux- \/ UNIX-Betriebssystemen eingesetzt wird, um numerische- sowie String-Ausdrücke auszuwerten.<\/p>\n
Neben der allgemeinen Syntax<\/a> lernen Sie auch die Anwendung des Befehls expr anhand verschiedener Beispiele anschaulich kennen.<\/p>\n Die allgemeine Syntax von expr <\/strong>lautet folgendermaßen:<\/p>\n Der expr <\/strong>übergebene Ausdruck lässt sich nun aus verschiedenen Operanden \/ Operatoren zusammensetzen, welche in den folgenden Abschnitten näher erläutert werden.<\/p>\n Der Befehl expr <\/strong>unterstützt neben Pattern-Matching auch einige weitere String-Operatoren, welche bei der Erstellung von String-Ausdrücken auch kombiniert werden können. String-Operatoren haben die höchste Präzedenz aller bei expr <\/strong>verfügbaren Operatoren.<\/p>\n Im Folgenden werden die verfügbaren String-Operationen vorgestellt.<\/p>\n Pattern-Matching wird mit der folgenden Syntax durchgeführt:<\/p>\n Die folgende alternative Syntax ist jedoch ebenfalls gültig:<\/p>\n Die übergebenen Argumente werden automatisch in Strings konvertiert. Das zweite Argument wird als einfacher regulärer Ausdruck<\/a> interpretiert, wobei ein “^” als Präfix implizit angehängt wird, und mit dem ersten Argument verglichen.<\/p>\n Bei einem erfolgreichen Match wird standardmäßig die Anzahl übereinstimmender Zeichen<\/strong> ausgegeben – wurde im regulären Ausdruck geklammert (“(<\/strong>” und “)<\/strong>“), so wird stattdessen der mit diesem Subausdruck übereinstimmende Teil des übergebenen Strings<\/strong> ausgegeben. Für die Ausgabe des Pattern-Matching ist dabei lediglich das erste Vorkommen von Klammern relevant, alle weiteren Klammern dienen ausschließlich der Einhaltung von Präzedenzregeln. Schlägt der Match fehl, so wird ohne Verwendung von Klammerung eine “0<\/strong>“, andernfalls der null-String<\/strong> ausgegeben.<\/p>\n expr ‘Linux Prof. Hellberg EDV-Beratung – Profi-Tutorials’ : ‘Linux’<\/p>\n Es wird eine “5<\/strong>” ausgegeben, da die ersten 5 Zeichen des Strings mit dem regulären Ausdruck übereinstimmen. In diesem Fall entspricht dies genau der Länge des Wortes “Linux<\/strong>“.<\/p>\n 5<\/p>\n expr ‘Der Befehl expr’ : ‘Der Befehl (.*)’<\/p>\n Erwartungsgemäß gibt expr<\/strong> an dieser Stelle das Wort<\/a> “expr<\/strong>” aus. Mithilfe des verwendeten regulären Ausdrucks ist es damit möglich, den Befehlsteil eines beliebigen Titels “Der Befehl [Befehl]<\/strong>” zu erhalten.<\/p>\n expr<\/p>\n Ein Substring des übergebenen Strings [String<\/strong>], beginnend an der Position [Position<\/strong>] mit der Länge [Länge<\/strong>], wird mit der folgenden Syntax erhalten:<\/p>\n Ist das Längen- und \/ oder Positions-Argument null<\/strong>, negativ<\/strong> oder nicht-numerisch<\/strong>, so wird stets der null-String<\/strong> ausgegeben.<\/p>\n expr substr ‘Prof. Hellberg EDV-Beratung’ 7 8<\/p>\n expr<\/strong> gibt nun die Zeichenkette<\/a>, welche an der 7. Position beginnt und an der 14. Position (7+8-1) endet, aus.<\/p>\n Hellberg<\/p>\n Die Position des ersten Vorkommnisses eines Zeichens aus einem spezifischen Zeichensatz<\/a> im übergebenen String wird mit folgender Syntax ermittelt:<\/p>\n Wird kein Vorkommnis gefunden, so wird eine “0<\/strong>” ausgegeben.<\/p>\n expr index ‘IT-Consulting’ ‘abCd’<\/p>\n In diesem Fall wird eine “4<\/strong>” ausgegeben, da das Zeichen “C<\/strong>” an 4. Position im String “IT-Consulting<\/strong>” auftaucht.<\/p>\n 4<\/p>\n Die Länge eines übergebenen Strings wird folgendermaßen ermittelt:<\/p>\n expr length ‘Profi-Tutorials’<\/p>\n expr<\/strong> gibt eine “15<\/strong>” aus – die Länge des Strings “Profi-Tutorials<\/strong>“.<\/p>\n 15<\/p>\n Mithilfe des Plus<\/strong> “+” Operators (GNU Extensions) wird das übergebene Argument [Token<\/a>] als String interpretiert<\/strong> – unabhängig davon, ob es sich um ein spezielles Keyword<\/strong>, wie etwa “match<\/strong>” oder “index<\/strong>“, handelt:<\/p>\n Soll der Befehl expr<\/strong> ein Keyword als String<\/strong> interpretieren, so müssen stets Anführungszeichen “”<\/strong> verwendet werden.<\/p>\n Der Befehl expr<\/strong> erlaubt die Verwendung der mathematischen Standardoperationen – die üblichen Präzedenzregeln werden dabei eingehalten. Die Präzedenz der numerischen Operatoren ist höher als die der relationalen \/ logischen Operatoren.<\/p>\n Die Addition zweier Integer-Zahlen<\/strong> wird folgendermaßen durchgeführt:<\/p>\n Analog wird auch die Subtraktion<\/strong> durchgeführt:<\/p>\n Können die übergebenen Argumente nicht als Integer interpretiert werden, so gibt expr<\/strong> eine Error-Meldung<\/strong> aus.<\/p>\n expr 55 + 45<\/p>\n Das Ergebnis der Addition “55 + 45” wird ausgegeben.<\/p>\n 100<\/p>\n expr 10 – 2<\/p>\n expr<\/strong> gibt das Ergebnis der Subtraktion “10 – 2” aus.<\/p>\n 8<\/p>\n Die Multiplikation <\/strong>erfolgt nach folgender Syntax (Das Zeichen “*<\/strong>” muss maskiert werden, damit es nicht von der Shell interpretiert wird):<\/p>\n Die Division <\/strong>wird mit dem Operator <\/strong>“\/<\/strong>” durchgeführt:<\/p>\n Schließlich wird auch der Modulo-Operator<\/strong> “%<\/strong>” unterstützt, welcher den Rest einer Integer-Division<\/strong> ausgibt:<\/p>\n expr 6 * 6<\/p>\n Das Produkt der beiden Zahlen wird ausgegeben.<\/p>\n 36<\/p>\n expr 9 \/ 2<\/p>\n expr <\/strong>gibt eine “4<\/strong>” als Ergebnis der Division zurück. In diesem Fall besteht ein Rest, da es sich um eine Integer-Division handelt. Der Rest kann mit dem Modulo-Operator<\/strong> “%<\/strong>” bestimmt werden.<\/p>\n 4<\/p>\n expr 9 % 2<\/p>\n Der durch die Modulo-Operation berechnete Rest beträgt “1<\/strong>“. (2 * 4 + Rest 1 = 9<\/strong>)<\/p>\n 1<\/p>\n Auch einige relationale bzw. logische Operatoren werden von expr <\/strong>unterstützt. Die relationalen \/ logischen Operatoren haben die niedrigste Präzedenz – im Folgenden werden diese nach aufsteigender Rangfolge vorgestellt:<\/p>\n Ein Lazy-Oder wird mit der folgenden Syntax realisiert (das Pipe-Symbol<\/strong> “|<\/strong>” muss maskiert werden):<\/p>\n expr <\/strong>gibt hierbei das erste Argument zurück, wenn es sich weder um den null-String<\/strong> noch den Zahlenwert “0<\/strong>” handelt. Andernfalls wird das zweite Argument ausgegeben – vorausgesetzt die genannten Bedingungen gelten hierfür. Treffen die Bedingungen weeder bei dem ersten, noch dem zweiten Argument zu, so ist die Ausgabe “0<\/strong>“.<\/p>\n Es handelt sich um ein Lazy-Oder<\/strong>, weswegen das zweite Argument nicht ausgewertet wird, wenn eine Ausgabe des ersten Arguments erfolgt.<\/p>\n expr 5 | 0<\/p>\n Das Ergebnis der Oder-Verknüpfung ist die “5<\/strong>” – es handelt sich bei diesem ersten Argument weder um den null-String<\/strong>, noch um den Zahlenwert “0<\/strong>“. Das zweite Argument “0<\/strong>” wird von expr <\/strong>daher nicht betrachtet.<\/p>\n 5<\/p>\n Mit der folgenden Syntax wird die Verknüpfung zweier Argumente mit einem Lazy-Und durchgeführt (das Et-Zeichen<\/strong> “&<\/strong>” muss maskiert werden):<\/p>\n expr <\/strong>gibt hier das erste Argument aus, sofern keines der beiden Argumente der null-String<\/strong> oder “0<\/strong>” ist. Andernfalls wird eine “0<\/strong>” ausgegeben.<\/p>\n Auch hier handelt es sich wieder um eine Lazy-Variante<\/strong>: Das zweite Argument wird nicht ausgewertet, wenn die Bedingungen für das erste Argument nicht zutreffen.<\/p>\n expr 0 & “hedv”<\/p>\n Es wird eine “0<\/strong>” ausgegeben, da es sich bei dem ersten Argument um den Zahlenwert “0<\/strong>” handelt.<\/p>\n 0<\/p>\n expr “admina” & “hedv”<\/p>\n Das erste Argument “admina<\/strong>” wird ausgegeben, da es sich bei keinem der beiden Argumente um den null-String<\/strong> oder den Zahlenwert “0<\/strong>” handelt.<\/p>\n admina<\/p>\n Mithilfe der in der folgenden Tabelle aufgelisteten Operatoren lassen sich zwei Argumente miteinander vergleichen<\/strong>. Die Syntax ist die folgende (auch hier müssen Operatoren teilweise maskiert werden, da diese – beispielsweise die Umleitung mit “<” – sonst von der Shell interpretiert werden):<\/p>\n expr <\/strong>versucht zunächst, die übergebenen Argumente in Integer zu konvertieren und anschließend einen numerischen Vergleich<\/strong> durchzuführen – schlägt dies fehl, so wird ein lexikographischer Vergleich<\/strong> unter Verwendung der durch die Umgebungsvariable<\/a> <\/strong>“LC_COLLATE<\/strong>” spezifizierten Sortierreihenfolge <\/strong>durchgeführt.<\/p>\n <<\/p>\n<\/td>\n [Argument 1] ist echt kleiner als [Argument 2]\n<\/p><\/td>\n<\/tr>\n <=<\/p>\n<\/td>\n [Argument 1] ist kleiner oder gleich [Argument 2]\n<\/p><\/td>\n<\/tr>\n = bzw. ==<\/p>\n<\/td>\n [Argument 1] ist gleich [Argument 2]\n<\/p><\/td>\n<\/tr>\n !=<\/p>\n<\/td>\n [Argument 1] ist ungleich [Argument 2]\n<\/p><\/td>\n<\/tr>\n >=<\/p>\n<\/td>\n [Argument 1] ist größer oder gleich [Argument 2]\n<\/p><\/td>\n<\/tr>\n ><\/p>\n<\/td>\n [Argument 1] ist echt größer als [Argument 2]\n<\/p><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n expr “profi” == “profi”<\/p>\n Da beide Argumente gleich sind, gibt expr <\/strong>den Wert “1<\/strong>” aus.<\/p>\n 1<\/p>\n expr “profi” == “tutorials”<\/p>\n In diesem Fall wird eine “0<\/strong>” ausgegeben, da die Argumente “profi<\/strong>” und “tutorials<\/strong>” ungleich sind.<\/p>\n 0<\/p>\n expr 50 > 42<\/p>\n Es wird eine “1<\/strong>” ausgegeben – der Vergleich ist gültig.<\/p>\n 1<\/p>\n expr “xyz” < “abc”<\/p>\n Der Befehl expr <\/strong>gibt hier eine “0<\/strong>” aus, da das Argument “xyz<\/strong>” lexikographisch größer ist als das Argument “abc<\/strong>“.<\/p>\n 0<\/p>\n Der Befehl expr <\/strong>kennt schließlich folgende Exit-Status<\/strong>:<\/p>\nAllgemeine Syntax<\/h2>\n
expr [Ausdruck]<\/pre>\n
String-Ausdrücke<\/h2>\n
Pattern-Matching<\/h3>\n
[String] : [Regex]<\/pre>\n
match [String] [Regex]<\/pre>\n
Beispiel: Pattern-Matching 1<\/h5>\n
In diesem Beispiel soll am Anfang des Strings “<\/span>Linux Prof. Hellberg EDV-Beratung – Profi-Tutorials” nach einer Übereinstimmung mit dem Wort “<\/span>Linux” gesucht werden. Da das Zeichen “^”, welches den Anfang einer Zeile markiert, stet impliziert wird, wird als regulärer Ausdruck lediglich das Wort “<\/span>Linux” angegeben.<\/span><\/h6>\n
Eingabe:<\/h6>\n
Ausgabe:<\/h6>\n
Beispiel: Pattern-Matching 2<\/h5>\n
Aus einem Titel wie “<\/span>Der Befehl expr” soll in diesem Beispiel der Befehlsteil (“<\/span>expr“) extrahiert werden. Klammerung wird hierbei eingesetzt, um eine beliebige auf “<\/span>Der Befehl” folgende Zeichenkette auszugeben.<\/span><\/h6>\n
Eingabe:<\/h6>\n
Ausgabe:<\/h6>\n
Substring<\/h3>\n
substr [string] [Position] [Länge]<\/pre>\n
Beispiel: Substring<\/h5>\n
Dem String “<\/span>Prof. Hellberg EDV-Beratung” soll in diesem Beispiel der Name “<\/span>Hellberg” entnommen werden. Dazu wird das Keyword “<\/span>substr” mit der Position “<\/span>7” (Position vom “<\/span>H” im String) und der Länge “<\/span>8” (Länge des Wortes “<\/span>Hellberg“) verwendet.<\/span><\/h6>\n
Eingabe:<\/h6>\n
Ausgabe:<\/h6>\n
Index<\/h3>\n
index [String] [Zeichensatz]<\/pre>\n
Beispiel: Index<\/h5>\n
In diesem Beispiel soll die erste Position in einem String, an welcher eines der Zeichen “<\/span>a“, “<\/span>b“, “<\/span>C” oder “<\/span>d” auftaucht, ermittelt werden.<\/span><\/h6>\n
Eingabe:<\/h6>\n
Ausgabe:<\/h6>\n
Länge<\/h3>\n
length [String]<\/pre>\n
Beispiel: Länge<\/h5>\n
Die Länge des Strings “<\/span>Profi-Tutorials” wird in diesem Beispiel ermittelt:<\/span><\/h6>\n
Eingabe:<\/h6>\n
Ausgabe:<\/h6>\n
String-Interpretation<\/h3>\n
+ [Token]<\/pre>\n
Numerische Ausdrücke<\/h2>\n
Addition \/ Substraktion<\/h3>\n
[Integer 1] + [Integer 2]<\/pre>\n
[Integer 1] - [Integer 2]<\/pre>\n
Beispiel: Addition<\/h5>\n
Dieses Beispiel zeigt die <\/span>Addition zweier Zahlen.<\/span><\/h6>\n
Eingabe:<\/h6>\n
Ausgabe:<\/h6>\n
Beispiel: Subtraktion<\/h5>\n
Hier wird die <\/span>Subtraktion zweier Zahlen gezeigt.<\/span><\/h6>\n
Eingabe:<\/h6>\n
Ausgabe:<\/h6>\n
Multiplikation \/ Division \/ Modulo<\/h3>\n
[Integer 1] * [Integer 2]<\/pre>\n
[Integer 1] \/ [Integer 2]<\/pre>\n
[Integer 1] % [Integer 2]<\/pre>\n
Beispiel: Multiplikation<\/h5>\n
Zwei Zahlen werden in diesem Beispiel multipliziert.<\/span><\/h6>\n
Eingabe:<\/h6>\n
Ausgabe:<\/h6>\n
Beispiel: Division<\/h5>\n
Eine Zahl wird in diesem Beispiel durch eine andere geteilt. Zu beachten ist hierbei der Rest.<\/span><\/h6>\n
Eingabe:<\/h6>\n
Ausgabe:<\/h6>\n
Beispiel: Modulo<\/h5>\n
In diesem Beispiel soll der Rest der zuvor durchgeführten Division “<\/span>9 \/ 2” ermittelt werden.<\/span><\/h6>\n
Eingabe:<\/h6>\n
Ausgabe:<\/h6>\n
Relationale \/ logische Ausdrücke<\/h2>\n
Oder<\/h3>\n
[Argument 1] | [Argument 2]<\/pre>\n
Beispiel: Oder<\/h5>\n
Hier wird eine Order-Verknüpfung der beiden Argumente “<\/span>5” und “<\/span>0” durchgeführt.<\/span><\/h6>\n
Eingabe:<\/h6>\n
Ausgabe:<\/h6>\n
Und<\/h3>\n
[Argument 1] & [Argument 2]<\/pre>\n
Beispiel: Und 1<\/h5>\n
Eine Und-Verknüpfung zweier Operatoren wird in diesem Beispiel vorgestellt.<\/span><\/h6>\n
Eingabe:<\/h6>\n
Ausgabe:<\/h6>\n
Beispiel: Und 2<\/h5>\n
Dieses Beispiel zeigt eine weitere Und-Verknüpfung.<\/span><\/h6>\n
Eingabe:<\/h6>\n
Ausgabe:<\/h6>\n
Relationale Operatoren<\/h3>\n
[Argument 1] [Operator] [Argument 2]<\/pre>\n
\n\n
\n Operator<\/strong><\/th>\n Beschreibung<\/th>\n<\/tr>\n<\/thead>\n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n Beispiel: Gleichheit 1<\/h5>\n
In diesem Beispiel wird die Gleichheit zweier Argumente überprüft.<\/span><\/h6>\n
Eingabe:<\/h6>\n
Ausgabe:<\/h6>\n
Beispiel: Gleichheit 2<\/h5>\n
Auch hier soll die Überprüfung der Gleichheit zweier Argumente stattfinden.<\/span><\/h6>\n
Eingabe:<\/h6>\n
Ausgabe:<\/h6>\n
Beispiel: Größer als<\/h5>\n
Dieses Beispiel zeigt die Durchführung eines “<\/span>größer als“-Vergleichs.<\/span><\/h6>\n
Eingabe:<\/h6>\n
Ausgabe:<\/h6>\n
Beispiel: Kleiner als<\/h5>\n
Hier wird ein “<\/span>kleiner als“-Vergleich gezeigt.<\/span><\/h6>\n
Eingabe:<\/h6>\n
Ausgabe:<\/h6>\n
Exit-Status<\/h2>\n
\n\n