**!!! ACHTUNG - evtl. veraltet - ACHTUNG !!!**
Diese Seite wurde zuletzt am 9. Juli 2014 um 10:27 Uhr geändert.
===== Hilfe =====
http://www.linux-ag.de/linux/LHB/node26.html
oder
linux:~# man bash
===== Bash als "Editor" =====
<- bzw. ->
+ <- (bzw. )
+ -> (bzw. )
+
+
+
+
+
+
+
+ + <->
Ein Editor ist meist bequemer!
===== Editoren =====
linux:~# **aptitude install mc**
linux:~# **mcedit **
kann alternativ auch nach starten von „mc“ mit der Funktionstaste F3 (Anzeigen) bzw. F4 (editieren) aufgerufen werden
linux:~# **aptitude install nano**
linux:~# **nano **
(nano ist heutzutage meist schon installier!?)
linux:~# **aptitude install vim**
linux:~# **vi **
(zumindest der "einfache" vi wird installiert sein, meist jedoch schon der "improved" vi!?)
http://tnerual.eriogerg.free.fr/vimqrc-ge.pdf
für alle gilt: existiert die Datei noch nicht, wird sie neu angelegt
===== Sonderzeichen =====
(Worttrenner)
* ? [[|]] (Jokerzeichen)
{ } (Klammerersetzung)
$ (Variablen- und Kommandoersetzung; alte Art: `...`)
& | ; (Befehlsverkettung)
> < (Ein- / Ausgabeumleitung)
( ) (Subshells)
! (Zugriff auf Historie)
~ (Abkürzung für das Heimatverzeichnis)
# (Kommentarzeichen)
" ' \ (Quoting)
[[Bash_Aufgaben#Sonderzeichen|Aufgaben]]
===== Umleitungen =====
0 (Standardeingabe)
1 (Standardausgabe)
2 (Standardfehlerausgabe)
< (Eingabe aus Datei lesen)
> (Ausgabe in Datei umleiten)
>> (Ausgabe an Datei anhängen)
2>&1 (Ausgabe + Fehler umleiten)
linux:~# **ping -c 1 localhorst > /dev/null 2>&1**
(ein Ping ohne Standard- und Fehlerausgabe)
[[Bash_Aufgaben#Umleitungen|Aufgaben]]
===== Geschweifte Klammern =====
... generieren Dateinamen durch Kombination aller Möglichkeiten
Beispiele:
linux:~# **mkdir ablage_{1,2,3,4,5}**
(erstellt fünf Verzeichnisse "ablage_1", "ablage_2",...)
linux:~# **cp /etc/passwd{,.orig}**
(kopiert "/etc/passwd" nach "/etc/passwd.orig")
linux:~# **cp /etc/passwd{.orig,}**
(kopiert "/etc/passwd.orig" nach "/etc/passwd")
[[Bash_Aufgaben#Geschweifte_Klammern|Aufgaben]]
===== Pipes =====
Linker Befehl gibt Daten auf Standardausgabe aus
Rechter Befehl liest Daten von Standardeingabe
Pipe verknüpft die beiden direkt
Beide Befehle laufen gleichzeitig Hand-in-Hand
Datenübergabe analog zu einer "Eimerkette"
Es werden keine temporären Dateien benötigt
Der Fehlerkanal wird nicht automatisch gepipet
Beispiel:
linux:~# **echo "12345" | grep --color "3"**
12345
[[Bash_Aufgaben#Prozesse_kombinieren|Aufgaben]]
===== Kommandoersetzung =====
Zuerst werden Joker (* und ?) ersetzt
danach werden Kommandoerzetzungen durchgeführt
schließlich wird die sich so ergebene Befehlszeile ausgeführt
Beispiel:
linux:~# **echo "heute ist $( date +%A )."**
//(alte Schreibweise vernachlässige ich einfach mal!)//
[[Bash_Aufgaben#Prozesse_kombinieren|Aufgaben]]
===== Prozessersetzung =====
von Anfang bis Ende gleicher Stand der „Datei“
Vermeidung von temporären Dateien
Syntax:
befehlA <( befehlB )
befehlA >( befehlB )
Beispiele
linux:~# **cat <( ls -la )**
(virtuelle Datei mit der Ausgabe von "ls -la")
linux:~# **>( grep "tcp" )**
(virtuelle Datei, Eingabe von...)
weitere Möglichkeiten, Prozesse zu kombinieren (teilweise schon behandelt):
befehlA | befehlB
befehlA $( befehlB )
befehlA ; befehlB
befehlA && befehlB
befehlA || befehlB
befehlA & befehlB
befehlA > dateiD
befehlA < dateiD
befehlA >> dateiD
befehlA 2> dateiD
befehlA 2>&1 dateiD
[[Bash_Aufgaben#Prozesse_kombinieren|Aufgaben]]
===== Kommandozeilenverarbeitung =====
Folgendermaßen arbeitet die Bash eine Kommandozeile ab:
- geschweifte Klammern werden ersetzt
- Ersetzung von ~ durch das Heimatverzeichnis
- Ersetzung von $1, $2,... durch die Parameter
- Kommandoersetzung
- Rechenausdrücke
- Zerlegung der Zeile in Worte
- Ersetzung von Jokern
- Funktion / Programm / Alias / Built-In
- Ausführung
===== Rechnen =====
Rechnen mit ganzen Zahlen
$(( RECHENAUSDRUCK )) //(alte Schreibweise vernachlässige ich hier auch einfach mal!)//
Innerhalb von $(( ... )) ist kein $ vor Variablen nötig, aber auch nicht schädlich
um Überraschungen bedingt durch den Zeichensatz zu vermeiden, muss die Umgebungsvariable LANG vorher per "LANG=" geleert werden... wenn das nicht von Erfolg gekrönt ist, muss selbiges evtl. noch für "LANGUAGE" und/oder "LC_ALL" gemacht werden
Beispiel:
linux:~# **LANG=; echo $(( 4 * 512 ))**
2048
mächtigere Alternative: bc
linux:~# **echo "4 * 512" | bc**
2048
===== Shellskript (Beispiel) =====
eine einfache Textdatei
eine ausführbare Datei (oder Aufruf per bash)
links von Kommentaren steht ein #
Befehle Zeile für Zeile (bzw. durch ; getrennt)
**#!/bin/bash** in der ersten Zeile sagt dem System, womit die Datei interpretiert werden soll
andere Dateien (z. B. Funktionsbibliotheken,...) können per "source" oder "." an der entsprechenden Stelle ausgeführt werden
/root/anderesShellSkript.sh
#!/bin/bash
# /root/anderesShellSkript.sh
echo "vor dem ersten Befehl!"
/root/shellskript.sh
#!/bin/bash
# /root/shellskript.sh
# 1. Kommentar
. anderesShellSkript
echo "1. Befehl"
sleep 3 # 2. Befehl (2. Kommentar)
echo "3. Befehl"
Ausführung und Ausgabe:
linux:~# chmod u+x shellskript.sh
linux:~# ls -l shellskript.sh
-rwxr--r-- 1 root root 117 8. Aug 12:00 shellskript.sh
linux:~# **./shellskript.sh** (oder "bash shellskript.sh")
vor dem ersten Befehl!
1. Befehl
3. Befehl
[[Bash_Aufgaben#Shellskript|Aufgaben]]
===== echo (Befehl) =====
-n kein Zeilenumbruch am Zeilenende
-e interpretiert Backslashes
* \n Zeilenumbruch (Linefeed)
* \r Wagenrücklauf (Carriage Return)
* \t Tabulator (nächste 8er-Spalte)
* \a Glocke, Piep
* \123 Asciizeichen (Oktal 123)
Beispiel:
linux:~# **echo -e "MfG\nPatrick"**
MfG
Patrick
[[Bash_Aufgaben#Echo|Aufgaben]]
===== here-doc =====
Nach einem Befehl kommt << und die Endekennung
Die Endekennung kann beliebig gewählt werden
Die Befehlszeile kann weitergehen
Der Befehl bekommt alle folgenden Zeilen als Eingabe
... bis eine Zeile nur aus der Endekennung besteht
Danach geht das Shellskript normal weiter
Beispiel:
linux:~# **cat < > /tmp/here.test
> Das hier
> ist ein
> Hier-Dokument.
> EOF**
linux:~# **cat /tmp/here.test**
Das hier
ist ein
Hier-Dokument.
[[Bash_Aufgaben#Here-doc|Aufgaben]]
===== (Shell)Variablen =====
Enthält der Inhalt der Variablen ein Sonderzeichen (s. o.), so muss der gesamte Inhalt durch "" oder // umschlossen werden oder die einzelnen Sonderzeichen per \ "escaped" werden!
Ausgabe aller Shellvariablen per „set“
"..." <- Variablen werden ersetzt
'...' <- Variablen werden nicht ersetzt
Typendeklaration per „typeset“ (z. B. -a = Array)
$0 Name des Shellskriptes
$$ Prozess-ID der Shell selbst
$# Anzahl der Parameter
$? Exitcode des letzten Befehls
Beispiel:
linux:~# **VARIABLE="Patrick"**
linux:~# **echo $VARIABLE**
Patrick
linux:~# **false**
linux:~# **echo $?**
1
===== Parameter (oder Aufrufargumente) =====
$1, $2, $3,...
**immer Prüfen!!!** (sie kommen vom "bösen" Benutzer)
Minimierung der Verarbeitung bei vollständiger Unterstützung der UNIX-Optionssyntax durch die Verwendung von „getopts“ (Beispiel: siehe „while“)
Nach Abarbeitung eines Parameters kann dieser per „shift“ aus der Liste entfernt werden, alle anderen Parameter rücken auf. (Problem: Parameter mit dazugehörigen „Werten“)
[[Bash_Aufgaben#Parameter|Aufgaben]]
===== getopts (Befehl) =====
Builtin-Kommando der bash
Verarbeitung von mehreren komplexen Parametern
1. Argument
* String
* vorangestellter Doppelpunkt schaltet die Ausgabe von getopts ab
* jeder Buchstabe entspricht einer gültigen Option
* ein auf den Buchstaben folgender Doppelpunkt besagt, dass die Option einen Wert verlangt
2. Argument
* Variable
* enthält die aktuelle Option aus den übergebenen Parametern
auf den Wert je Option kann per $OPTARG zugegriffen werden
Beispiel: siehe "[[Bash#while..._do..._done_.28Konstukt.29|while]]"
===== Umgebungsvariablen =====
Setzen per:
export $VAR (übernimmt die Shellvariable ins Environment)
export VAR="12345" (Wertzuweisung und Übernahme)
Jeder Prozess hat sie (nicht nur Shells)
Werden automatisch an Kindprozesse vererbt
Aber: Shellvariablen werden nicht vererbt
Shell: Environment (= Umgebung) als Shellvariablen "sichtbar"
löschen per "unset"
/root/mybashvar.sh:
#!/bin/bash
# /root/mybashvar.sh
echo $MYBASHVAR
Ausführung:
linux:~# **export MYBASHVAR="Hallo"**
linux:~# **env | grep MYBASHVAR**
MYBASHVAR=Hallo
linux:~# **./mybashvar.sh**
Hallo
linux:~# **unset MYBASHVAR**
linux:~# **./mybashvar.sh**
linux:~#
===== Variablenumformung =====
'#' schneidet vorne kurz ab
'##' schneidet vorne lang ab
% schneidet hinten kurz ab
%% schneidet hinten lang ab
was abgeschnitten soll, kann ein einfacher Text oder ein Muster mit Jokern sein
Unterschied # zu ## bzw. % zu %% nur, wenn das Muster Joker enthält
Beispiel:
linux:~# **TEST="/usr/bin/test.sh"**
linux:~# **echo ${TEST%/*}**
/usr/bin
linux:~# **echo ${TEST##*/}**
test.sh
[[Bash_Aufgaben#Variablenumformung|Aufgaben]]
===== test (Befehl) =====
Syntax:
test AUSDRUCK
oder
[[|AUSDRUCK ]]
Beispiele für Ausdrücke:
test -e datei
[[|-d verzeichnis ]]
[[|-x datei ]]
[[|-n "zeichenkette" ]]
[[|"zeichenkette" = "zeichenkette" ]]
[[|zahl -lt zahl ]]
[[|zahl -ge zahl ]]
[[|! ... ]]
[[|test -a test ]]
[[|test -o test ]]
weitere siehe "man test"!
[[Bash_Aufgaben#Test|Aufgaben]]
===== if, elif, else und fi (Konstrukt) =====
Falls Bedingung erfüllt ist (if)...
* Programm wurde erfolgreich ausgeführt
* test-Befehl
... mache das Eine (then)...
... falls nicht, aber eine andere Bedingung erfüllt ist (elif), mache das, falls nicht...
... mache das Andere (else)
zum Schluss folgt ein fi!
/root/if_else.sh
#!/bin/bash
# /root/if_else.sh
//if ! echo "$1" | egrep "^[[+-]]?[0-9]+$" > /dev/null; then//
//echo "Der erste Parameter ist keine gueltige Zahl!"//
//exit 1;//
//fi//
**if test 0 -gt $1; then**
echo "Der Parameter ist kleiner als Null."
**elif [[|0 -lt $1 ]]; then**
echo "Der Parameter ist groesser als Null."
**else**
echo "Der Parameter ist Null!"
**fi**
Ausführung und Ausgabe:
linux:~# **./if_else.sh -10**
Der Parameter ist kleiner als Null.
linux:~# **./if_else.sh 0**
Der Parameter ist Null!
linux:~# **./if_else.sh 666**
Der Parameter ist groesser als Null.
===== case (Konstrukt) =====
case ... in ... Alternative)... esac
Joker sind erlaubt
Balken erlaubt mehrere Alternativen
Bei Sonderzeichen in "Alternative" das "escapen" nicht vergessen
;; schließt den Fall ab (wenn vorher kein exit zum Abbruch geführt hat
Beispiel: siehe "[[Bash#while..._do..._done_.28Konstukt.29|while]]"
===== for... Wortliste... done (Konstrukt) =====
Einleitung mit "for"
Schleifenvariable kann frei benannt werden
Zugriff innerhalb der Schleife mittels $
Zugriff von außen auf die Schleifenvariable ist nicht ohne weiteres möglich
nach „in“ kommt Wortliste
* wort1 wort2 ... wortX
oder
* $@, read, Kommandoersetzung
"break" bricht eine Schleife sofort ab
"continue" beginnt sofort mit dem nächsten Durchlauf
Beispiel 1 (/root/for.sh):
#!/bin/bash
# /root/for.sh
LANG ======
ZAHLEN="1 2 3 4 5 6 7 8 9 10"
**for ZAHL in $ZAHLEN; do**
echo $(( $ZAHL * $ZAHL ))
**done**
Ausführung und Ausgabe:
linux:~# **./for.sh**
1
4
9
16
25
36
49
64
81
100
Beispiel 2 (/root/for_schleife.sh):
#!/bin/bash
# /root/for_schleife.sh
for pid in $( pidof sshd ); do
if [ "neupat75" = $( ps -Ao user,pid \
| grep $pid \
| awk '{print $1;}' ) ]; then
continue
fi
kill -KILL $pid
done
[[Bash_Aufgaben#For|Aufgaben]]
===== while... do... done (Konstukt) =====
Die while-Schleife läuft, solange die Bedingung wahr ist
Die until-Schleife wird solange ausgeführt, bis die Bedingung wahr ist
/root/while_getopts_case.sh
while getopts ":ab:c" opt; do
case $opt in
a ) echo "verarbeite Option -a" ;;
b ) echo "verarbeite Option -b"
echo "der Parameter der Option ist: $OPTARG"
;;
c ) echo "verarbeite Option -c" ;;
\? ) echo "Verwendung: test.sh [[-a]][-b|barg][[-c]] Datei"
exit 1
esac
done
LANG=; shift $(( $OPTIND – 1 ))
echo "Die angegebene Datei heißt $1"
[[Bash_Aufgaben#While|Aufgaben]]
===== read (Befehl) =====
Interaktives Erfragen von Benutzereingaben
Lesen von Zeilen und Worten aus Textdateien
read schlägt fehl, wenn keine Eingabe erfolgt (Abfrage mit „if“ möglich)
Syntax:
read GANZEZEILE
read VARA VARB VARC VARREST
Beispiel 1:
#!/bin/bash
# /root/read_user.sh
echo -n "Bitte Quellverzeichnis angeben: "
if read SOURCE; then
echo "Quellverzeichnis: $SOURCE."
else echo "Kein Quellverzeichnis!"; exit 1
fi
echo -n "Bitte Zielverzeichnis angeben: "
if read TARGET; then
echo "Zielverzeichnis: $TARGET."
else echo "Kein Zielverzeichnis!"; exit 2
fi
if mv "$SOURCE" "$TARGET"; then
echo "Umbenennen war erfolgreich. :-)"
else echo "Umbenennen ist fehlgeschlagen. :-("; exit 3
fi
Beispiel 2:
#!/bin/bash
# /root/read_system.sh
while read MONAT TAG UHRZEIT MELDUNG; do
echo "-------------------------"
echo "Datum: $TAG. $MONAT"
echo "Uhrzeit: $UHRZEIT"
echo "Meldung:"
echo "$MELDUNG"
done < <( tail -n 5 /var/log/messages )
===== Blöcke (Konstrukt) =====
Mit { und } können Befehlsblöcke erstellt werden
Ein solcher Block wird wie ein Befehl behandelt
Er hat eine gemeinsame Ein-/Ausgabe
Beispiel:
#!/bin/bash
# /root/block.sh
{
N=1000
while [[|$N -lt 10000 ]]
do
echo $N
LANG=; N=$(( $N + 1 ))
done
} | grep 7.*7
Ausführung:
linux:~# ./block.sh | wc -l
495
===== function (Konstukt) =====
ist ein kleines "Unter-Shellskript" im Shellskript
wird wie ein Programm über Namen aufgerufen
hat eigene Parameter $1, $2,...
muss vor dem ersten Aufruf definiert werden
hat auch Standardeingabe/-ausgabe
Beispiel:
#!/bin/bash
# /root/function.sh
function userlist {
USERSHELL=$1
cat /etc/passwd | grep $USERSHELL
}
userlist /bin/bash | sort
Ausführung:
linux:~# **/root/function.sh**
root:x:0:0:root:/root:/bin/bash
user:x:1000:1000:Patrick Neumann,,,:/home/user:/bin/bash
===== Signale =====
signalisiert einfaches Ereignis
sendet Kernel oder Prozess an einen anderen
Signalnr. 1-32: Art des Ereignisses
* 1 = **HUP** = manchmal: Konfiguration neu laden
* 2 = **INT** = schlägt Prozessbeendung vor ( + )
* 15 = **TERM** = schlägt Prozessbeendung vor (kill)
* 9 = **KILL** = beendet Prozess gewaltsam
* 20 = TSTP = friert Prozess ein ( + , abfangbar)
* 19 = STOP = friert Prozess ein (nicht abfangbar)
* 18 = CONT = setzt Prozess nach Signal 19 oder 20 fort
(mehr dazu: "kill -l" bzw. "man 7 signal")
nur root kann Signale an fremde Prozesse senden
Ereignis kann mit folgenden Befehlen gesendet werden:
kill [[|SIGNAL ]] PROZESSID
killall [[|SIGNAL ]] PROZESSNAME
Shell bekommt Signal z. B. von +
Abfangen mittels „trap BEFEHLE SIGNAL“
so können vor einer friedlichen Beendigung ggf. noch Daten auf die Festplatte geschrieben werden
Beispiel:
#!/bin/bash
# /root/trap.sh
function signal {
echo -e "\nSignal $1 abgefangen..."
echo "... beende jetzt Prozess $$."
exit
}
trap "signal INT" INT
while true ; do echo -n "." ; sleep 1 ; done
Shell 1 ausführen, danach Shell 2 ausführen und in der 1. Shell sollte dann etwas passieren.
Shell 1:
linux:~# **/root/trap**
.....
Signal INT abgefangen...
... beende jetzt Prozess 12345.
Shell 2:
linux:~# **kill -INT $( pgrep trap )**
===== reguläre Ausdrücke =====
einfache reguläre Ausdrücke: grep und sed
erweiterte reguläre Ausdrücke: egrep (= grep -E), sed (-r) und awk
Suchmuster sind ähnlich wie Joker
* und ? haben aber eine andere Wirkung als in der Shell!
Tipp: mit der Option --color färbt egrep die Fundstelle ein!
. ein beliebiges Zeichen
* vorangegangenes Zeichen beliebig oft
? vorangegangenes Zeichen 0 oder 1 mal
+ vorangegangenes Zeichen mind. einmal
^ verneint Zeichenklasse oder das nachfolgende
Suchmuster muss am Anfang vorkommen
$ das voranstehende Suchmuster muss am Ende
vorkommen oder leitet ein Skalar ein
| Alternative Ausdrücke
\ maskieren des nachfolgenden (Sonder-)Zeichens
\d Ziffer (genau wie [[0-9]])
\D Nicht-Ziffer
\w Buchstabe, Ziffer oder Unterstrich (bedingt auch Umlaute)
\W Nicht-Buchstabe, Nicht-Ziffer und kein Unterstrich
\r Steuerzeichen für Wagenrücklauf
\n Steuerzeichen für Zeilenvorschub
\t Steuerzeichen für Tabulator
\f Steuerzeichen für Seitenvorschub
\s Leerzeichen oder Steuerzeichen
\< bzw. \> leere Zeichenkette am Wortanfang bzw. -ende
\S Nicht-Leerzeichen oder Nicht-Steuerzeichen
[[abc]] a, b oder c
[[^abc]] ein Zeichen, das nicht a, b, oder c ist
[[0-9]] Ziffer
[[a-zA-Z]] Klein- oder Großbuchstabe
[[^äöüÄÖÜ]] kein deutscher Umlaut
[[:space:]] Leerzeichen, Tabulator,...
[[:alnum:]] Zahl oder Buchstabe
(...) gruppiert einen Ausdruck
(...|...) erlaubt zwei Alternativen (mehrfach möglich)
{8} vorangegangene Gruppe genau 8 mal
{2,4} vorangegang. Gruppe 2, 3 oder 4 mal
{0,3} vorangegang. Gruppe bis zu 3 mal
{5,} vorangegang. Gruppe 5 mal oder öfter
(die Syntax {,5} funktioniert nicht!)
Beispiel mit grep:
linux:~# **echo "123 ist kleiner als 321" | egrep --color "[[0-9]]"**
123 ist kleiner als 321
Beispiel-Muster:
M..t Mist aber nicht Meist
M.*t Mt, Mut, Mist, Meist
Mau?l Mal, Maul aber nicht Mauul
Ja+! Ja!, Jaa! aber nicht J!
[^[[:space:]]]* beliebig viele Nicht-Leerzeichen
[[0-9]]+ mindestens eine Ziffer
(ha)+ ha, haha, hahaha,...
Ba(ch|um) Bach oder Baum
[[0-9]]{4} genau vier Ziffern
([[0-9]]{2}){1,2} zwei oder vier Ziffern
^$ Leerzeile
^[[:space:]]*$ Zeile mit nichts als Leerzeichen
^# Zeile, die mit # anfängt (Kommentar)
===== grep (Befehl) =====
...
===== sed (Befehl) =====
macht Änderungen in Textströmen und arbeitet zeilenbasiert
wichtigste Operation: Suchen und Ersetzen
zusätzlich: Selektion von Zeilen ähnlich wie grep, head und tail
liest aus Dateien oder von Standardeingabe (0)
schreibt immer nach Standardausgabe (1)
arbeitet mit regulären Ausdrücken
Linuxprogramm | sed 'Befehl'
sed 'Befehl' Datei
sed -r 'Befehl' Datei
sed -e 'Befehl' -e 'Befehl' Datei
sed -f DateiMitBefehlen Datei
---> #!/bin/sed -f
sed -n (Ausgabe abschalten)
sed 'Befehl' Datei1 > Datei2
(Umleitung nach Datei1 geht nicht!)
---> mv Datei2 Datei1
d lösche zeilen (delete)
p ausgeben (print)
s/.../.../ ersetzen Treffer einmal (substitute)
s/.../.../g ersetze alle Treffer
s/...//g lösche Treffer
s/.../...&.../ hänge (vorne und hinten) an Treffer an
c \Newline ersetze Zeile (change)
a \Newline hänge Zeile an (append)
i \Newline füge Zeile ein (insert)
r Datei integrieren (read)
Beispiele:
linux:~# sed '1 d' datei
linux:~# sed '100,$ d' datei
linux:~# sed '/info/ d' datei
linux:~# sed 's/ROOT/root/' datei
linux:~# sed 's/patrick/Patrick/g' datei
linux:~# sed 's/ [[A-z0-9.]][A-z0-9.]*evil.com//g' access.log
linux:~# sed '/meyer/ c\
--- Ersatzzeile ---'
linux:~# sed '/neumann/ r datei'
===== awk (Befehl) =====
Arbeitet sich Zeile für Zeile durch eine Textdatei
kennt Variablen, Zahlen, kann rechnen (auch Fließkomma)
gut zum quantitativen Auswerten von Logdateien
gibt standardmäßig den Text nicht aus
das neue nawk sollte dem alten awk vorgezogen werden!
Linuxprogramm | awk '{Befehl}'
awk '{Befehl}' Datei
awk -f DateiMitBefehlen Datei
---> #!/bin/awk -f
-F
{ Befehl; }
BEGIN { Befehl; }
END { Befehl; }
print „Text“
printf „Format“,Variablen
$1, $2,... $NF
+ - * /
n = n + 1
Beispiele:
linux:~# ls -l | awk '{print $2;}'
linux:~# ls -l | awk '{print $( NF-1 );}'
linux:~# awk -F : '{print $1;}' /etc/passwd
linux:~# awk -F : '{printf "%-8s %4d %-10s\n",$1,$2,$3;}' /etc/passwd
linux:~# awk -F : 'BEGIN{print "---"}
{printf "%-8s %4d %-10s\n",$1,$2,$3;} END{print "---"}' /etc/passwd
linux:~# awk 'BEGIN{FS=":"} {print $1;}' /etc/passwd
linux:~# awk '/root/ {print $0}' /etc/passwd
linux:~# awk 'NR > 100 && NR < 200 {print $3}' access.log
linux:~# awk '/info/ {i = i + 1} END{print "anzahl: ",i}' error.log
linux:~# awk '/info/ {i++} END{print "anzahl: ",i}' error.log
linux:~# awk '/info/ {i = i + $3}
END{print "ergebnis: ",i," (wie toll!)"}' datei
Verarbeitung von (mehrdimensionalen )Arrays
Rechnen
Verzweigungen (analog zu if)
Vergleichsoperatoren (Zahlen und Strings)
Logische Operatoren (&&, || und !)
Schleife (for und while inkl. Sprungbefehle)
Eingabe-Funktionen (analog zu read)
Systemaufrufe
Funktionen (analog zu function)