Tutorial zum Erlernen von Shell-Skripten (1)

Enterprise 2023-10-01 02:05:09 views: null

Lernen von Shell-Skripten

1. Was ist Shell?

1. Shell-Übersicht

Shell ist eine Befehlszeilenschnittstelle (CLI) in einem Computerbetriebssystem, die es Benutzern ermöglicht, mit dem Betriebssystem zu interagieren und verschiedene Aufgaben und Vorgänge auszuführen. Shell ist außerdem eine Skript-Programmiersprache, mit der Benutzer Skripts schreiben können, um Aufgaben zu automatisieren und eine Reihe von Befehlen auszuführen

In Linux- und Unix-Betriebssystemen Shell 是用户与操作系统内核之间的中间层akzeptiert es vom Benutzer eingegebene Befehle und übergibt diese Befehle zur Ausführung an den Kernel. Benutzer können Befehle über die Tastatur eingeben, und die Shell schält 解释和执行diese Befehle dann ab. 输入和输出、环境变量、文件操作Die Shell ist auch für die Verarbeitung usw. verantwortlich.

Einige gängige Shells sind Bash (Bourne-Again Shell), Zsh (Z Shell), Fish (Friendly Interactive Shell) usw. Jede Shell hat ihre eigenen Eigenschaften und Funktionen. Bash ist die häufigste Standard-Shell unter Linux und macOS

Zu den Hauptanwendungen von Shell gehören:

  • Befehle und Programme ausführen: Benutzer können Befehle in die Shell eingeben, um Programme auszuführen, Dateien zu verwalten, den Systemstatus anzuzeigen usw.
  • Skriptprogrammierung: Benutzer können Shell-Skripte schreiben, um eine Reihe von Befehlen und Vorgängen zu kombinieren und so automatisierte Aufgaben auszuführen
  • Pipes und Umleitung: Mit der Shell können Benutzer die Ausgabe von Befehlen an andere Befehle weiterleiten sowie Ein- und Ausgaben an Dateien oder Geräte umleiten
  • Verwaltung von Umgebungsvariablen: Shell ermöglicht Benutzern das Festlegen und Verwalten von Umgebungsvariablen, die sich auf die laufende Umgebung von Benutzern und Programmen auswirken.
  • Prozesssteuerung: Shell unterstützt bedingte Anweisungen, Schleifen und Verzweigungen, sodass Benutzer komplexe Skriptlogik schreiben können

2. Klassifizierung von Muscheln

Shell-Programmierung erfordert, wie JavaScript- und PHP-Programmierung, einen Texteditor, der Code schreiben kann, und einen Skriptinterpreter, der ihn interpretieren und ausführen kann. Es gibt viele
Arten von Shells in Linux, und die häufigsten sind:

  • Bourne Shell (/usr/bin/sh oder /bin/sh)
  • Bourne Again Shell (/bin/bash)
  • C-Shell (/usr/bin/csh)
  • K-Shell (/usr/bin/ksh)
  • Shell für Root (/sbin/sh)

Dieses Tutorial konzentriert sich auf Bash, auch bekannt als Bourne Again Shell. Da es einfach zu verwenden und kostenlos ist, wird Bash häufig in der täglichen Arbeit verwendet. Gleichzeitig ist Bash auch die Standard-Shell für die meisten Linux-Systeme.

Im Allgemeinen wird nicht zwischen Bourne Shell und Bourne Again Shell unterschieden#!/bin/sh同样也可以改为 #!/bin/bash

#! 告诉系统其后路径所指定的程序即是解释此脚本文件的 Shell 程序

3. Das erste Shell-Skript

# 1. vim helloworld.sh 是打开一个文本编辑器（Vim）并创建或打开名为 "helloworld.sh" 的文件的命令
vim helloworld.sh

# 2. echo "hello, world!" 是一个 Shell 命令。作用是在终端上打印 "hello, world!"
echo "hello,world!"

# 3. 用于为一个文件赋予可执行权限 
chmod +x helloworld.sh

# 4. 运行这个脚本的命令
./helloworld.sh
  • Der Ausführungseffekt ist wie folgt:
    Fügen Sie hier eine Bildbeschreibung ein

4. Ausführung mehrerer Befehle

Mehrere Befehlsausführer Wirkung Format
; Mehrere Befehle werden nacheinander ausgeführt, ohne dass eine logische Verbindung zwischen den Befehlen besteht. Befehl 1; Befehl 2
&& Wenn Befehl 1 korrekt ausgeführt wird (Exit-Statuscode ist 0), wird Befehl 2 ausgeführt; andernfalls wird Befehl 2 nicht ausgeführt. Befehl 1 && Befehl 2
|| Befehl 2 wird nur ausgeführt, wenn Befehl 1 fehlerhaft ausgeführt wird (der Exit-Statuscode ist nicht 0); andernfalls wird Befehl 2 nicht ausgeführt. Befehl 1 || Befehl 2

Beispiel für die Ausführung mehrerer Befehle:

  1. Das Semikolon (;) wird verwendet, um mehrere Befehle nacheinander auszuführen, und es besteht keine logische Verbindung zwischen den Befehlen:

    $ command1 ; command2 ; command3

    Beispiel:

    $ ls ; echo "Hello" ; date

    Der obige Befehl führt lsden Befehl (Inhalt des aktuellen Verzeichnisses auflisten), echoden Befehl (Druck „Hallo“) und dateden Befehl (aktuelles Datum und Uhrzeit anzeigen) aus.

  2. Der logische UND-Operator (&&) wird nur dann zum Ausführen des nächsten Befehls verwendet, wenn der vorherige Befehl korrekt ausgeführt wurde:

    $ command1 && command2

    Beispiel:

    $ rm file.txt && echo "File deleted successfully"

    Der obige Befehl versucht zunächst, die Datei zu löschen file.txt. Wenn der Löschvorgang erfolgreich ist, führen Sie echoden Befehl aus, um „Datei erfolgreich gelöscht“ anzuzeigen. Wenn das Löschen der Datei fehlschlägt (Befehl 1 wurde falsch ausgeführt), echowird der Befehl nicht ausgeführt.

  3. Der logische ODER-Operator (||) wird nur dann zum Ausführen des nächsten Befehls verwendet, wenn der vorherige Befehl falsch ausgeführt wurde:

    $ command1 || command2

    Beispiel:

    $ find /tmp -name "file.txt" || echo "File not found"

    Der obige Befehl versucht zunächst, /tmpeine Datei mit dem Namen „file.txt“ im Verzeichnis zu finden. Wenn die Datei gefunden wird (Befehl 1 korrekt ausgeführt), echowird der Befehl nicht ausgeführt. Wenn die Datei nicht gefunden wird (Befehl 1 wurde fehlerhaft ausgeführt), echowird der Befehl ausgeführt, um „Datei nicht gefunden“ anzuzeigen.

2. Shell-Variablen

3.1 Benennungsregeln für Variablen

In Shell-Skripten sind Variablen Schlüsselelemente zum Speichern und Bearbeiten von Daten. Die richtige Benennung von Variablen ist der Schlüssel zum Schreiben klarer, lesbarer und robuster Skripte. Im Folgenden sind die Benennungsregeln für Shell-Variablen aufgeführt:

  1. Variablennamen können Folgendes enthalten:

    • Buchstaben (Groß- oder Kleinbuchstaben): a bis z oder A bis Z.
    • Zahlen: 0 bis 9 (Variablennamen dürfen jedoch nicht mit Zahlen beginnen).
    • Unterstreichen _.

  2. Variablennamen müssen mit einem Buchstaben oder einem Unterstrich beginnen. Es ist nicht erlaubt, mit einer Zahl zu beginnen.

  3. Bei Variablennamen muss die Groß-/Kleinschreibung beachtet werden, $myVares $myvarhandelt sich also um zwei verschiedene Variablen.

  4. Vermeiden Sie die Verwendung der reservierten Schlüsselwörter von Shell (z. B. if, while, for usw.) als Variablennamen

  5. Es wird empfohlen, aussagekräftige, beschreibende Variablennamen zu verwenden, um die Lesbarkeit des Skripts zu verbessern.

  6. Gängige Namensstile:

    • Camel Case: Das erste Wort beginnt mit einem Kleinbuchstaben und der erste Buchstabe der nachfolgenden Wörter wird großgeschrieben.
      Beispiel: myVariableName, thisIsCamelCase.

    • Unterstrich-Nomenklatur (Snake Case): Alle Buchstaben sind Kleinbuchstaben und Wörter werden _durch Unterstriche getrennt.
      Zum Beispiel: my_variable_name, this_is_snake_case.

Beispiel:

Hier sind einige Beispiele, die verschiedene Regeln für die Benennung von Variablen veranschaulichen:

# 驼峰命名法示例
myVariableName="Hello, World!"
thisIsCamelCase="这是一个驼峰命名"
anotherCamelCaseVariable="这是另个驼峰命名"

# 下划线命名法示例
my_variable_name="Hello, World!"
this_is_snake_case="这是下划线命名"
another_snake_case_variable="这是另一个下划线命名"

Korrekte Regeln für die Benennung von Variablen sind eine der Grundlagen der Shell-Skriptprogrammierung. Sie tragen dazu bei, wartbaren und lesbaren Code zu schreiben, Fehler zu reduzieren und die Codequalität zu verbessern.

3.2 Spezielle Symbole für Variablen

  1. $ : Das Dollarzeichen wird verwendet, um auf den Wert einer Variablen zu verweisen.
    Beispiel:

    myVar="Hello"
echo $myVar   # 输出：Hello

    Fügen Sie hier eine Bildbeschreibung ein

  2. * : Sternchen-Platzhalter, wird verwendet, um null oder mehr Zeichen zu finden.
    Beispiel:

    ls *.txt   # 列出所有以 ".txt" 结尾的文件

    Fügen Sie hier eine Bildbeschreibung ein

  3. ? : Fragezeichen-Platzhalter, der für jedes beliebige Zeichen verwendet wird.
    Beispiel:

    ls file?.txt   # 列出类似 "file1.txt"、"fileA.txt" 的文件

    Fügen Sie hier eine Bildbeschreibung ein

  4. [] : Eckige Klammern werden zur Definition des Zeichensatzes verwendet und können mit jedem Zeichen in den eckigen Klammern übereinstimmen.
    Beispiel:

    ls [aeiou]*   # 列出以元音字母开头的文件

    Fügen Sie hier eine Bildbeschreibung ein

  5. { } : Klammern werden zum Erstellen von Befehlssequenzen oder zum Erweitern von Zeichenfolgen verwendet.
    Beispiel:

    echo {
      
      A,B,C}   # 输出：A B C

    Fügen Sie hier eine Bildbeschreibung ein

  6. | : Der vertikale Balken wird verwendet, um die Ausgabe eines Befehls an einen anderen Befehl weiterzuleiten und so eine Pipe zu bilden.
    Beispiel:

    cat file.txt | grep "pattern"   # 在文件中搜索模式

    Fügen Sie hier eine Bildbeschreibung ein

  7. ; : Semikolon wird verwendet, um mehrere Befehle zu trennen, sodass mehrere Befehle in einer Zeile ausgeführt werden können.
    Beispiel:

    command1; command2   # 依次执行两个命令

    Fügen Sie hier eine Bildbeschreibung ein

  8. && : Logischer UND-Operator, der verwendet wird, um zwei Befehle auszuführen und den zweiten Befehl erst auszuführen, nachdem der erste Befehl erfolgreich war.
    Beispiel:

    make && make install   # 如果 make 成功，则执行 make install

  9. || : Logischer ODER-Operator, der verwendet wird, um zwei Befehle auszuführen und den zweiten Befehl nur dann auszuführen, wenn der erste Befehl fehlschlägt.
    Beispiel:

    command1 || echo "command1 failed"   # 如果 command1 失败，则输出提示

  10. \> : Das Größer-als-Symbol wird verwendet, um die Ausgabe eines Befehls in eine Datei umzuleiten.
    Beispiel:

    echo "Hello, World!" > output.txt   # 将文本写入文件

Fügen Sie hier eine Bildbeschreibung ein

  1. >> : Das doppelte Größer-als-Symbol wird verwendet, um die Ausgabe eines Befehls an eine Datei anzuhängen.
    Beispiel:
echo "More text" >> output.txt   # 追加文本到文件

Fügen Sie hier eine Bildbeschreibung ein

  1. < : Das Kleiner-als-Symbol wird verwendet, um den Inhalt einer Datei als Eingabe für einen Befehl umzuleiten.
    Beispiel:
command < input.txt   # 使用文件内容作为输入执行命令
  1. ` : Backticks werden verwendet, um den Befehl auszuführen und als String auszugeben.
    Beispiel:
currentDate=`date`   # 获取当前日期并存储为字符串

3.3 Benutzerdefinierte Variablen

Variablen werden von Shell-Skriptautoren definiert und zum Speichern von Zwischenergebnissen bestimmter Aufgaben oder Berechnungen verwendet. Der Gültigkeitsbereich ist der aktuelle Shell-Prozess oder das aktuelle Shell-Skript.

1. Variablen definieren:

In Shell-Skripten können Sie das Gleichheitszeichen (=) verwenden, um Variablen zu definieren. 变量名不应该包含空格，并且通常使用大写字母, um sie von Systemumgebungsvariablen zu unterscheiden.

myVar="Hello, World"

2. Variablen zuweisen:

Um einer Variablen einen Wert zuzuweisen, verwenden Sie einfach das Gleichheitszeichen (=) für die Zuweisungsoperation.

myVar="New Value"

3. Variablen verwenden:

Um den Wert einer Variablen zu verwenden, stellen Sie der Variablen ein Dollarzeichen ($) voran.

echo $myVar

4. String-Verkettung:

Variablen können mit Strings verkettet werden.

greeting="Hello"
name="John"
echo "$greeting, $name!"

Beispiel:

[root@localhost shell]# NAME="cxk"
[root@localhost shell]# DOING="play-basketball"
[root@localhost shell]# echo $NAME $DOING
cxk play-basketball
[root@localhost shell]# echo "$NAME,$DOING！！！"
cxk,play-basketball！！！

5. Variablen exportieren:

Wenn Sie eine Variable in die Umgebung der aktuellen Shell exportieren möchten, damit auch andere untergeordnete Prozesse darauf zugreifen können, können Sie exportden Befehl verwenden.

export myVar="Exported Value"

6. Schreibgeschützte Variablen:

Eine Variable kann schreibgeschützt gemacht werden, um zu verhindern, dass ihr Wert geändert wird.

readonly myVar="This variable is read-only"

Beispiel:

[root@localhost shell]# var='cxk'
[root@localhost shell]# echo $var
cxk
[root@localhost shell]# var='rap'
[root@localhost shell]# echo $var
rap
[root@localhost shell]# readonly var='ikun'
[root@localhost shell]# echo $var
ikun
[root@localhost shell]# var='cxk'
-bash: var: 只读变量

7. Variablen löschen:

Variablen können mit unsetdem Befehl gelöscht werden.

unset myVar

Beispiel:

[root@localhost shell]# setVar='temp'
[root@localhost shell]# echo $setVar
temp
[root@localhost shell]# unset setVar
[root@localhost shell]# echo $setVar

8. Best Practices:

  • Verwenden Sie aussagekräftige Variablennamen, um die Lesbarkeit des Codes zu verbessern.
  • Verwenden Sie doppelte Anführungszeichen, um Variablen in Anführungszeichen zu setzen und Zeichenfolgen zu verarbeiten, die Leerzeichen oder Sonderzeichen enthalten.
  • Vermeiden Sie die Verwendung von Großbuchstaben zum Definieren von Nicht-Umgebungsvariablen, um Konflikte mit Systemumgebungsvariablen zu vermeiden.
  • Überprüfen Sie vor der Verwendung einer Variablen, ob diese definiert ist, um unerwartete Fehler zu vermeiden.
  • Verwenden Sie diese Option readonly, um zu verhindern, dass Variablen, die nicht geändert werden sollten, versehentlich geändert werden.
  • Verwenden Sie diese Option export, um die Variable im untergeordneten Prozess verfügbar zu machen.
  • Fügen Sie Kommentare hinzu, um den Zweck von Variablen zu erläutern und die Wartbarkeit des Codes zu verbessern.

3.4 Umgebungsvariablen

1. Was sind Umgebungsvariablen?

Umgebungsvariablen sind Schlüssel-Wert-Paare, die auf Betriebssystemebene gespeichert werden und zum Speichern von Konfigurationsinformationen, Pfaden, Benutzereinstellungen usw. verwendet werden. Shell-Umgebungsvariablen sind für die Steuerung und Konfiguration des Systemverhaltens sehr wichtig

2. Überprüfen Sie die Umgebungsvariablen:

Verwenden Sie echoden Befehl und das Dollarzeichen ($), um den Wert einer bestimmten Umgebungsvariablen anzuzeigen
. Geben Sie beispielsweise den Home-Verzeichnispfad des aktuellen Benutzers aus:

echo $HOME

Fügen Sie hier eine Bildbeschreibung ein

3. Umgebungsvariablen festlegen:

Um Umgebungsvariablen festzulegen, können Sie exportden folgenden Befehl verwenden:

export MY_VARIABLE="Hello"

MY_VARIABLEDadurch wird eine Umgebungsvariable mit dem Namen erstellt und ihr Wert auf „Hallo“ gesetzt. Beachten Sie, dass diese Variable innerhalb der aktuellen Shell-Sitzung verfügbar ist.

4. Persistente Umgebungsvariablen:

Um eine Umgebungsvariable dauerhaft zu machen, fügen Sie sie normalerweise zur Shell-Konfigurationsdatei hinzu, z. B. .bashrcoder .bash_profile(für die Bash-Shell). Auf diese Weise wird die Variable jedes Mal automatisch gesetzt, wenn eine neue Shell-Sitzung gestartet wird.

5. Alle Umgebungsvariablen anzeigen:

Um alle definierten Umgebungsvariablen anzuzeigen, können Sie envden folgenden Befehl verwenden:

env

Oder verwenden Sie printenvden Befehl:

printenv

6. Umgebungsvariablen löschen:

Um Umgebungsvariablen zu löschen, können Sie unsetden folgenden Befehl verwenden:

unset MY_VARIABLE

7. Umgebungsvariablen verwenden:

Umgebungsvariablen sind in Skripten sehr nützlich und können zum Speichern von Konfigurationsinformationen oder Pfaden verwendet werden, zum Beispiel:

# 使用环境变量
echo "home路径的环境变量地址: $HOME"

8. Vom System vordefinierte Umgebungsvariablen:

Das Betriebssystem und die Shell definieren einige Umgebungsvariablen wie PATH, HOMEusw. vor USER, die für den Zugriff auf Systeminformationen oder die Konfiguration verwendet werden können.

9. Umgebungsvariablen importieren:

Beim Importieren von Umgebungsvariablen werden Umgebungsvariablen aus einer externen Datei oder Quelle in die aktuelle Shell-Sitzung geladen, sodass sie in der aktuellen Sitzung verfügbar sind. Wird normalerweise verwendet, um sicherzustellen, dass erforderliche Umgebungsvariablen definiert sind, bevor Konfigurationsinformationen aus einer Datei geladen, Umgebungsvariablen festgelegt oder andere Skripts ausgeführt werden.

In der Shell gibt es mehrere Möglichkeiten, Umgebungsvariablen zu importieren:

  • sourceBefehl oder .(Punkt) verwenden : Diese beiden Befehle werden verwendet, um die Befehle in der angegebenen Datei auszuführen und die Ergebnisse auf die aktuelle Shell-Sitzung anzuwenden. Wird normalerweise zum Laden von Umgebungsvariablendateien verwendet, z. B. .env.

    source .env
# 或者
. .env

    Wo .envist die Datei, die Umgebungsvariablendefinitionen enthält? Nach der Ausführung dieser Befehle .envwerden die in der Datei definierten Umgebungsvariablen in der aktuellen Shell-Sitzung wirksam.

  • Verwenden exportdes Befehls: Wenn Sie Umgebungsvariablen in die aktuelle Shell-Sitzung importieren und in untergeordneten Prozessen verfügbar machen möchten, können Sie exportden folgenden Befehl verwenden:

    export MY_VARIABLE="Hello"

    Dadurch wird eine Umgebungsvariable mit dem Namen in der aktuellen Shell-Sitzung erstellt MY_VARIABLEund in der aktuellen Sitzung und ihren untergeordneten Prozessen verfügbar gemacht.

  • Pass ~/.bashrcor ~/.bash_profile: Wenn Sie möchten, dass die Umgebungsvariablen jedes Mal automatisch importiert werden, wenn Sie eine neue Bash-Shell-Sitzung starten, können Sie sie zur Datei .bashrcor .bash_profileim Home-Verzeichnis des Benutzers hinzufügen. Auf diese Weise werden die Umgebungsvariablen bei jeder Anmeldung automatisch festgelegt.

    Sie können der Datei beispielsweise .bashrcdie folgende Zeile hinzufügen, um Umgebungsvariablen zu importieren:

    source /path/to/myenvfile

10. Best Practices:

  • Verwenden Sie aussagekräftige Variablennamen, um die Lesbarkeit des Codes zu verbessern.
  • Vermeiden Sie das Überschreiben vordefinierter Systemumgebungsvariablen, um unnötige Probleme zu vermeiden.
  • Wenn vertrauliche Informationen (z. B. Passwörter) erforderlich sind, vermeiden Sie die Speicherung in Umgebungsvariablen, da Umgebungsvariablen im Allgemeinen keine sichere Möglichkeit zum Speichern dieser Informationen darstellen.

3.5 Positionsparametervariablen

  • Diese Variablen werden verwendet, um Befehlszeilenargumente in Shell-Skripten abzurufen.
  • $0Gibt den Namen des Skripts an, $1gibt den ersten Parameter an, $2gibt den zweiten Parameter an und so weiter.
  • Beispiel:
    script.sh arg1 arg2
# 在脚本内部可以使用 $0、$1、$2 获取参数
    Fügen Sie hier eine Bildbeschreibung ein

3.6 Vordefinierte Variablen

  • Die Shell stellt einige spezielle vordefinierte Variablen bereit, um Informationen über die Shell und das System zu erhalten.
  • Es stellt beispielsweise $HOMEdas Home-Verzeichnis des aktuellen Benutzers und $PWDdas aktuelle Arbeitsverzeichnis dar.
  • Beispiel:
    echo "当前用户的主目录是 $HOME"

3.7 Akzeptieren Sie Tastatureingaben

  • Diese Variablen werden verwendet, um Tastatureingaben des Benutzers zu akzeptieren.
  • Beispielsweise readwird ein Befehl verwendet, um Benutzereingaben in einer angegebenen Variablen zu speichern.
  • Beispiel:
    echo "请输入您的姓名："
read userName
echo "您输入的姓名是：$userName"
    Fügen Sie hier eine Bildbeschreibung ein

3. Shell-Betreiber

Im Folgenden finden Sie die Syntax und Beispiele gängiger Operatoren in Shell-Skripten

Betreibertyp Operator Syntaxbeispiel Beispiel
Rechenzeichen Zusatz result=$((a + b)) 5 + 2Das Ergebnis ist7
Subtraktion result=$((a - b)) 5 - 2Das Ergebnis ist3
Multiplikation result=$((a * b)) 5 * 2Das Ergebnis ist10
Aufteilung result=$((a / b)) 10 / 3Das Ergebnis ist3
Rest nehmen result=$((a % b)) 15 % 7Das Ergebnis ist1
Vergleichsoperatoren gleich [ "$a" -eq "$b" ] 5 -eq 5ist wahr
Nicht gleichzusetzen mit [ "$a" -ne "$b" ] 5 -ne 2ist wahr
mehr als die [ "$a" -gt "$b" ] 5 -gt 2ist wahr
weniger als [ "$a" -lt "$b" ] 5 -lt 10ist wahr
größer oder gleich [ "$a" -ge "$b" ] 5 -ge 5ist wahr
Gleich oder kleiner als [ "$a" -le "$b" ] 5 -le 10ist wahr
Logische Operatoren UND-Verknüpfung [ "$a" -gt 0 ] && [ "$a" -lt 10 ] 5 > 0und 5 < 10ist wahr
ODER-Verknüpfung [ "$a" -eq 0 ] || [ "$a" -eq 10 ] 5 = 0oder 5 = 10ist falsch
KEIN Betrieb ! [ "$a" -eq 5 ] 5 = 5ist falsch
Aufgabenverwalter Abtretung x=10 xgleich10
additive Zuordnung x=$((x + 5)) x5Nach der Addition xgleich15
subtraktive Zuordnung y=$((y - 5)) yminus 5gleich y_15
Bitoperatoren Bitweises UND result=$((a & b)) 5 & 3Das Ergebnis ist1
Bitweises ODER result=$((a | b)) 5 | 3Das Ergebnis ist7
Bitweises XOR result=$((a ^ b)) 5 ^ 3Das Ergebnis ist6
Bitweise Negation result=$((~a)) ~5Das Ergebnis ist-6
Linksverschiebung result=$((a << 2)) 5 << 2Das Ergebnis ist20
Verschiebung nach rechts result=$((a >> 1)) 5 >> 1Das Ergebnis ist2

3.1 Arithmetische Operatoren

aHinweis: Wenn Sie in der Shell die Additionsoperation von Variablen und ausführen möchten b, müssen Sie dazu eine bestimmte Syntax verwenden. Die direkte Eingabe $a+$bwird von der Shell nicht als Additionsoperation interpretiert, da sie von der Shell als nicht gefundener Befehl behandelt wird.

Um Additionsoperationen auszuführen, können Sie exprBefehle oder $((...))Ausdrücke verwenden. Hier sind Beispiele für beide Methoden:

  • Methode 1: exprBefehl verwenden

    a=1
b=2
result=$(expr $a + $b)
echo "a + b = $result"

  • Methode 2: $((...))Ausdrücke verwenden

    a=1
b=2
result=$((a + b))
echo "a + b = $result"

Wird zur Durchführung mathematischer Operationen verwendet. Die unterstützten arithmetischen Operatoren sind +, -, *, /, %.

# 语法：result=$((expression))

a=5
b=2

# 加法
result=$((a + b))  # 结果是7

# 减法
result=$((a - b))  # 结果是3

# 乘法
result=$((a * b))  # 结果是10

# 除法
result=$((a / b))  # 结果是2

# 取余
result=$((a % b))  # 结果是1

3.2 Vergleichsoperatoren

Wird verwendet, um die Beziehung zwischen zwei Werten zu vergleichen. Die unterstützten Vergleichsoperatoren sind -eq, -ne, -gt, -lt, -ge, -le.

# 语法：[ expression ]
# 注意：方括号内的空格是必需的！

a=5
b=10

# 相等
if [ "$a" -eq "$b" ]; then
    echo "$a 等于 $b"
else
    echo "$a 不等于 $b"
fi

# 不等于
if [ "$a" -ne "$b" ]; then
    echo "$a 不等于 $b"
else
    echo "$a 等于 $b"
fi

# 大于
if [ "$a" -gt "$b" ]; then
    echo "$a 大于 $b"
else
    echo "$a 不大于 $b"
fi

# 小于
if [ "$a" -lt "$b" ]; then
    echo "$a 小于 $b"
else
    echo "$a 不小于 $b"
fi

# 大于等于
if [ "$a" -ge "$b" ]; then
    echo "$a 大于等于 $b"
else
    echo "$a 小于 $b"
fi

# 小于等于
if [ "$a" -le "$b" ]; then
    echo "$a 小于等于 $b"
else
    echo "$a 大于 $b"
fi

3.3 Logische Operatoren

Wird zur Durchführung logischer Operationen verwendet. Die unterstützten logischen Operatoren sind &&(logisches UND), ||(logisches ODER), !(logisches NICHT).

# 语法：command1 && command2
# command2 仅在 command1 返回真（退出状态码为0）时执行

# 与运算
if [ "$a" -gt 0 ] && [ "$a" -lt 10 ]; then
    echo "$a 大于0并且小于10"
else
    echo "$a 不满足条件"
fi

# 或运算
if [ "$a" -eq 0 ] || [ "$a" -eq 10 ]; then
    echo "$a 等于0或等于10"
else
    echo "$a 不满足条件"
fi

# 非运算
if ! [ "$a" -eq 5 ]; then
    echo "$a 不等于5"
else
    echo "$a 等于5"
fi

3.4 Zuweisungsoperator

Wird verwendet, um Variablen Werte zuzuweisen. Die unterstützten Zuweisungsoperatoren sind =``+=, -=, *=, /=, %=.

# 语法：variable operator expression

x=10
y=20

# 赋值
x=5
y=10

# 加法并赋值
x=$((x + 5))  # x 现在等于10

# 减法并赋值
y=$((y - 5))  # y 现在等于15

3,5-Bit-Operatoren

Wird zur Durchführung von Bitoperationen verwendet. Die unterstützten Bitoperatoren sind &(bitweises UND), |(bitweises ODER), ^(bitweises exklusives ODER), (bitweise ~Negation), <<(Linksverschiebung), >>(Rechtsverschiebung).

# 语法：result=$((expression))

a=5
b=3

# 按位与
result=$((a & b))  # 结果是1

# 按位或
result=$((a | b))  # 结果是7

# 按位异或
result=$((a ^ b))  # 结果是6

# 按位取反
result=$((~a))     # 结果是-6

# 左移
result=$((a << 2))  # 结果是20

# 右移
result=$((a >> 1))  # 结果是2

4. Prozesskontrolle

Zu den Prozesskontrollstrukturen in Shell-Skripten gehören bedingte Anweisungen (if-Anweisungen), Schleifenanweisungen (for-Schleife, while-Schleife), case-Anweisungen usw. Im Folgenden finden Sie detaillierte Syntax- und Verwendungsbeispiele für jede Flusskontrollstruktur:

4.1 Bedingte Anweisung – if-Anweisung

  • ifAnweisungen werden verwendet, um verschiedene Befehle unter bestimmten Bedingungen auszuführen. Die Syntax lautet wie folgt:

    if [ condition ]; then
    # 条件为真时执行的命令
else
    # 条件为假时执行的命令
fi

  • Beispiel:

    #!/bin/bash

x=10

if [ $x -eq 10 ]; then
    echo "x 等于 10"
else
    echo "x 不等于 10"
fi

4.2 Schleifenanweisung – for-Schleife

  • forSchleifen werden verwendet, um eine Reihe von Befehlen über die Elemente in einer Liste auszuführen. Die Syntax lautet wie folgt:

    for variable in list; do
    # 在每次迭代中执行的命令
done

  • Beispiel:

    #!/bin/bash

fruits=("apple" "banana" "cherry")

for fruit in "${fruits[@]}"; do
    echo "水果：$fruit"
done

4.3 Schleifenanweisung – while-Schleife

  • whileEine Schleife wird verwendet, um eine Folge von Befehlen auszuführen, wenn eine Bedingung wahr ist, bis die Bedingung falsch ist. Die Syntax lautet wie folgt:

    while [ condition ]; do
    # 当条件为真时执行的命令
done

  • Beispiel:

    #!/bin/bash

count=1

while [ $count -le 5 ]; do
    echo "循环次数：$count"
    ((count++))
done

4.4 Fallerklärung

  • caseAnweisungen werden verwendet, um verschiedene Befehle basierend auf unterschiedlichen Bedingungen auszuführen. Die Syntax lautet wie folgt:

    case expression in
    pattern1)
        # 匹配 pattern1 时执行的命令
        ;;
    pattern2)
        # 匹配 pattern2 时执行的命令
        ;;
    *)
        # 默认情况下执行的命令
        ;;
esac

  • Beispiel:

    #!/bin/bash

fruit="apple"

case $fruit in
    "apple")
        echo "这是苹果"
        ;;
    "banana")
        echo "这是香蕉"
        ;;
    *)
        echo "这不是苹果或香蕉"
        ;;
esac

4.5 Kontrollfluss – unterbrechen und fortfahren

  • breakWird verwendet, um die Schleife zu verlassen.

  • continueWird verwendet, um den Rest der aktuellen Schleife zu überspringen und mit der nächsten Iteration fortzufahren.

  • Beispiel:

    #!/bin/bash

for i in {
      
      1..5}; do
    if [ $i -eq 3 ]; then
        continue
    fi
    echo "循环次数：$i"
    if [ $i -eq 4 ]; then
        break
    fi
done

5. Funktion

Shell-Funktionen sind leistungsstarke Werkzeuge, die es ermöglichen, eine Reihe von Befehlen und Logik in einer wiederverwendbaren Einheit zu kapseln, um eine bestimmte Aufgabe oder Berechnung auszuführen. In diesem Artikel befassen wir uns ausführlich mit der Syntax von Shell-Funktionen und stellen mehrere praktische Beispiele bereit, um sie besser zu verstehen und zu verwenden.

5.1 Shell-Funktionsdefinition

Shell-Funktionen können zwei verschiedene Syntaxformen verwenden: die Verwendung von functionSchlüsselwörtern und die Verwendung einer kompakten Form.

5.1.1 Funktionsdefinition des Schlüsselworts

function function_name {
    
    
    # 函数体，包括命令和逻辑
    # 可以接受参数
    # 可以使用局部变量
    # 可以返回一个值
}

5.1.2 Kompaktform-Funktionsdefinition

function_name() {
    
    
    # 函数体
}

5.2 Funktionsaufruf

Sobald eine Funktion definiert ist, kann sie überall im Skript aufgerufen werden. Wenn Sie eine Funktion aufrufen, verwenden Sie einfach ihren Namen gefolgt von den erforderlichen Argumenten

Grammatik:

function_name argument1 argument2

Beispiel für einen einfachen Funktionsaufruf

# 定义一个函数，用于打印欢迎消息
welcome() {
    
    
    echo "欢迎来到Shell函数示例！"
}

# 调用函数
welcome

5.3 Funktionsparameter

Funktionen können Parameter akzeptieren, was sie vielseitiger und flexibler macht. $1Innerhalb der Funktion können Sie Variablen wie , usw. verwenden, $2um auf die an die Funktion übergebenen Parameter zu verweisen. $3Diese Variablen stellen den ersten Parameter, den zweiten Parameter, den dritten Parameter usw. dar.

Schauen wir uns ein Beispiel einer Funktion an, die Parameter akzeptiert:

# 定义一个函数，接受两个参数并打印它们
print_arguments() {
    
    
    echo "第一个参数: $1"
    echo "第二个参数: $2"
}

# 调用函数，并传递两个参数
print_arguments "Hello" "World"

print(){
echo "你的名字：$1"
echo "你的爱好：$2"
}
print "蔡徐坤" "打篮球"

Fügen Sie hier eine Bildbeschreibung ein

5.4 Rückgabewert der Funktion

Shell-Funktionen können einen Wert zurückgeben, der es der Funktion ermöglicht, Berechnungen durchzuführen und die Ergebnisse an das Hauptprogramm zurückzugeben. Um einen Wert zurückzugeben, können Sie eine Anweisung verwenden returnund diese dann im Hauptprogramm verwenden, $?um den Rückgabewert abzurufen.

Beispiel einer Funktion, die die Summe zweier Zahlen berechnet und das Ergebnis zurückgibt:

# 定义一个函数，计算两个数字之和并返回结果
add_numbers() {
    
    
    local sum=$(( $1 + $2 ))
    return $sum
}

# 调用函数，并获取返回值
add_numbers 5 7
result=$?
echo "5 + 7 的和是：$result"

5.5 Lokale Variablen

In Shell-Funktionen können Sie localSchlüsselwörter verwenden, um lokale Variablen zu erstellen. Lokale Variablen sind nur innerhalb der Funktion sichtbar und haben keinen Einfluss auf Variablen im globalen Bereich. Dies ist sehr nützlich, da es die Verwendung von Variablen innerhalb einer Funktion ermöglicht, ohne sich Gedanken über Konflikte mit anderen Teilen des Codes machen zu müssen.

Funktionsbeispiel lokaler Variablen:

# 定义一个函数，演示局部变量
my_function() {
    
    
    local local_variable="局部变量"
    echo "在函数内部：$local_variable"
}

local_variable="全局变量"
my_function
echo "在函数外部：$local_variable"

fun(){
    
    

echo "全局变量值:$var"
local var="局部变量"
echo "局部变量赋值后:$var"
}
var="全局变量"
fun

Fügen Sie hier eine Bildbeschreibung ein

5.6 Praxisbeispiele

5.6.1 Fakultät berechnen

Berechnet die Fakultät einer bestimmten Zahl. Die Fakultät ist das Produkt einer positiven ganzen Zahl und des Produkts aller positiven ganzen Zahlen von 1 bis zu dieser ganzen Zahl.

# 定义一个函数，计算给定数字的阶乘
calculate_factorial() {
    
    
    local number=$1
    local result=1

    if [ $number -lt 0 ]; then
        echo "输入必须是非负整数。"
        return 1
    fi

    for (( i=1; i<=number; i++ )); do
        result=$((result * i))
    done

    echo "$number 的阶乘是：$result"
    return 0
}

# 调用函数，计算阶乘
calculate_factorial 5
calculate_factorial 0
calculate_factorial -3

5.6.2 Dateien suchen

Sucht eine bestimmte Datei im Dateisystem und gibt den Pfad zu der Datei zurück

# 定义一个函数，查找文件并返回路径
find_file() {
    
    
    # 接受两个参数：文件名和搜索目录
    local file_name=$1
    local search_dir=$2

    # 检查是否提供了有效的文件名和搜索目录
    if [ -z "$file_name" ] || [ -z "$search_dir" ]; then
        echo "请输入文件名和搜索目录。"
        return 1  # 返回错误代码1表示参数不足或无效
    fi

    # 使用`find`命令在指定目录中查找文件
    local result=$(find "$search_dir" -name "$file_name")

    # 检查是否找到文件
    if [ -z "$result" ]; then
        echo "未找到文件 '$file_name'。"
        return 1  # 返回错误代码1表示未找到文件
    else
        echo "文件 '$file_name' 的路径是：$result"
        return 0  # 返回成功代码0表示找到文件
    fi
}

# 调用函数，查找文件
find_file "example.txt" "/path/to/search"   # 查找存在的文件
find_file "missing.txt" "/path/to/search"   # 查找不存在的文件
find_file "" "/path/to/search"              # 无效的参数：文件名为空

6. Befehle zum Abfangen, Ersetzen und Verarbeiten von Zeichen

6.1 Allgemeine Zeichenverarbeitung

6.1.1 Stringlänge

Grammatik:

${
    
    #string}

Beispiel:

string="Hello, World!"
length=${
    
    #string}
echo "字符串的长度为：$length"  # 输出 "字符串的长度为：13"

6.1.2 Teilzeichenfolgen abfangen

Grammatik:

${string:起始位置:长度}

Beispiel:

string="Hello, World!"
substring="${string:0:5}"  # 从位置0开始截取5个字符
echo "$substring"  # 输出 "Hello"

6.1.3 Präfix löschen

Grammatik:

${string#前缀}

Beispiel:

string="/path/to/file.txt"
without_prefix="${string#/path/}"  # 删除前缀 "/path/"
echo "$without_prefix"  # 输出 "to/file.txt"

6.1.4 Suffix löschen

Grammatik:

${string%后缀}

Beispiel:

string="/path/to/file.txt"
without_suffix="${string%.txt}"  # 删除后缀 ".txt"
echo "$without_suffix"  # 输出 "/path/to/file"

6.1.5 In Kleinbuchstaben umwandeln

Grammatik:

${string,,}

Beispiel:

string="Hello, World!"
lowercase="${string,,}"  # 转换为小写
echo "小写: $lowercase"  # 输出 "小写: hello, world!"

6.1.6 In Großbuchstaben umwandeln

Grammatik:

${string^^}

Beispiel:

string="Hello, World!"
uppercase="${string^^}"  # 转换为大写
echo "大写: $uppercase"  # 输出 "大写: HELLO, WORLD!"

6.1.7 String-Ersetzung (erste Übereinstimmung)

Grammatik:

${string/要替换的子串/替换为的字符串}

Beispiel:

string="姓名：name,age:20,height:159cm,艺名：name"
replaced="${string/name/cxk}"  # 替换第一个 "name" 为 "cxk"
echo "$replaced"  # 输出 "姓名：cxk,age:20,height:159cm,艺名：name"

Fügen Sie hier eine Bildbeschreibung ein

6.1.8 String-Ersetzung (alles abgleichen)

Grammatik:

${string//要替换的子串/替换为的字符串}

Beispiel:

string="姓名：name,age:20,height:159cm,艺名：name"
replaced="${string//name/cxk}"  # 替换所有的 "apples" 为 "bananas"
echo "$replaced"  # 输出 "I love bananas, bananas are great!"

Fügen Sie hier eine Bildbeschreibung ein

6.1.9 Teilstring-Übereinstimmung extrahieren

Grammatik:

[[ $string =~ 正则表达式 ]]
匹配结果：${
    
    BASH_REMATCH[n]}

Beispiel:

string="我的邮箱 [email protected]"
# 使用正则表达式来匹配字符串中的邮箱地址，并将匹配结果存储在`BASH_REMATCH`数组中，然后提取出匹配的邮箱地
if [[ $string =~ [a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{
    
    2,4} ]]; then
    email="${
     
     BASH_REMATCH[0]}"
    echo "匹配到的邮箱地址是：$email"
fi

Fügen Sie hier eine Bildbeschreibung ein

6.2 Reguläre Ausdrücke und Platzhalter

6.2.1 Der Unterschied zwischen regulären Ausdrücken und Platzhaltern

  1. Reguläre Ausdrücke :

    • Reguläre Ausdrücke sind ein leistungsstarkes 模式匹配Werkzeug zum Abgleichen von Zeichenfolgen in Texten anhand von Mustern. Es handelt sich um eine Include-Übereinstimmung, sodass eine Übereinstimmung mit einer beliebigen Stelle in der Zeichenfolge möglich ist.
    • Unter Linux unterstützen Befehle wie grep, awkusw. sednormalerweise reguläre Ausdrücke. Sie können reguläre Ausdrücke zum Suchen, Ersetzen, Filtern von Text usw. verwenden.
    • Die umfangreiche Syntax regulärer Ausdrücke ermöglicht Ihnen die Durchführung erweiterter Textoperationen wie Erfassen, Gruppieren, Wiederholungsabgleich usw.

    Beispiel:

    • Verwenden Sie diese Option grep, um alle Zeilen zu finden, die Zahlen enthalten:grep '[0-9]' file.txt

  2. Platzhalter :

    • Platzhalter werden verwendet, um Dateinamen abzugleichen. Es handelt sich um eine exakte Übereinstimmung, die unabhängig vom Dateiinhalt nur Dateinamen findet, die einem bestimmten Muster entsprechen.
    • Unter Linux unterstützen Befehle wie ls, findusw. cpnormalerweise Platzhalter. Platzhalterzeichen werden zum Suchen oder Bearbeiten von Dateien verwendet, nicht für den Text in den Dateien.
    • Zu den Platzhalterzeichen gehören *(übereinstimmend mit null oder mehr Zeichen), ?(übereinstimmend mit einem Zeichen), [...](übereinstimmend mit einer Reihe von Zeichen) usw.

    Beispiel:

    • Verwenden Sie diese Option, um lsalle .txtDateien aufzulisten, die mit Folgendem enden:ls *.txt

Zusammenfassen:

  • Reguläre Ausdrücke werden für die Textverarbeitung verwendet und unterstützen erweiterte Zuordnungen und Operationen.
  • Platzhalter werden für den Dateinamenabgleich verwendet und sind ein grundlegendes Werkzeug zur Dateiauswahl.

6.2.2 Häufig verwendete reguläre Ausdrücke

Muster für reguläre Ausdrücke beschreiben Anwendungsbeispiel
^pattern Entspricht patternZeilen, die mit beginnen. grep '^Error' file.txtOrdnen Sie Zeilen zu, die mit „Error“ beginnen.
pattern$ Entspricht patternZeilen, die mit enden. grep 'end$' file.txtEntspricht Zeilen, die mit „end“ enden.
. Entspricht jedem einzelnen Zeichen außer Newline. grep 'a.b' file.txtEntspricht „aab“, „axb“ usw.
* Entspricht null oder mehr Instanzen des vorherigen Zeichens oder Unterausdrucks. grep 'go*gle' file.txtEntspricht „ggle“, „google“, „gooogle“ usw.
+ Entspricht einer oder mehreren Instanzen des vorherigen Zeichens oder Unterausdrucks. grep 'go+gle' file.txtEntspricht „google“, „gooogle“ usw., aber nicht „ggle“.
? Entspricht null oder einer Instanz des vorherigen Zeichens oder Unterausdrucks. grep 'colou?r' file.txtEntspricht „Farbe“ und „Farbe“.
[abc] Entspricht jedem Zeichen im Zeichensatz. grep '[aeiou]' file.txtEntspricht Zeilen, die Vokale enthalten.
[0-9] Entspricht einer beliebigen Zahl. grep '[0-9]' file.txtEntspricht Zeilen, die Zahlen enthalten.
[^abc] Entspricht jedem Zeichen, das nicht im Zeichensatz enthalten ist. grep '[^0-9]' file.txtEntspricht Zeilen, die keine Zahlen enthalten.
\d Entspricht jedem numerischen Zeichen, äquivalent zu [0-9]. grep '\d' file.txtEntspricht Zeilen, die Zahlen enthalten.
\D Entspricht jedem nicht numerischen Zeichen, äquivalent zu [^0-9]. grep '\D' file.txtEntspricht Zeilen, die keine Zahlen enthalten.
\w Entspricht jedem einzelnen Wortzeichen (Buchstabe, Zahl oder Unterstrich), äquivalent zu [a-zA-Z0-9_]. grep '\w' file.txtEntspricht Zeilen, die Wortzeichen enthalten.
\W Entspricht jedem Nicht-Wort-Zeichen, äquivalent zu [^a-zA-Z0-9_]. grep '\W' file.txtEntspricht Zeilen, die keine Wortzeichen enthalten.
\s Entspricht jedem Leerzeichen (Leerzeichen, Tabulator, Zeilenumbruch usw.). grep '\s' file.txtEntspricht Zeilen, die Leerzeichen enthalten.
\S Entspricht jedem Zeichen, das kein Leerzeichen ist. grep '\S' file.txtEntspricht Zeilen, die keine Leerzeichen enthalten.
(pattern) Erstellen Sie eine Erfassungsgruppe, die passenden Text erfasst. grep 'a\(bc\)*d' file.txtEntspricht „ad“, „abcd“, „abcbcd“ usw.
` ` Logischer ODER-Operator, entspricht einem von zwei Mustern.
.* Entspricht null oder mehr beliebigen Zeichen, normalerweise einer ganzen Textzeile. grep '.*pattern.*' file.txtEntspricht Zeilen, die „Muster“ enthalten.

6.3 Befehle zum Abfangen, Ersetzen und Verarbeiten von Zeichen

6.3.1 Schnittbefehl

cut命令用于从文本行中剪切或提取字段。默认情况下，cut使用制表符（Tab）作为字段分隔符，但可以通过-d选项指定其他分隔符。它通常用于提取或删除文本文件中的特定列。

基本用法：

cut [OPTIONS] [FILE]

  • 剪切文件中的第2列：

    cut -f2 input.txt

    Fügen Sie hier eine Bildbeschreibung ein

  • 使用逗号作为分隔符剪切第1和第3列：

    cut -d',' -f1,3 input.csv

    Fügen Sie hier eine Bildbeschreibung ein

  • 以特定字符作为字段分隔符，剪切第1列：

    cut -d',' -f1 /etc/passwd

    Fügen Sie hier eine Bildbeschreibung ein

  • 剪切每行的前5个字符：

    cut -c1-5 input.txt

    Fügen Sie hier eine Bildbeschreibung ein

6.3.2 awk命令

awk是一个强大的文本处理工具，它可以执行复杂的文本处理操作，包括文本提取、计算、条件筛选等。awk将文本分割成字段，并允许对字段进行操作。它的灵活性使其成为处理结构化文本数据的理想工具。

基本用法：

awk 'pattern { action }' [FILE]

  • 显示文件的第2列和第3列：

    awk '{print $2, $3}' input.txt

    Fügen Sie hier eine Bildbeschreibung ein

  • 计算文件中所有数字的总和：

    awk '{ sum += $1 } END { print sum }' input.txt

    Fügen Sie hier eine Bildbeschreibung ein

  • 使用逗号作为分隔符，打印第1列和第3列：

    awk -F',' '{print $1, $3}' input.csv

    Fügen Sie hier eine Bildbeschreibung ein

  • 打印包含特定模式的行：

        awk '/pattern/ {print}' input.txt

    Fügen Sie hier eine Bildbeschreibung ein

6.3.3 sed命令

sed（流编辑器）用于对文本进行基本的编辑和转换，如替换、删除、插入和替换。sed可以通过正则表达式来匹配和操作文本，通常在管道中与其他命令一起使用。

基本用法：

sed [OPTIONS] 's/pattern/replacement/' [FILE]

  • 替换文本文件中的所有"old"为"new"：

    sed 's/old/new/g' input.txt

    Fügen Sie hier eine Bildbeschreibung ein

  • 删除包含特定字符串的行：

    sed '/pattern/d' input.txt

    Fügen Sie hier eine Bildbeschreibung ein

  • 在每行的开头插入文本：

    sed 's/^/Prefix /' input.txt

    Fügen Sie hier eine Bildbeschreibung ein

  • 将文件中的所有字母转换为大写：

    sed 's/[a-z]/\U&/g' input.txt

    Fügen Sie hier eine Bildbeschreibung ein

6.4 sort、uniq、wc 命令

sort、uniq和wc是在Linux和Unix系统上常用的命令，用于排序、去重和统计文本数据。

6.4.1 sort命令

sort命令用于对文本文件的行进行排序。默认情况下，它按照字典顺序对文本行进行排序，但可以使用不同的选项来进行数字排序、逆序排序等。

基本用法：

sort [OPTIONS] [FILE]

  • 对文件进行排序并将结果输出到标准输出：

    sort input.txt

    Fügen Sie hier eine Bildbeschreibung ein

  • 对文件进行数字排序（例如，按数值大小而不是字典顺序）：

    sort -n input.txt

    Fügen Sie hier eine Bildbeschreibung ein

  • 对文件进行逆序排序：

    sort -r input.txt

    Fügen Sie hier eine Bildbeschreibung ein

6.4.2 uniq命令

uniq命令用于从已排序的文本数据中去重重复的行。它通常与sort命令结合使用，以确保重复行相邻。

基本用法：

uniq [OPTIONS] [FILE]

  • 从文件中去重重复的行：

    sort input.txt | uniq

    Fügen Sie hier eine Bildbeschreibung ein

  • 显示去重后的行以及它们重复的次数：

    sort input.txt | uniq -c

    Fügen Sie hier eine Bildbeschreibung ein

6.4.3 wc命令

wc命令用于统计文本文件的行数、字数和字符数。

基本用法：

wc [OPTIONS] [FILE]

  • 统计文件的行数、单词数和字符数：

    wc input.txt

    Fügen Sie hier eine Bildbeschreibung ein

  • 仅统计行数：

    wc -l input.txt

    Fügen Sie hier eine Bildbeschreibung ein

  • 仅统计单词数：

    wc -w input.txt

    Fügen Sie hier eine Bildbeschreibung ein

  • 仅统计字符数：

    wc -c input.txt

    Fügen Sie hier eine Bildbeschreibung ein

6.5 管道（Pipeline）

管道（Pipeline）是在Unix和类Unix操作系统中广泛使用的强大工具，它允许将一个命令的输出直接传递给另一个命令，以便进行复杂的数据处理和筛选。

管道（Pipeline）语法：

command1 | command2
  • command1：第一个命令的输出将被传递给第二个命令。
  • command2：接收来自command1的输入并进行处理的第二个命令。

6.6 grep命令

grep命令用于在文本中搜索匹配指定模式的行

grep命令语法：

grep [选项] 模式 [文件...]
  • 选项：可以是一些可选的标志，用于控制搜索的行为。
  • 模式：要搜索的文本模式或正则表达式。
  • 文件：要在其中搜索模式的一个或多个文件。如果省略文件参数，则grep将从标准输入中读取数据。
  1. 搜索文件中包含特定字符串的行：
grep "search_term" filename.txt
  1. 搜索多个文件中包含特定字符串的行：
grep "search_term" file1.txt file2.txt
  1. 搜索目录中所有文件包含特定字符串的行：
grep "search_term" /path/to/directory/*
  1. 搜索多个文件并显示匹配行的行号：
grep -n "search_term" file1.txt file2.txt
  1. 忽略大小写进行搜索：
grep -i "search_term" filename.txt
  1. 使用正则表达式进行高级搜索（例如，查找以"abc"开头的行）：
grep "^abc" filename.txt
  1. 逆向搜索，即只显示不匹配模式的行：
grep -v "search_term" filename.txt
  1. 递归搜索目录中的文件：
grep -r "search_term" /path/to/directory/
  1. 搜索匹配模式的行并统计匹配的次数：
grep -c "search_term" filename.txt

7. 输入输出重定向

7.1 Linux标准输入

类型 设备 设备名 文件描述符 类型
标准输入（stdin） 键盘 /dev/stdin 0 标准输入
标准输出（stdout） 显示器 /dev/stdout 1 标准输出
标准错误输出（stderr） 显示器 /dev/stderr 2 标准错误输出

7.2 输入重定向

类型 符号（语法） 功能
标准输入 命令 < 文件1 命令将文件1的内容作为标准输入设备
标识符限定输入 命令 << 标识符 命令将标准输入中读入内容，直到遇到“标识符”分隔符为止
输入输出重定向 命令 < 文件1 > 文件2 命令将文件1的内容作为标准输入，将文件2作为标准输出。

7.3 输出重定向

类型 符号 作用
Standardausgabeumleitung (Override) Befehl > Datei Geben Sie im Überschreibmodus den korrekten Ausgabeinhalt des Befehls in die angegebene Datei oder das angegebene Gerät aus
Standardausgabeumleitung (anhängen) Befehl>>Datei Geben Sie im Anhängemodus den korrekten Ausgabeinhalt des Befehls in die angegebene Datei oder das angegebene Gerät aus
Standardfehlerausgabeumleitung (Override) Fehlerbefehl 2 > Datei Gibt die Fehlerausgabe des Befehls im Überschreibmodus an die angegebene Datei oder das angegebene Gerät aus
Standardfehlerausgabeumleitung (anhängen) Fehler Befehl 2>> Datei Geben Sie im Anhängemodus die Fehlerausgabe des Befehls in die angegebene Datei oder das angegebene Gerät aus
Speichern Sie sowohl stdout als auch stderr (überschreiben) Befehl>Datei2>&1 Speichern Sie im Overlay-Modus sowohl die korrekte als auch die fehlerhafte Ausgabe in derselben Datei
Sowohl die Standardausgabe als auch die Standardfehlerausgabe speichern (anhängen) Befehl>>Datei2>&1 Speichern Sie im Anhängemodus sowohl die korrekte Ausgabe als auch die Fehlerausgabe in derselben Datei
Speichern Sie sowohl stdout als auch stderr (überschreiben) Befehl&>Datei Speichern Sie im Overlay-Modus sowohl die korrekte als auch die fehlerhafte Ausgabe in derselben Datei
Sowohl die Standardausgabe als auch die Standardfehlerausgabe speichern (anhängen) Befehl &>> Datei Speichern Sie im Anhängemodus sowohl die korrekte Ausgabe als auch die Fehlerausgabe in derselben Datei
Korrekte Ausgabe und Fehlerausgabe getrennt speichern Befehl > Datei 1 2 > Datei 2 Speichern Sie die korrekte Ausgabe in Datei 1 und die Fehlerausgabe in Datei 2

7.4 /dev/null

Wenn Sie einen Befehl ausführen möchten, ohne die Ausgabe auf dem Bildschirm anzuzeigen, können Sie /dev/nulldie Ausgabe vollständig verwerfen, indem Sie sie in eine Datei umleiten.

Beispiel:

command > /dev/null

Dieser Befehl leitet die Standardausgabe des Befehls in /dev/nulleine Datei um und verwirft die Ausgabe vollständig.

Ich denke du magst

Origin blog.csdn.net/qq_29864051/article/details/132650005
Empfohlen
Rangfolge
Täglich
Mehr
2024-05-28(1)
2024-05-27(1)
2024-05-26(0)
2024-05-25(1)
2024-05-24(13)
2024-05-23(34)
2024-05-22(10)
2024-05-21(34)
2024-05-20(5)
2024-05-19(0)

Code World

© 2018 codetd.com