$ wenn wahr;dann echo JA; sonst echo fiYES$ wenn falsch;dann echo JA;sonst echo NEIN;
$ wenn wahr && wahr;dann echo JA$ wenn wahr && falsch;dann echo JA$ wenn falsch && falsch;dann echo JA$ wenn falsch && wahr ;dann Echo JA; sonst Echo NEIN;
$ wenn wahr ||. echo ja; sonst echo fija $ wenn wahr || false ||. false;dann echo JA; sonst echo NEIN;
$ wenn ! false;dann echo NEIN; dann echo fiNO;
Es kann sich sehen lassen
WAHRUnd
FALSCHWir gehen entsprechend unserem Verständnis logischer Operationen vor, aber um Shells Implementierung logischer Operationen besser zu verstehen, müssen wir herausfinden:
WAHRUnd
FALSCHWie funktioniert es?
Die Antwort lautet: Nein.
WAHRUnd
FALSCHSie sind selbst keine logischen Werte, sie sind alle integrierte Befehle der Shell, aber ihr Rückgabewert ist ein „logischer Wert“:
$ true$ echo $?0$ false$ echo $?1
kann gesehen werden
WAHRgab 0 zurück und
FALSCHDann wird 1 zurückgegeben. Es entspricht nicht den wahren Werten 1 und 0, die wir in der diskreten Mathematik gelernt haben, sondern ist das Gegenteil.
$ help true falsetrue: true Gibt ein erfolgreiches Ergebnis zurück.false: false Gibt ein erfolgloses Ergebnis zurück.$ type true falsetrue ist eine eingebaute Shell.false ist eine eingebaute Shell
veranschaulichen:
$?Es handelt sich um eine spezielle Variable, die den Endstatus (Exit-Statuscode) des letzten Prozesses speichert.
Aus den oben genannten Vorgängen ist es nicht schwer zu verstehen, warum der Schwerpunkt auf der C-Sprachprogrammierung liegt.
hauptsächlichVor der Funktion hinzufügen
intund am Ende hinzufügen
0 zurückgeben. Denn in der Shell wird 0 als Zeichen dafür verwendet, ob das Programm erfolgreich beendet wird. Dies ist, was die Shell
WAHRUnd
FALSCHIm Wesentlichen werden sie verwendet, um anzuzeigen, ob ein bestimmtes Programm korrekt endet, und nicht mit den herkömmlichen wahren und falschen Werten (1 und 0). Im Gegenteil, sie geben 0 und 1 zurück. Glücklicherweise müssen wir uns darüber keine Gedanken machen, wenn wir logische Operationen ausführen.
Aus dem vorherigen Abschnitt haben wir klar verstanden, was der „logische Wert“ unter Shell ist: Es ist der Rückgabewert, wenn der Prozess erfolgreich beendet wird, ist er wahr, wenn er nicht erfolgreich zurückgegeben wird, ist er falsch.
Und der bedingte Test verwendet einfach
prüfenEine solche Anweisung wird verwendet, um numerische Tests (verschiedene numerische Attributtests), String-Tests (verschiedene String-Attributtests) und Dateitests (verschiedene Dateiattributtests) durchzuführen. Wir beurteilen, ob der entsprechende Test erfolgreich ist, nachdem wir verschiedene Routineaufgaben abgeschlossen haben Gepaart mit der logischen Kombination verschiedener Tests können komplexere Aufgaben gelöst werden.
$ wenn test 5 -eq 5;dann echo JA; sonst echo fiYES$ wenn test 5 -ne 5;dann echo JA;
$ wenn test -n nicht leer;dann echo fiYES$, wenn test -z nicht leer;dann echo fiNO$;dann echo fiYES$ wenn test -n ;dann echo JA; sonst echo fiNO;
$ wenn test -f /boot/System.map; dann echo NEIN; wenn test -d /boot/System.map; dann echo NEIN;
$ a=5;b=4;c=6;$ if test $a -eq 5 -a $b -eq 4 -a $c -eq 6;
$ if test -f /etc/profile -o -d /etc/profile;then echo YES; else echo fiYES
!KEIN Betrieb
$ if test ! -f /etc/profile; then echo YES;
Das Obige zeigt nur
prüfenBeherrschen Sie einige sehr einfache Tests, die Sie bestehen können
HilfetestErhalten
prüfenWeitere Verwendungsmöglichkeiten von . Das ist zu beachten
prüfenEs gibt einige Unterschiede zwischen den logischen Operationen innerhalb des Befehls und den logischen Operatoren der Shell. Die entsprechenden sind:
-AUnd
&&,
-OUnd
||, die beiden können nicht verwechselt werden. Anstatt Operationen zu sein
!, vergleichen Sie sie unten.
$ cat > test.sh#!/bin/bashecho test[STRG+D] # Drücken Sie die Tastenkombination STRG und D, um die Cat-Eingabe zu beenden, das gleiche wie unten, geben Sie nicht mehr $ chmod +x test.sh$ if test an -s test .sh -a -x test.sh; then echo fiYES$ if test -s test.sh && test -x test.sh;
$ str1=test$ str2=test$ if test -z $str2 -o $str2 == $str1; then echo YES$ if test -z $str2 == $str1; dann echo JA; sonst echo fiYES
$ i=5$ if test $i -lt 5 -a $i -ne 6; else echo fiYES$ if ! ; sonst echo NEIN;
Es ist leicht, den Unterschied zwischen ihnen zu erkennen,
-AUnd
-OAls Parameter des Testbefehls wird er innerhalb des Testbefehls verwendet und
&&Und
||Es wird verwendet, um den Rückgabewert des Tests zu berechnen.
!Beiden gemeinsam. Was Aufmerksamkeit erfordert, ist:
Manchmal ist es nicht notwendig
!Betreiber, wie z
-GlUnd
-neIm Gegenteil, es kann verwendet werden, um zu testen, ob zwei Werte gleich sind;
-zUnd
-NEs ist auch entsprechend und wird verwendet, um zu testen, ob eine bestimmte Zeichenfolge leer ist.
existieren
Bashinnen,
prüfenBefehle können durch den Operator [] ersetzt werden, es ist jedoch zu beachten, dass [
Anschließend mit] müssen zusätzliche Leerzeichen vorangestellt werden
Beim Testen einer Zeichenfolge wird empfohlen, alle Variablen in doppelte Anführungszeichen zu setzen, um zu verhindern, dass nur Testparameter und kein Testinhalt vorhanden sind, wenn der Variableninhalt leer ist.
Im Folgenden veranschaulichen wir anhand von Beispielen die oben genannten drei Vorsichtsmaßnahmen:
-neUnd
-GlDementsprechend können wir manchmal darauf verzichten
!Betrieb
$ i=5$ wenn test $i -eq 5; sonst echo NEIN; wenn test $i -ne 5; dann Echo JA; sonst Echo NEIN;
verwenden
[ ]ersetzen kann
prüfen, es wird viel „schöner“ aussehen
$ if [ $i -eq 5 ]; then echo YES; if [ $i -gt 4 ] & [ $i -lt 6 ];
Denken Sie daran, einige String-Variablen hinzuzufügen
,Erinnern[Anschließend mit
]Fügen Sie vorher ein zusätzliches Leerzeichen hinzu
$ str=$ if [ $str = test]; then echo NO; bash: [: =: unärer Operator erwartetNO$ if [ $str = test ]; then echo YES else echo NO;
An dieser Stelle wurde der bedingte Test eingeführt. Tatsächlich haben wir ihn oben bereits verwendet, also eine Kombination mehrerer Testbefehle
&&,
||Und
!Eine Folge kombinierter Befehle. Diese Befehlsfolge ersetzt effektiv
wenn/dannbedingte Zweigstruktur. Es ist nicht schwer, sich die folgenden Multiple-Choice-Fragen vorzustellen, die wir häufig in der C-Sprachprogrammierung stellen (sehr langweiliges, aber aussagekräftiges Beispiel): Wird Folgendes gedruckt?
J, wenn gedruckt, was wird gedruckt?
#include <stdio.h>int main(){ int i, j; i=5;j=1; if ((i==5) && (j=5)) printf(%dn, j); 0 zurückgeben;}
Es ist leicht zu wissen, dass die Nummer 5 gedruckt wird, weil
ich==5Diese Bedingung gilt und nachfolgend
&&Um zu beurteilen, ob die gesamte Bedingung erfüllt ist, müssen wir ein nachfolgendes Urteil fällen, aber dieses Urteil ist kein konventionelles Urteil, sondern zuerst
JÄndern Sie es in 5 und konvertieren Sie es dann in einen wahren Wert, sodass die Bedingung wahr ist und 5 gedruckt wird. Daher kann dieser Satz wie folgt interpretiert werden: Wenn
ichgleich 5 ist, dann setzen
JWeisen Sie einen Wert von 5 zu, wenn
Jgrößer als 1 ist (weil es vorher schon wahr war), dann ausdrucken
JWert. Benutzen Sie es auf diese Weise
&&Die verkettete Urteilsaussage ersetzt zwei
WennBedingte Verzweigungsanweisung.
Es basiert genau auf den einzigartigen Eigenschaften logischer Operationen, die wir übergeben können
&&,
||zu ersetzen
wenn/dannWarten Sie auf die bedingte Verzweigungsstruktur und generieren Sie so eine Befehlsliste.
Die Ausführungsregeln der Befehlsliste entsprechen den Operationsregeln logischer Operationen
&&Wenn der erstere bei verbundenen Befehlen erfolgreich zurückgegeben wird, wird der folgende Befehl ausgeführt, andernfalls verwenden Sie ihn
||Wenn die verbundenen Befehle erfolgreich zurückgegeben werden, werden die nachfolgenden Befehle nicht ausgeführt und umgekehrt.
$ ping -c 1 www.lzu.edu.cn -W 1 && echo =======connected========
Es stellt sich eine sehr interessante Frage, die wir oben erwähnt haben: Warum sollte das C-Programm so sein?
hauptsächlich()Gibt die Funktion am Ende 0 zurück? Wenn nicht, welche Konsequenzen hätte es, ein solches Programm in die Befehlsliste aufzunehmen? Schreiben Sie selbst ein einfaches C-Programm und fügen Sie es dann zur Anzeige in die Befehlsliste ein.
Manchmal wird stattdessen eine Befehlsliste verwendet
wenn/dannDie bedingte Verzweigungsstruktur kann Code einsparen und das Programm schöner und leichter lesbar machen, zum Beispiel:
#!/bin/bashecho $#echo $1if [ $# -eq 1 ] && (echo $1 | grep ^[0-9]*$ >/dev/null);dann echo YESfi
Hinweis: Das obige Beispiel erfordert, dass die Anzahl der Parameter 1 beträgt und der Typ numerisch ist.
Plus
Ausgang 1, werden wir weglassen
wenn/dannStruktur
#!/bin/bashecho $#echo $1! ([ $# -eq 1 ] && (echo $1 | grep ^[0-9]*$ >/dev/null)) && exit 1echo JA
Nach dieser Verarbeitung erfordert die Beurteilung der Programmparameter nur eine einfache Codezeile und wird schöner.
In diesem Abschnitt werden logische Operationen, bedingte Tests und Befehlslisten in der Shell-Programmierung vorgestellt.