{"id":7236,"date":"2021-05-28T19:16:31","date_gmt":"2021-05-28T19:16:31","guid":{"rendered":"https:\/\/profi-tutorials.de\/linux\/?p=7236"},"modified":"2021-07-09T14:35:49","modified_gmt":"2021-07-09T14:35:49","slug":"befehl-expr","status":"publish","type":"post","link":"https:\/\/profi-tutorials.de\/linux\/grundlagen\/befehl-expr\/","title":{"rendered":"Der Befehl expr"},"content":{"rendered":"

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

Allgemeine Syntax<\/h2>\n

Die allgemeine Syntax von expr <\/strong>lautet folgendermaßen:<\/p>\n

expr [Ausdruck]<\/pre>\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
String-Ausdrücke<\/h2>\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<\/h3>\n
Pattern-Matching wird mit der folgenden Syntax durchgeführt:<\/p>\n
[String] : [Regex]<\/pre>\n
Die folgende alternative Syntax ist jedoch ebenfalls gültig:<\/p>\n
match [String] [Regex]<\/pre>\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
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
expr ‘Linux Prof. Hellberg EDV-Beratung – Profi-Tutorials’ : ‘Linux’<\/p>\n
Ausgabe:<\/h6>\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
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
expr ‘Der Befehl expr’ : ‘Der Befehl (.*)’<\/p>\n
Ausgabe:<\/h6>\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
Substring<\/h3>\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
substr [string] [Position] [Länge]<\/pre>\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
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
expr substr ‘Prof. Hellberg EDV-Beratung’ 7 8<\/p>\n
Ausgabe:<\/h6>\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
Index<\/h3>\n
Die Position des ersten Vorkommnisses eines Zeichens aus einem spezifischen Zeichensatz<\/a> im übergebenen String wird mit folgender Syntax ermittelt:<\/p>\n
index [String] [Zeichensatz]<\/pre>\n
Wird kein Vorkommnis gefunden, so wird eine “0<\/strong>” ausgegeben.<\/p>\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
expr index ‘IT-Consulting’ ‘abCd’<\/p>\n
Ausgabe:<\/h6>\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
Länge<\/h3>\n
Die Länge eines übergebenen Strings wird folgendermaßen ermittelt:<\/p>\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
expr length ‘Profi-Tutorials’<\/p>\n
Ausgabe:<\/h6>\n
expr<\/strong> gibt eine “15<\/strong>” aus – die Länge des Strings “Profi-Tutorials<\/strong>“.<\/p>\n
15<\/p>\n
String-Interpretation<\/h3>\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
+ [Token]<\/pre>\n
Soll der Befehl expr<\/strong> ein Keyword als String<\/strong> interpretieren, so müssen stets Anführungszeichen “”<\/strong> verwendet werden.<\/p>\n
Numerische Ausdrücke<\/h2>\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
Addition \/ Substraktion<\/h3>\n
Die Addition zweier Integer-Zahlen<\/strong> wird folgendermaßen durchgeführt:<\/p>\n
[Integer 1] + [Integer 2]<\/pre>\n
Analog wird auch die Subtraktion<\/strong> durchgeführt:<\/p>\n
[Integer 1] - [Integer 2]<\/pre>\n
Können die übergebenen Argumente nicht als Integer interpretiert werden, so gibt expr<\/strong> eine Error-Meldung<\/strong> aus.<\/p>\n
Beispiel: Addition<\/h5>\n
Dieses Beispiel zeigt die <\/span>Addition zweier Zahlen.<\/span><\/h6>\n
Eingabe:<\/h6>\n
expr 55 + 45<\/p>\n
Ausgabe:<\/h6>\n
Das Ergebnis der Addition “55 + 45” wird ausgegeben.<\/p>\n
100<\/p>\n
Beispiel: Subtraktion<\/h5>\n
Hier wird die <\/span>Subtraktion zweier Zahlen gezeigt.<\/span><\/h6>\n
Eingabe:<\/h6>\n
expr 10 – 2<\/p>\n
Ausgabe:<\/h6>\n
expr<\/strong> gibt das Ergebnis der Subtraktion “10 – 2” aus.<\/p>\n
8<\/p>\n
Multiplikation \/ Division \/ Modulo<\/h3>\n
Die Multiplikation <\/strong>erfolgt nach folgender Syntax (Das Zeichen “*<\/strong>” muss maskiert werden, damit es nicht von der Shell interpretiert wird):<\/p>\n
[Integer 1] * [Integer 2]<\/pre>\n
Die Division <\/strong>wird mit dem Operator <\/strong>“\/<\/strong>” durchgeführt:<\/p>\n
[Integer 1] \/ [Integer 2]<\/pre>\n
Schließlich wird auch der Modulo-Operator<\/strong> “%<\/strong>” unterstützt, welcher den Rest einer Integer-Division<\/strong> ausgibt:<\/p>\n
[Integer 1] % [Integer 2]<\/pre>\n
Beispiel: Multiplikation<\/h5>\n
Zwei Zahlen werden in diesem Beispiel multipliziert.<\/span><\/h6>\n
Eingabe:<\/h6>\n
expr 6 * 6<\/p>\n
Ausgabe:<\/h6>\n
Das Produkt der beiden Zahlen wird ausgegeben.<\/p>\n
36<\/p>\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
expr 9 \/ 2<\/p>\n
Ausgabe:<\/h6>\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
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
expr 9 % 2<\/p>\n
Ausgabe:<\/h6>\n
Der durch die Modulo-Operation berechnete Rest beträgt “1<\/strong>“. (2 * 4 + Rest 1 = 9<\/strong>)<\/p>\n
1<\/p>\n
Relationale \/ logische Ausdrücke<\/h2>\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
Oder<\/h3>\n
Ein Lazy-Oder wird mit der folgenden Syntax realisiert (das Pipe-Symbol<\/strong> “|<\/strong>” muss maskiert werden):<\/p>\n
[Argument 1] | [Argument 2]<\/pre>\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
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
expr 5 | 0<\/p>\n
Ausgabe:<\/h6>\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
Und<\/h3>\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
[Argument 1] & [Argument 2]<\/pre>\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
Beispiel: Und 1<\/h5>\n
Eine Und-Verknüpfung zweier Operatoren wird in diesem Beispiel vorgestellt.<\/span><\/h6>\n
Eingabe:<\/h6>\n
expr 0 & “hedv”<\/p>\n
Ausgabe:<\/h6>\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
Beispiel: Und 2<\/h5>\n
Dieses Beispiel zeigt eine weitere Und-Verknüpfung.<\/span><\/h6>\n
Eingabe:<\/h6>\n
expr “admina” & “hedv”<\/p>\n
Ausgabe:<\/h6>\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
Relationale Operatoren<\/h3>\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
[Argument 1] [Operator] [Argument 2]<\/pre>\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\n\n\n\n\n\n\n\n\n\n
Operator<\/strong><\/th>\nBeschreibung<\/th>\n<\/tr>\n<\/thead>\n
\n
<<\/p>\n<\/td>\n
\n
[Argument 1] ist echt kleiner als [Argument 2]\n<\/p><\/td>\n<\/tr>\n
\n
<=<\/p>\n<\/td>\n
\n
[Argument 1] ist kleiner oder gleich [Argument 2]\n<\/p><\/td>\n<\/tr>\n
\n
= bzw. ==<\/p>\n<\/td>\n
\n
[Argument 1] ist gleich [Argument 2]\n<\/p><\/td>\n<\/tr>\n
\n
!=<\/p>\n<\/td>\n
\n
[Argument 1] ist ungleich [Argument 2]\n<\/p><\/td>\n<\/tr>\n
\n
>=<\/p>\n<\/td>\n
\n
[Argument 1] ist größer oder gleich [Argument 2]\n<\/p><\/td>\n<\/tr>\n
\n
><\/p>\n<\/td>\n
\n
[Argument 1] ist echt größer als [Argument 2]\n<\/p><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Beispiel: Gleichheit 1<\/h5>\n
In diesem Beispiel wird die Gleichheit zweier Argumente überprüft.<\/span><\/h6>\n
Eingabe:<\/h6>\n
expr “profi” == “profi”<\/p>\n
Ausgabe:<\/h6>\n
Da beide Argumente gleich sind, gibt expr <\/strong>den Wert “1<\/strong>” aus.<\/p>\n
1<\/p>\n
Beispiel: Gleichheit 2<\/h5>\n
Auch hier soll die Überprüfung der Gleichheit zweier Argumente stattfinden.<\/span><\/h6>\n
Eingabe:<\/h6>\n
expr “profi” == “tutorials”<\/p>\n
Ausgabe:<\/h6>\n
In diesem Fall wird eine “0<\/strong>” ausgegeben, da die Argumente “profi<\/strong>” und “tutorials<\/strong>” ungleich sind.<\/p>\n
0<\/p>\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
expr 50 > 42<\/p>\n
Ausgabe:<\/h6>\n
Es wird eine “1<\/strong>” ausgegeben – der Vergleich ist gültig.<\/p>\n
1<\/p>\n
Beispiel: Kleiner als<\/h5>\n
Hier wird ein “<\/span>kleiner als“-Vergleich gezeigt.<\/span><\/h6>\n
Eingabe:<\/h6>\n
expr “xyz” < “abc”<\/p>\n
Ausgabe:<\/h6>\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
Exit-Status<\/h2>\n
Der Befehl expr <\/strong>kennt schließlich folgende Exit-Status<\/strong>:<\/p>\n\n\n\n\n\n\n\n\n
Exit-Status<\/th>\nBeschreibung<\/th>\n<\/tr>\n<\/thead>\n
\n
0<\/p>\n<\/td>\n
\n
Der Ausdruck ist weder null, noch “0”<\/p>\n<\/td>\n<\/tr>\n
\n
1<\/p>\n<\/td>\n
\n
Der Ausdruck ist null oder “0”<\/p>\n<\/td>\n<\/tr>\n
\n
2<\/p>\n<\/td>\n
\n
Der Ausdruck ist ungültig<\/p>\n<\/td>\n<\/tr>\n
\n
3<\/p>\n<\/td>\n
\n
Ein interner Fehler ist aufgetreten (beispielsweise ein arithmetischer Überlauf)<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Abonniere JETZT unseren Newsletter!<\/p>\n
Verpasse nie wieder neue<\/strong> Beiträge und exklusive Insider-Only-Inhalte!<\/strong><\/p>\n","protected":false},"excerpt":{"rendered":"
In diesem Beitrag lernen Sie den Befehl expr kennen, welcher unter Linux- \/ UNIX-Betriebssystemen eingesetzt wird, um numerische- sowie String-Ausdr\u00fccke auszuwerten. Neben der allgemeinen Syntax lernen Sie auch die Anwendung des Befehls expr anhand verschiedener Beispiele anschaulich kennen. Allgemeine Syntax Die allgemeine Syntax von expr lautet folgenderma\u00dfen: Der expr \u00fcbergebene Ausdruck l\u00e4sst sich nun aus […]<\/p>\n","protected":false},"author":2,"featured_media":7876,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":"","tve_updated_post":"
\t
In diesem Beitrag lernen Sie den Befehl expr kennen, welcher unter Linux- \/ UNIX-Betriebssystemen eingesetzt wird, um numerische- sowie String-Ausdr\u00fccke auszuwerten.<\/p>
Neben der allgemeinen Syntax lernen Sie auch die Anwendung des Befehls expr anhand verschiedener Beispiele anschaulich kennen.<\/p><\/div>
\n\t
\n\t\tInhaltsverzeichnis<\/span>\n\t\t
Allgemeine Syntax<\/a><\/div>
String-Ausdr\u00fccke<\/a><\/div>
Pattern-Matching<\/a><\/div>
Substring<\/a><\/div>
Index<\/a><\/div>
L\u00e4nge<\/a><\/div>
String-Interpretation<\/a><\/div>
Numerische Ausdr\u00fccke<\/a><\/div>
Addition \/ Substraktion<\/a><\/div>
Multiplikation \/ Division \/ Modulo<\/a><\/div><\/div>
Relationale \/ logische Ausdr\u00fccke<\/a><\/div>
Oder<\/a><\/div>
Und<\/a><\/div>
Relationale Operatoren<\/a><\/div>
Exit-Status<\/a><\/div><\/div><\/div>\n\t<\/div>\n<\/div>
Allgemeine Syntax<\/h2>
Die allgemeine Syntax von expr <\/strong>lautet folgenderma\u00dfen:<\/p>
[code]expr [Ausdruck][\/code]<\/p>
Der expr <\/strong>\u00fcbergebene Ausdruck l\u00e4sst sich nun aus verschiedenen Operanden \/ Operatoren zusammensetzen, welche in den folgenden Abschnitten n\u00e4her erl\u00e4utert werden.<\/p>
String-Ausdr\u00fccke<\/h2>
Der Befehl expr <\/strong>unterst\u00fctzt neben Pattern-Matching auch einige weitere String-Operatoren, welche bei der Erstellung von String-Ausdr\u00fccken auch kombiniert werden k\u00f6nnen. String-Operatoren haben die h\u00f6chste Pr\u00e4zedenz aller bei expr <\/strong>verf\u00fcgbaren Operatoren.<\/p>
Im Folgenden werden die verf\u00fcgbaren String-Operationen vorgestellt.<\/p>
Pattern-Matching<\/h3>
Pattern-Matching wird mit der folgenden Syntax durchgef\u00fchrt:<\/p>
[code][String] : [Regex][\/code]<\/p>
Die folgende alternative Syntax ist jedoch ebenfalls g\u00fcltig:<\/p>
[code]match [String] [Regex][\/code]<\/p>
Die \u00fcbergebenen Argumente werden automatisch in Strings konvertiert. Das zweite Argument wird als einfacher regul\u00e4rer Ausdruck interpretiert, wobei ein \"^\" als Pr\u00e4fix implizit angeh\u00e4ngt wird, und mit dem ersten Argument verglichen.<\/p>
Bei einem erfolgreichen Match wird standardm\u00e4\u00dfig die Anzahl \u00fcbereinstimmender Zeichen<\/strong> ausgegeben - wurde im regul\u00e4ren Ausdruck geklammert (\"(<\/strong>\" und \")<\/strong>\"), so wird stattdessen der mit diesem Subausdruck \u00fcbereinstimmende Teil des \u00fcbergebenen Strings<\/strong> ausgegeben. F\u00fcr die Ausgabe des Pattern-Matching ist dabei lediglich das erste Vorkommen von Klammern relevant, alle weiteren Klammern dienen ausschlie\u00dflich der Einhaltung von Pr\u00e4zedenzregeln. Schl\u00e4gt der Match fehl, so wird ohne Verwendung von Klammerung eine \"0<\/strong>\", andernfalls der null-String<\/strong> ausgegeben.<\/p><\/div>
\n\t
<\/div>\n\t
Beispiel: Pattern-Matching 1<\/h5><\/div>
\n\t
\n<\/div>
In diesem Beispiel soll am Anfang des Strings \"<\/span>Linux Prof. Hellberg EDV-Beratung - Profi-Tutorials\" nach einer \u00dcbereinstimmung mit dem Wort \"<\/span>Linux\" gesucht werden. Da das Zeichen \"^\", welches den Anfang einer Zeile markiert, stet impliziert wird, wird als regul\u00e4rer Ausdruck lediglich das Wort \"<\/span>Linux\" angegeben.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
expr 'Linux Prof. Hellberg EDV-Beratung - Profi-Tutorials' : 'Linux'<\/p><\/div>
Ausgabe:<\/h6>
Es wird eine \"5<\/strong>\" ausgegeben, da die ersten 5 Zeichen des Strings mit dem regul\u00e4ren Ausdruck \u00fcbereinstimmen. In diesem Fall entspricht dies genau der L\u00e4nge des Wortes \"Linux<\/strong>\".<\/p><\/div>
5<\/p><\/div><\/div>\n<\/div>
\n\t
<\/div>\n\t
Beispiel: Pattern-Matching 2<\/h5><\/div>
\n\t
\n<\/div>
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><\/div>
Eingabe:<\/h6><\/div>
expr 'Der Befehl expr' : 'Der Befehl (.*)'<\/p><\/div>
Ausgabe:<\/h6>
Erwartungsgem\u00e4\u00df gibt expr<\/strong> an dieser Stelle das Wort \"expr<\/strong>\" aus. Mithilfe des verwendeten regul\u00e4ren Ausdrucks ist es damit m\u00f6glich, den Befehlsteil eines beliebigen Titels \"Der Befehl [Befehl]<\/strong>\" zu erhalten.<\/p><\/div>
expr<\/p><\/div><\/div>\n<\/div>
Substring<\/h3>
Ein Substring des \u00fcbergebenen Strings [String<\/strong>], beginnend an der Position [Position<\/strong>] mit der L\u00e4nge [L\u00e4nge<\/strong>], wird mit der folgenden Syntax erhalten:<\/p>
[code]substr [string] [Position] [L\u00e4nge][\/code]<\/p>
Ist das L\u00e4ngen- und \/ oder Positions-Argument null<\/strong>, negativ<\/strong> oder nicht-numerisch<\/strong>, so wird stets der null-String<\/strong> ausgegeben.<\/p><\/div>
\n\t
<\/div>\n\t
Beispiel: Substring<\/h5><\/div>
\n\t
\n<\/div>
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\u00e4nge \"<\/span>8\" (L\u00e4nge des Wortes \"<\/span>Hellberg\") verwendet.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
expr substr 'Prof. Hellberg EDV-Beratung' 7 8<\/p><\/div>
Ausgabe:<\/h6>
expr<\/strong> gibt nun die Zeichenkette, welche an der 7. Position beginnt und an der 14. Position (7+8-1) endet, aus.<\/p><\/div>
Hellberg<\/p><\/div><\/div>\n<\/div>
Index<\/h3>
Die Position des ersten Vorkommnisses eines Zeichens aus einem spezifischen Zeichensatz im \u00fcbergebenen String wird mit folgender Syntax ermittelt:<\/p>
[code]index [String] [Zeichensatz][\/code]<\/p>
Wird kein Vorkommnis gefunden, so wird eine \"0<\/strong>\" ausgegeben.<\/p><\/div>
\n\t
<\/div>\n\t
Beispiel: Index<\/h5><\/div>
\n\t
\n<\/div>
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><\/div>
Eingabe:<\/h6><\/div>
expr index 'IT-Consulting' 'abCd'<\/p><\/div>
Ausgabe:<\/h6>
In diesem Fall wird eine \"4<\/strong>\" ausgegeben, da das Zeichen \"C<\/strong>\" an 4. Position im String \"IT-Consulting<\/strong>\" auftaucht.<\/p><\/div>
4<\/p><\/div><\/div>\n<\/div>
L\u00e4nge<\/h3>
Die L\u00e4nge eines \u00fcbergebenen Strings wird folgenderma\u00dfen ermittelt:<\/p>
[code]length [String][\/code]<\/p><\/div>
\n\t
<\/div>\n\t
Beispiel: L\u00e4nge<\/h5><\/div>
\n\t
\n<\/div>
Die L\u00e4nge des Strings \"<\/span>Profi-Tutorials\" wird in diesem Beispiel ermittelt:<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
expr length 'Profi-Tutorials'<\/p><\/div>
Ausgabe:<\/h6>
expr<\/strong> gibt eine \"15<\/strong>\" aus - die L\u00e4nge des Strings \"Profi-Tutorials<\/strong>\".<\/p><\/div>
15<\/p><\/div><\/div>\n<\/div>
String-Interpretation<\/h3>
Mithilfe des Plus<\/strong> \"+\" Operators (GNU Extensions) wird das \u00fcbergebene Argument [Token] als String interpretiert<\/strong> - unabh\u00e4ngig davon, ob es sich um ein spezielles Keyword<\/strong>, wie etwa \"match<\/strong>\" oder \"index<\/strong>\", handelt:<\/p>
[code]+ [Token][\/code]<\/p>
Soll der Befehl expr<\/strong> ein Keyword als String<\/strong> interpretieren, so m\u00fcssen stets Anf\u00fchrungszeichen \"\"<\/strong> verwendet werden.<\/p>
Numerische Ausdr\u00fccke<\/h2>
Der Befehl expr<\/strong> erlaubt die Verwendung der mathematischen Standardoperationen - die \u00fcblichen Pr\u00e4zedenzregeln werden dabei eingehalten. Die Pr\u00e4zedenz der numerischen Operatoren ist h\u00f6her als die der relationalen \/ logischen Operatoren.<\/p>
Addition \/ Substraktion<\/h3>
Die Addition zweier Integer-Zahlen<\/strong> wird folgenderma\u00dfen durchgef\u00fchrt:<\/p>
[code][Integer 1] + [Integer 2][\/code]<\/p>
Analog wird auch die Subtraktion<\/strong> durchgef\u00fchrt:<\/p>
[code][Integer 1] - [Integer 2][\/code]<\/p>
K\u00f6nnen die \u00fcbergebenen Argumente nicht als Integer interpretiert werden, so gibt expr<\/strong> eine Error-Meldung<\/strong> aus.<\/p><\/div>
\n\t
<\/div>\n\t
Beispiel: Addition<\/h5><\/div>
\n\t
\n<\/div>
Dieses Beispiel zeigt die <\/span>Addition zweier Zahlen.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
expr 55 + 45<\/p><\/div>
Ausgabe:<\/h6>
Das Ergebnis der Addition \"55 + 45\" wird ausgegeben.<\/p><\/div>
100<\/p><\/div><\/div>\n<\/div>
\n\t
<\/div>\n\t
Beispiel: Subtraktion<\/h5><\/div>
\n\t
\n<\/div>
Hier wird die <\/span>Subtraktion zweier Zahlen gezeigt.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
expr 10 - 2<\/p><\/div>
Ausgabe:<\/h6>
expr<\/strong> gibt das Ergebnis der Subtraktion \"10 - 2\" aus.<\/p><\/div>
8<\/p><\/div><\/div>\n<\/div>
Multiplikation \/ Division \/ Modulo<\/h3>
Die Multiplikation <\/strong>erfolgt nach folgender Syntax (Das Zeichen \"*<\/strong>\" muss maskiert werden, damit es nicht von der Shell interpretiert wird):<\/p>
[code][Integer 1] * [Integer 2][\/code]<\/p>
Die Division <\/strong>wird mit dem Operator <\/strong>\"\/<\/strong>\" durchgef\u00fchrt:<\/p>
[code][Integer 1] \/ [Integer 2][\/code]<\/p>
Schlie\u00dflich wird auch der Modulo-Operator<\/strong> \"%<\/strong>\" unterst\u00fctzt, welcher den Rest einer Integer-Division<\/strong> ausgibt:<\/p>
[code][Integer 1] % [Integer 2][\/code]<\/p><\/div>
\n\t
<\/div>\n\t
Beispiel: Multiplikation<\/h5><\/div>
\n\t
\n<\/div>
Zwei Zahlen werden in diesem Beispiel multipliziert.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
expr 6 * 6<\/p><\/div>
Ausgabe:<\/h6>
Das Produkt der beiden Zahlen wird ausgegeben.<\/p><\/div>
36<\/p><\/div><\/div>\n<\/div>
\n\t
<\/div>\n\t
Beispiel: Division<\/h5><\/div>
\n\t
\n<\/div>
Eine Zahl wird in diesem Beispiel durch eine andere geteilt. Zu beachten ist hierbei der Rest.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
expr 9 \/ 2<\/p><\/div>
Ausgabe:<\/h6>
expr <\/strong>gibt eine \"4<\/strong>\" als Ergebnis der Division zur\u00fcck. 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><\/div>
4<\/p><\/div><\/div>\n<\/div>
\n\t
<\/div>\n\t
Beispiel: Modulo<\/h5><\/div>
\n\t
\n<\/div>
In diesem Beispiel soll der Rest der zuvor durchgef\u00fchrten Division \"<\/span>9 \/ 2\" ermittelt werden.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
expr 9 % 2<\/p><\/div>
Ausgabe:<\/h6>
Der durch die Modulo-Operation berechnete Rest betr\u00e4gt \"1<\/strong>\". (2 * 4 + Rest 1 = 9<\/strong>)<\/p><\/div>
1<\/p><\/div><\/div>\n<\/div>
Relationale \/ logische Ausdr\u00fccke<\/h2>
Auch einige relationale bzw. logische Operatoren werden von expr <\/strong>unterst\u00fctzt. Die relationalen \/ logischen Operatoren haben die niedrigste Pr\u00e4zedenz - im Folgenden werden diese nach aufsteigender Rangfolge vorgestellt:<\/p>
Oder<\/h3>
Ein Lazy-Oder wird mit der folgenden Syntax realisiert (das Pipe-Symbol<\/strong> \"|<\/strong>\" muss maskiert werden):<\/p>
[code][Argument 1] | [Argument 2][\/code]<\/p>
expr <\/strong>gibt hierbei das erste Argument zur\u00fcck, 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\u00fcr. Treffen die Bedingungen weeder bei dem ersten, noch dem zweiten Argument zu, so ist die Ausgabe \"0<\/strong>\".<\/p>
Es handelt sich um ein Lazy-Oder<\/strong>, weswegen das zweite Argument nicht ausgewertet wird, wenn eine Ausgabe des ersten Arguments erfolgt.<\/p><\/div>
\n\t
<\/div>\n\t
Beispiel: Oder<\/h5><\/div>
\n\t
\n<\/div>
Hier wird eine Order-Verkn\u00fcpfung der beiden Argumente \"<\/span>5\" und \"<\/span>0\" durchgef\u00fchrt.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
expr 5 | 0<\/p><\/div>
Ausgabe:<\/h6>
Das Ergebnis der Oder-Verkn\u00fcpfung 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><\/div>
5<\/p><\/div><\/div>\n<\/div>
Und<\/h3>
Mit der folgenden Syntax wird die Verkn\u00fcpfung zweier Argumente mit einem Lazy-Und durchgef\u00fchrt (das Et-Zeichen<\/strong> \"&<\/strong>\" muss maskiert werden):<\/p>
[code][Argument 1] & [Argument 2][\/code]<\/p>
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>
Auch hier handelt es sich wieder um eine Lazy-Variante<\/strong>: Das zweite Argument wird nicht ausgewertet, wenn die Bedingungen f\u00fcr das erste Argument nicht zutreffen.<\/p><\/div>
\n\t
<\/div>\n\t
Beispiel: Und 1<\/h5><\/div>
\n\t
\n<\/div>
Eine Und-Verkn\u00fcpfung zweier Operatoren wird in diesem Beispiel vorgestellt.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
expr 0 & \"hedv\"<\/p><\/div>
Ausgabe:<\/h6>
Es wird eine \"0<\/strong>\" ausgegeben, da es sich bei dem ersten Argument um den Zahlenwert \"0<\/strong>\" handelt.<\/p><\/div>
0<\/p><\/div><\/div>\n<\/div>
\n\t
<\/div>\n\t
Beispiel: Und 2<\/h5><\/div>
\n\t
\n<\/div>
Dieses Beispiel zeigt eine weitere Und-Verkn\u00fcpfung.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
expr \"admina\" & \"hedv\"<\/p><\/div>
Ausgabe:<\/h6>
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><\/div>
admina<\/p><\/div><\/div>\n<\/div>
Relationale Operatoren<\/h3>
Mithilfe der in der folgenden Tabelle aufgelisteten Operatoren lassen sich zwei Argumente miteinander vergleichen<\/strong>. Die Syntax ist die folgende (auch hier m\u00fcssen Operatoren teilweise maskiert werden, da diese - beispielsweise die Umleitung mit \"<\" - sonst von der Shell interpretiert werden):<\/p>
[code][Argument 1] [Operator] [Argument 2][\/code]<\/p>
expr <\/strong>versucht zun\u00e4chst, die \u00fcbergebenen Argumente in Integer zu konvertieren und anschlie\u00dfend einen numerischen Vergleich<\/strong> durchzuf\u00fchren - schl\u00e4gt dies fehl, so wird ein lexikographischer Vergleich<\/strong> unter Verwendung der durch die Umgebungsvariable <\/strong>\"LC_COLLATE<\/strong>\" spezifizierten Sortierreihenfolge <\/strong>durchgef\u00fchrt.<\/p><\/div>
Operator<\/strong><\/p><\/div><\/th>
Beschreibung<\/p><\/div><\/th><\/tr><\/thead>
<<\/p><\/div><\/td>
[Argument 1] ist echt kleiner als [Argument 2]<\/p><\/div><\/td><\/tr>
<=<\/p><\/div><\/td>
[Argument 1] ist kleiner oder gleich [Argument 2]<\/p><\/div><\/td><\/tr>
= bzw. ==<\/p><\/div><\/td>
[Argument 1] ist gleich [Argument 2]<\/p><\/div><\/td><\/tr>
!=<\/p><\/div><\/td>
[Argument 1] ist ungleich [Argument 2]<\/p><\/div><\/td><\/tr>
>=<\/p><\/div><\/td>
[Argument 1] ist gr\u00f6\u00dfer oder gleich [Argument 2]<\/p><\/div><\/td><\/tr>
><\/p><\/div><\/td>
[Argument 1] ist echt gr\u00f6\u00dfer als [Argument 2]<\/p><\/div><\/td><\/tr><\/tbody><\/table><\/div>
\n\t
<\/div>\n\t
Beispiel: Gleichheit 1<\/h5><\/div>
\n\t
\n<\/div>
In diesem Beispiel wird die Gleichheit zweier Argumente \u00fcberpr\u00fcft.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
expr \"profi\" == \"profi\"<\/p><\/div>
Ausgabe:<\/h6>
Da beide Argumente gleich sind, gibt expr <\/strong>den Wert \"1<\/strong>\" aus.<\/p><\/div>
1<\/p><\/div><\/div>\n<\/div>
\n\t
<\/div>\n\t
Beispiel: Gleichheit 2<\/h5><\/div>
\n\t
\n<\/div>
Auch hier soll die \u00dcberpr\u00fcfung der Gleichheit zweier Argumente stattfinden.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
expr \"profi\" == \"tutorials\"<\/p><\/div>
Ausgabe:<\/h6>
In diesem Fall wird eine \"0<\/strong>\" ausgegeben, da die Argumente \"profi<\/strong>\" und \"tutorials<\/strong>\" ungleich sind.<\/p><\/div>
0<\/p><\/div><\/div>\n<\/div>
\n\t
<\/div>\n\t
Beispiel: Gr\u00f6\u00dfer als<\/h5><\/div>
\n\t
\n<\/div>
Dieses Beispiel zeigt die Durchf\u00fchrung eines \"<\/span>gr\u00f6\u00dfer als\"-Vergleichs.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
expr 50 > 42<\/p><\/div>
Ausgabe:<\/h6>
Es wird eine \"1<\/strong>\" ausgegeben - der Vergleich ist g\u00fcltig.<\/p><\/div>
1<\/p><\/div><\/div>\n<\/div>
\n\t
<\/div>\n\t
Beispiel: Kleiner als<\/h5><\/div>
\n\t
\n<\/div>
Hier wird ein \"<\/span>kleiner als\"-Vergleich gezeigt.<\/span><\/h6><\/div>
Eingabe:<\/h6><\/div>
expr \"xyz\" < \"abc\"<\/p><\/div>
Ausgabe:<\/h6>
Der Befehl expr <\/strong>gibt hier eine \"0<\/strong>\" aus, da das Argument \"xyz<\/strong>\" lexikographisch gr\u00f6\u00dfer ist als das Argument \"abc<\/strong>\".<\/p><\/div>
0<\/p><\/div><\/div>\n<\/div>
Exit-Status<\/h2>
Der Befehl expr <\/strong>kennt schlie\u00dflich folgende Exit-Status<\/strong>:<\/p><\/div>
Exit-Status<\/p><\/div><\/th>
Beschreibung<\/p><\/div><\/th><\/tr><\/thead>
0<\/p><\/div><\/td>
Der Ausdruck ist weder null, noch \"0\"<\/p><\/div><\/td><\/tr>
1<\/p><\/div><\/td>
Der Ausdruck ist null oder \"0\"<\/p><\/div><\/td><\/tr>
2<\/p><\/div><\/td>
Der Ausdruck ist ung\u00fcltig<\/p><\/div><\/td><\/tr>
3<\/p><\/div><\/td>
Ein interner Fehler ist aufgetreten (beispielsweise ein arithmetischer \u00dcberlauf)<\/p><\/div><\/td><\/tr><\/tbody><\/table><\/div>
\n\t
<\/div>\n\t
Abonniere JETZT unseren Newsletter!<\/p><\/div>
\n\t
\n<\/div>
Verpasse nie wieder neue<\/strong> Beitr\u00e4ge und exklusive Insider-Only-Inhalte!<\/strong><\/p><\/div>
\n\t
<\/div>
<\/div>