Die zsh lässt sich auf quasi allen Linuxsystemen über die Paketverwaltung installieren. Unter Ubuntu z.B. mit dem Befehl

sudo apt-get install zsh

Danach kann man sie mit dem Aufruf von zsh ausführen. Um sie zur Standardshell zu machen genügt der Befehl

chsh -s /usr/bin/zsh username

Wobei username durch den entsprechenden Usernamen ersetzt werden muss und der Pfad zu zsh stimmen muss. Auf manchen Systemen liegt zsh in /bin. Wo zsh liegt kann man mit dem folgenden Befehl heraus finden:

which zsh

Die zsh bedient sich Elementen der Bash, der Korn-Shell (ksh) und der TENEX-C-Shell (tcsh – eine erweiterte C-Shell). Sie ist sehr gut konfigurierbar und fast jedes Verhalten der Bash kann nachgeahmt werden so dass der Umstieg sehr leicht fällt. Bestehende Bash-Scripte können natürlich weiterhin genutzt werden, wenn der Shebang entsprechend gesetzt ist. Also in der ersten Zeile folgendes steht:

#!/bin/bash

Im Folgenden werde ich einige interessante Vorteile der zsh kurz beschreiben. Zu einzelnen Themen werde wahrscheinlich in anderen Artikel ausführlicher eingehen. Dies sollen also nur Beispiele sein, die die Mächtigkeit demonstrieren sollen. Da die zsh so viele Möglichkeiten bietet ist es nicht möglich hier alles im Detail zu erläutern. Optionen werden mit dem Befehl setopt gesetzt. Dies kann man auch so in die Konfigurationsdatei ~/.zshrc schreiben.

Autokorrektur
Die zsh beherrscht einen Mechanismus, der kleine Tippfehler automatisch korrigiert. Hat man in einem Ordner eine Datei testfile.txt und möchte diese kopieren nach file2.txt, so führt man in der Regel folgenden Befehl aus:

cp testfile.txt file2.txt

wie von der Bash gewohnt nutzt man dafür die Autovervollständigung mittels TAB. Bei einem Verschreiber wird dieser in der zsh automatisch korrigiert. Beispiel:

cp tsetf<TAB>

wird automatisch korrigiert und zu

cp testfile.txt

vervollständigt.

Die Autokorrektur aktiviert man mit der Option correct

Globale Aliase
Neben den normalen Aliasen für Kommandos, wie man sie aus der Bash kennt, gibt es in der zsh noch globale Aliase, die überall im Befehl genutzt werden können, nicht nur am Anfang. Zwei Beispiele verdeutlichen dies:

alias -g G='| grep'
alias -g L='| less'

erzeugt die globalen Aliase G und L die man hinter alle möglichen Befehle schreiben kann um die Ausgabe des entsprechenden Befehls in grep oder less zu pipen. Z.B.

ls G txt

entspricht dem Befehl

ls | grep txt

oder

ps -e L

entspricht

ps -e | less

Natürlich ist auch folgendes Möglich:

ls G txt L

was folgendem Befehl entspricht:

ls | grep txt | less

Suffix Aliase
Mit Suffixaliasen kann man Programme festlegen, mit denen bestimmte Dateitypen (anhand ihrer Endung) geöffnet werden sollen. Man braucht dann nur noch den Namen der Datei eingeben und sie wird mit dem entsprechenden Programm geöffnet. Beispiel:

alias -s pdf=evince

legt einen Alias für pdf Dateien an. Sie sollen mit evince geöffnet werden. Danach reicht die Eingabe von

dokument.pdf

und die Datei dokument.pdf wird mit evince geöffnet.

Aliase für Verzeichnisse: Hashes
Mit sogenannten Hashes lassen sich Aliase für beliebige Verzeichnisse anlegen. Auf diese kann dann sehr einfach zugegriffen werden. Mit dem Befehl

hash -d perl=~/developement/scripting/perl

legt man einen Hash namens perl für das Verzeichnis ~/developement/scripting/perl an. Auf dieses Verzeichnis kann man jetzt mit ~perl zugreifen. Auch innerhalb eines Befehls wie folgendes Beispiel zeigt:

cp testscript.pl ~perl

Dieser Befehl kopiert die Datei testscript.pl in das Verzeichnis ~/developement/scripting/perl.

Auto-CD
Mit der Option autocd kann man zum Wechseln in ein Verzeichnis einfach den Namen eines Verzeichnisses eingeben und das Kommando cd davor einfach weglassen. Wenn es keinen Befehl gibt, der so heißt wie das Verzeichnis, so wird in das Verzeichnis gewechselt.

Kurze for-Schleifen
Statt einem

for i in *.eps; do epstopdf $i; done

um alle eps-Dateien in einem Verzeichnis in pdf-Dateien umzuwandeln genügt unter zsh die kürzere Form

for i (*.eps) epstopdf $i

Globale History
Die History, die man mit der Pfeil-auf Taste durchgehen kann, kann man in der zsh so einstellen, dass sie in jeder zsh-Instanz gleich ist. Das heißt man hat nicht mehr für jedes Fenster seine eigene History sondern kann mit der Pfeil-auf Taste auch Befehle raussuchen, die in anderen Fenstern eingegeben wurden. Die History wird jedoch nur nach jedem Befehl geupdated, das heißt man muss ggf. einmal Return drücken, damit die Befehle aus einem anderen Fenster verfügbar sind.

Dieses Verhalten kann mit der Option share_history aktiviert werden.

Directory Stack
Wie Bash, hat die zsh auch einen Directory stack. Mit dem Befehl pushd kann man das aktuelle Verzeichnis auf den Stack legen und mit popd das jeweils letzte Verzeichnis vom Stack nehmen und dorthin springen. Mit der Option auto_pushd legt die zsh automatisch jedes Verzeichnis auf den Directorystack, aus welchem man in ein anderes Verzeichnis wechselt. So hat man immer eine History der Verzeichnisse in denen man war und kann mit popd sehr einfach wieder in Verzeichnisse welchseln, die man vorher besucht hatte.

Globbing
Die Nutzung von Wildcards – unter zsh globbing genannt – ist bei der Z-Shell wesentlich mächtiger als in der Bash. Zunächst gibt es rekursives Globbing (gibts in der Bash in neueren Versionen wohl auch). So kann man mit dem Befehl

ls **/*.html

alle HTML-Dateien im aktuellen Verzeichnis und allen Unterverzeichnissen auflisten lassen.

Es gibt jedoch auch noch Qualifier um Dateien mit bestimmten Eigenschaften auszuwählen. Diese schreibt man in runde Klammern. So kann man mit . normale Dateien, mit / Verzeichnisse und mit @ Symbolische Links matchen. Praktisch ist das z.B. wenn man allen Verzeichnissen ab einem bestimmten Verzeichnis die Rechte 755 und allen Dateien 644 vergeben möchte. Dies kann man mit den folgenden zwei Befehlen bewerkstelligen statt mit find und exec zu arbeiten.

chmod 755 **/*(/)
chmod 644 **/*(.)

Zusätzlich gibt es auch Qualifier für verschiedenste Dateirechte. Folgender Befehl listet alle Dateien auf, die von allen beschrieben werden können:

ls **/*(.W)

Auch nach der Dateigröße lässt sich suchen:

print **/*(L0)

listet alle leeren Dateien auf.

Auch die Sortierung lässt sich beliebig anpassen. Mit dem Befehl:

print *(oL)

Listet alle Dateien der Größe nach von klein nach groß auf. Mit großem O wird die Sortierung umgekehrt.

Somit lässt sich mittels globbing in der zsh das Kommando find quasi komplett ersetzen. Die hier gezeigten Beispiele sehen auf den ersten Blick recht kompliziert und kryptisch aus. Wenn man das Prinzip aber einmal verstanden hat und die wichtigsten Qualifier kennt ist es aber ganz einfach und sehr praktisch.

Es gibt noch jede Menge weiterer Qualifier und Möglichkeiten für das Globbing (z.B. nur das erste oder eine bestimmte Anzahl von Elementen auszuwählen), die ich hier gar nicht alle erwähnen kann. Im zsh-Manual gibt es jedoch eine Liste der Glob-Qualifier.

Um alle Möglichkeiten nutzen zu können sollte die Option extended_glob gesetzt werden.

Vervollständigung
Die zsh hat wie die Bash einen Vervollständigungsmechanismus, so dass man mit der TAB-Taste Kommandos, Dateinamen und vieles mehr vervollständigen kann. In der zsh ist dieser Mechanismus jedoch extrem gut konfigurierbar und programierbar. So kann man z.B. beim scp Befehl (der Dateien über ssh kopiert) die Verzeichnisse auf dem entfernten Rechner vervollständigen und genau definieren welche Programme mit welchen Dateitypen zusammen arbeiten können. Für sehr viele Programme ist dies schon vorgefertigt, so dass ein

latex doku<TAB>

automatisch zu

 latex dokument.tex

vervollständigt wird. Dies beherrscht die Bash zum Teil auch. Jedoch ist es in der zsh wesentlich besser konfigurierbar und anpassbar.

Sehr praktisch finde ich auch die Menüfunktion. So wird beim ersten Druck auf die TAB-Taste wie in der Bash soweit vervollständigt, bis nicht mehr entschieden werden kann welche Datei (bzw. welcher Befehl) gemeint ist. Ein weiterer Druck auf die TAB-Taste listet alle weiteren Möglichkeiten auf und jeder weitere Druck geht diese Möglichkeiten durch. Wenn ich also drei Dateien habe: test.txt, testfile1.txt und testfile2.txt und gebe folgendes ein:

ls te<TAB>

so wird zuerst auf test vervollständigt. Ein weiterer Druck gibt mir alle Möglichkeiten aus:

testfile1.txt  testfile2.txt  test.txt

und ein dritter Druck auf die Tab-Taste vervollständigt den Befehl zu

ls testfile1.txt

Das ist viel schneller als erst ein f einzugeben um erneut TAB zu drücken und dann die 1 einzugeben um wiederum TAB zu drücken bis der Dateiname endgültig vervollständigt wird.

Ein weiterer Druck auf TAB nimmt dann die nächste Möglichkeit. In diesem Beispiel also

ls testfile2.txt

und so weiter.

Expansion
Mit der TAB-Taste kann man in der zsh nicht nur Kommandos, Dateinamen, … vervollständigen, sondern auch Variablen expandieren. Viele kennen ja die spezielle Variable !!, die den zuletzt ausgeführten Befehl enthält. In der zsh kann man nun folgendes eingeben:

!!<TAB>

und die Variable !! wird automatisch zum zuletzt ausgeführten Befehl expandiert. Genauso kann man auch jede andere Variable expandieren:

$PWD<TAB>

wird zu /home/zimon/developement (vorrausgesetzt ich befinde mich zum Zeitpunkt der expansion in diesem Verzeichnis).

History Kontrolle
Wie bei der Bash auch, kann man in der zsh die History durchsuchen. Die zsh geht jedoch so weit, dass man auch nach bestimmten Parametern suchen kann. Ein Beispiel:

cp ../perl/foo.pl ~/developement/projektordner

Danach kommen ein paar andere Kommandos. Möchte nun eine andere Datei in den gleichen Projektordner kopieren reicht folgende Eingabe:

cp ../perl/bar.pl !?proj?:3

Mit !? wird nach einem vorherigen Befehl gesucht. Das proj ist ein String der in diesem Befehl vorkam. Mit dem ?:3 wird das dritte Argument genutzt. Durch die Expansion kann manmit durch einen Druck auf TAB diesen Ausdruck auch noch expandieren um sicher zu gehen, dass das richtige Argument ausgewählt wurde. Man kann zwar mit Alt+. wie in der Bash die jeweils letzten Argumente durchgehen, auf diese Weise kann man aber auch das zweite von drei Argumenten suchen.

Es gibt noch wesentlich mehr Möglichkeiten die History zu durchsuchen und zu verwenden.

Hochkonfigurierbarer Prompt
In der Z-Shell kann man nicht nur die linke Seite des Prompts sondern auch die rechte Seite konfigurieren. Als Beispiel hier mal mein aktueller Prompt:

Mein aktueller zsh-Prompt

Ich finde die Anzeige der Uhrzeit inklusive Sekunden recht praktisch, da man daran sieht wie lange ein Befehl gedauert hat oder wann man ihn ausgeführt hat. Es gibt jedoch auch die Möglichkeit automatisch die Ausgabe von time bei der Beendigung eines Befehls ausgeben zu lassen, der länger als eine vorher definierte Zeit benötigt hat.

Der Prompt ist eine abgeänderte Version von Phil!s ZSH Prompt.

[UPDATE] Auf Anfrage hin ist hier noch der Code für die von mir abgeänderte Version des Prompts:

setprompt () {
    ###
    # Need this so the prompt will work.
 
    setopt prompt_subst
 
 
    ###
    # See if we can use colors.
 
    autoload colors zsh/terminfo
    if [[ "$terminfo[colors]" -ge 8 ]]; then
	colors
    fi
    for color in RED GREEN YELLOW BLUE MAGENTA CYAN WHITE; do
	eval PR_$color='%{$terminfo[bold]$fg[${(L)color}]%}'
	eval PR_LIGHT_$color='%{$fg[${(L)color}]%}'
	(( count = $count + 1 ))
    done
    PR_NO_COLOUR="%{$terminfo[sgr0]%}"
 
 
    ###
    # See if we can use extended characters to look nicer.
 
    typeset -A altchar
    set -A altchar ${(s..)terminfo[acsc]}
    PR_SET_CHARSET="%{$terminfo[enacs]%}"
    PR_SHIFT_IN="%{$terminfo[smacs]%}"
    PR_SHIFT_OUT="%{$terminfo[rmacs]%}"
    PR_HBAR=${altchar[q]:--}
    PR_ULCORNER=${altchar[l]:--}
    PR_LLCORNER=${altchar[m]:--}
    PR_LRCORNER=${altchar[j]:--}
    PR_URCORNER=${altchar[k]:--}
 
    if [[ "$TERM" == "screen" ]]; then
	PR_HBAR=-
     	PR_ULCORNER=--
    	PR_LLCORNER=--
    	PR_LRCORNER=--
    	PR_URCORNER=-
   fi 
 
 
    ###
    # Decide if we need to set titlebar text.
 
    case $TERM in
	xterm*)
	    PR_TITLEBAR=$'%{\e]0;%(!.-=*[ROOT]*=- | .)%n@%m:%~ | ${COLUMNS}x${LINES} | %y\a%}'
	    ;;
	screen)
	    PR_TITLEBAR=$'%{\e_screen \005 (\005t) | %(!.-=[ROOT]=- | .)%n@%m:%~ | ${COLUMNS}x${LINES} | %y\e\\%}'
	    ;;
	*)
	    PR_TITLEBAR=''
	    ;;
    esac
 
 
    ###
    # Decide whether to set a screen title
    if [[ "$TERM" == "screen" ]]; then
        PR_STITLE=$'%{\ekzsh\e\\%}'
    else
        PR_STITLE=''
    fi
 
 
    ###
    # Finally, the prompt.
 
    PROMPT='$PR_SET_CHARSET$PR_STITLE${(e)PR_TITLEBAR}\
$PR_RED$PR_SHIFT_IN$PR_ULCORNER$PR_BLUE$PR_HBAR$PR_SHIFT_OUT(\
$PR_GREEN%(!.%SROOT%s.%n)$PR_GREEN@%m:%l\
$PR_BLUE)$PR_SHIFT_IN$PR_HBAR$PR_RED$PR_HBAR${(e)PR_FILLBAR}$PR_BLUE$PR_HBAR$PR_SHIFT_OUT(\
$PR_MAGENTA%$PR_PWDLEN<...<%~%<<\
$PR_BLUE)$PR_SHIFT_IN$PR_HBAR$PR_RED$PR_URCORNER$PR_SHIFT_OUT\
 
$PR_RED$PR_SHIFT_IN$PR_LLCORNER$PR_BLUE$PR_HBAR$PR_SHIFT_OUT(\
%(?..$PR_LIGHT_RED%?$PR_BLUE:)\
${(e)PR_APM}$PR_YELLOW%D{%H:%M:%S}\
$PR_BLUE)$PR_SHIFT_IN$PR_HBAR$PR_SHIFT_OUT\
$PR_RED$PR_SHIFT_IN$PR_HBAR$PR_SHIFT_OUT\
$PR_NO_COLOUR '
 
    RPROMPT=' $PR_RED$PR_SHIFT_IN$PR_HBAR$PR_BLUE$PR_HBAR$PR_SHIFT_OUT\
($PR_YELLOW%D{%a,%b%d}$PR_BLUE)$PR_SHIFT_IN$PR_HBAR$PR_RED$PR_LRCORNER$PR_SHIFT_OUT$PR_NO_COLOUR'
 
    PS2='$PR_RED$PR_SHIFT_IN$PR_HBAR$PR_SHIFT_OUT\
$PR_BLUE$PR_SHIFT_IN$PR_HBAR$PR_SHIFT_OUT(\
$PR_LIGHT_GREEN%_$PR_BLUE)$PR_SHIFT_IN$PR_HBAR$PR_SHIFT_OUT\
$PR_RED$PR_SHIFT_IN$PR_HBAR$PR_SHIFT_OUT$PR_NO_COLOUR '
 
}
 
setprompt

[/UPDATE]

ZLE-Widgets
Der Z-Line-Editor (ZLE) ist quasi die Eingabezeile in der zsh. Dafür kann man sich kleine Programme schreiben, die einem das Leben vereinfachen. Ein Beispiel wäre ein Programm, dass bei der Eingabe von ... diese zu ../.. umwandelt. Jeder weitere Punkt wird wieder umgewandelt. So kann man recht einfach folgendes eingeben:

cd ..../directory

Auf dem Bildschirm erscheint jedoch folgendes:

cd ../../../directory

Dieses Widget ist kein Standard bei der Z-Shell. Man kann es aber durch folgenden Code in der Konfigurationsdatei ~/.zshrc erzeugen:

rationalise-dot() {
    if [[ $LBUFFER = *.. ]]; then
        LBUFFER+=/..
    else
        LBUFFER+=.
            fi
}
zle -N rationalise-dot
bindkey . rationalise-dot

Automatisches tee-ing
In der Z-Shell kann man die Ausgabe eines Kommandos recht einfach in mehrere verschiedene Dateien umleiten. Statt wie in der Bash

ls | tee -a all | tee actual

zu schreiben, kann man in der zsh einfach

ls >>all >actual

eingeben. Beide Befehle führen ls aus und hängen die Ausgabe an die Datei all an und schreiben sie in die Datei actual wobei der inhalt jeweils überschrieben wird.
Möchte man die Ausgabe wie beim original tee Befehl auch auf dem Bildschirm sehen, so leitet man sie auch noch auf STDOUT um:

ls >>all >actual >&1

Verzeichnisse durch Ersetzung wechseln
Ein Beispiel sollte dies am besten Erklären. Man nehme an man hat zwei Verzeichnisse: ~/developement/scripting/perl/modules und ~/developement/scripting/python/modules und man befindet sich in ~/developement/scripting/perl/modules, so kann man durch den Befehl

cd perl python

in das Verzeichnis ~/developement/scripting/python/modules wechseln. Bei einem cd Kommando mit zwei Parametern wird im aktuellen Verzeichnis-String das erste Wort durch das zweite ersetzt. Hier also perl durch python.

Fazit
Ich bin jetzt nicht 100% sicher, dass alles hier beschriebene nicht auch in der Bash möglich ist. Es zeigt aber auf jeden Fall, dass die Z-Shell jede Menge interessante Möglichkeiten bietet und man viele Dinge einfacher und schneller erledigen kann als in der Bash. Die oben gezeigten Features sind meist nur angerissen und nur eine kleine Auswahl von dem was die Z-Shell bietet. Darüber hinaus besitzt die Z-Shell eine ganze Reihe Module z.B. für Matheoperationen oder einen eigenen FTP-Client, die man bei Bedarf laden kann.

Sehr schön ist auch die Möglichkeit den Screen-Title von der zsh aus zu setzen.

Es lohnt sich auf jeden Fall, diese Shell etwas genauer zu betrachten. Bei mir hat sie mittlerweile die Bash fast vollständig ersetzt (vorhandene Scripte habe ich nicht umgeschrieben).

Links

• Offizielle zsh Projektseite (englisch)
• zsh Manual (englisch)
• zsh User’s Guide (englisch)
• Michael Prokops zsh Seite – Seite mit Features und Beispielen wo zsh mit Bash verglichen wird
• Michael Prokops zsh Liebhaberseite – Viele gute Beispiele und zsh Tricks angelehnt an das zsh-lovers Projekt.
• zsh wiki – Wiki über zsh (englisch)
• zsh-lovers – Sammlung von Tipps, Tricks und Beispielen (englisch)
• grml zsh Seite – Seite mit sehr großer zsh-Konfigurationsdatei, Referenzkarte und anderen zsh Infos. Die grml-Linuxdistribution hat zsh als Standardshell. (englisch)
• strcat.de/zsh/ – Seite mit Auflistung vieler Features und Tipps (englisch)
• Zzappers Best of ZSH Tips – Viele zsh Tipps (englisch)

Ein solches “Erinnerungsprogramm” kann man sich recht leicht selber basteln. Ich habe dafür das Linuxtool at mit dem Programm zenity, welches Dialoge darstellen kann, kombiniert.

at (bzw. der at-Daemon atd) ist auf den meisten Linuxdistributionen bereits vorhanden, kann sonst aber auch über die Paketverwaltung installiert werden. Zenity sollte bei den meisten Distributionen ebenfalls über die Paketverwaltung installierbar sein.
Unter Ubuntu installiert man zenity mit dem Befehl:

sudo apt-get install zenity

Mit at können Befehle zu einem festgelegten Zeitpunkt ausgeführt werden. Eine sehr schöne Einführung gibt es in der Ausgabe 10/2008 von freiesMagazin (eine Fortsetzung ist in der nachfolgenden Ausgabe enthalten, welche mich auch zu diesem “Programm” inspirierte, weil ich mit den dort vorgestellten Erinnerungs-Lösungen nicht zufrieden war).

Um mit zenity einen Dialog anzuzeigen kann man folgenden Befehl nutzen:

zenity --info --title="Titel des Dialogs" --text "Text, der angezeigt werden soll"

Damit dies von at angezeigt werden kann muss noch das Display angegeben werden:

zenity --info --title="Titel des Dialogs" --text "Text, der angezeigt werden soll" --display=:0

Diesen Befehl kann man nun in ein Bash- oder Perl-Script einfügen, wobei der Titel fest sein kann und der Text als Argument übergeben wird. Ich habe mich für Perl entschieden:

#!/usr/bin/perl
 
system("zenity --info --title=\"Erinnerung\" --text \"@ARGV\" --display=:0");

Dieses Script habe ich unter dem Namen r (für “remember”) im bin-Ordner meines Homeverzeichnisses gespeichert. Dieses muss natürlich im Pfad liegen, was durch folgende Zeile in der Datei ~/.bashrc erreicht werden kann:

export PATH=$PATH:/home/user/bin

“user” muss natürlich durch den entsprechenden Usernamen ersetzt werden. Nachdem man die ~/.bashrc mit dem Befehl

. ~/.bashrc

neu “geladen” hat kann man sich nun an Termine oder andere Dinge erinnern lassen.

Beispiele:
Um 14:30 Termin bei FooBar. Also um 14:15 erinnern:

at 14:15
r Termin bei FooBar in 15 Minuten
Strg+d

In einer halben Stunde ist eine Besprechung (5 min vorher erinnern):

at now +25min
r Besprechung
Strg+d

Es öffnet sich zur angegebenen Zeit ein Dialogfenster (egal, was man gerade macht – solange man sich in X befindet. Bei Spielen im Fullscreen habe ich es jedoch nicht getestet.), welches den Titel “Erinnerung” enthält und den angegebenen Text ausgibt. Das Fenster kann durch einen Klick auf “OK” wieder geschlossen werden.

at bietet noch viele weitere Möglichkeiten eine Zeit anzugeben. Diese werden im (ersten) oben verlinkten freiesMagazin-Artikel beschrieben.

Unter Vim gibt es die Möglichkeit, den Namen der aktuellen Datei als Titel für das Screenfenster zu benutzen.
Dafür braucht man nur die folgenden Zeilen zur ~/.vimrc hinzufügen:

if expand('$TERM') == 'screen'
augroup vim_screen
  autocmd!
  autocmd VimEnter,BufWinEnter,WinEnter *
    \ exec "silent! !echo -ne '\\ek" . expand('%:t') . "\\e\\\\'"
augroup END
endif

[UPDATE]Auf dem 256bit Blog beschreibt Christian Brabandt, wie man den Screen-Titel von Vim aus ohne autocommands und mit sehr vielen Einstellungen setzen kann.[/UPDATE]

Ansonsten finde ich es sehr praktisch, wenn in der Statusleiste das aktuelle Verzeichnis steht. Da der komplette Pfad meist sehr lang ist, können mit einem regulären Ausdruck alle Verzeichnisse bis auf das letzte jeweils mit ihren Anfangsbuchstaben abgekürzt werden:

s/(\w).*?\//$1\//g

So wird /home/zimon/.vim/plugin zu /h/z/.v/plugin abgekürzt.

Wem das immer noch zu lang ist, der kann aus dem Namen des letzten Verzeichnisses auch noch die Vokale heraus nehmen (ähnlich wie es dillo in seinen Tabs macht):

s/(\w).*?\//$1\//g; my $end; $x=~s/\/(.)(?:[aeiou]|([^aeiou\/])(?{$end.=$^N}))*\s*$/\/$1$end/

Damit wird /home/zimon/.vim/plugin zu /h/z/.v/plgn

Um in der Bash den Screen-Titel automatisch zu setzen, kann man folgenden Code zu seiner ~/.bashrc hinzufügen. Hier wurde der erste reguläre Ausdruck genutzt (man kann ihn natürlich auch durch den anderen Ausdruck ersetzen, wenn man möchte):

function precmd {
    case "$TERM" in
        screen)
        wd=`perl -e '$x=shift; $x=~ s/(\w).*?\//$1\//g; print $x;' "$PWD"`
        echo -ne "\033k$wd\033\\"
        ;;
    esac
}
PROMPT_COMMAND=precmd

Für zsh User gibt es hier den Code für die ~/.zshrc. In diesem Beispiel wurde der zweite reguläre Ausdruck genutzt:

function precmd {
    if [[ "$TERM" == "screen" ]]; then
    local wd=`perl -e '$x=shift; $ x=~ s/(\w).*?\//$1\//g; my $end; $x=~s/\/(.)(?:[aeiou]|([^aeiou\/])(?{$end.=$^N}))*\s*$/\/$1$end/; print $x;' "$PWD"`
	PR_STITLE=$'%{\ek'$wd$'\e\\%}'
    fi
}

Vielen Dank an Ploppor für den zsh Code und sonstige zahlreiche Unterstützung in letzter Zeit.

Es tut mir leid, dass ich in letzter Zeit nichts geschrieben habe, aber meine Diplomarbeit lässt mir einfach keine Zeit.

perl -e 'print "Hello World!\n"'

Um jede print-Anweisung mit einem “newline” abzuschließen, kann man zusätzlich die Option -l benutzen:

perl -l -e 'print "Hello World!"; print "Hello Ubuntuusers!"'

Um eine Datei Zeile für Zeile durchzugehen, gibt es die Option -n. Das Program beschreibt dann ähnlich wie bei awk was mit jeder Zeile geschehen soll:

perl -n -l -e 'print $_ if $_ =~ /foo/"' datei.txt

gibt alle Zeilen aus, die “foo” enthalten.
Die Option -n entspricht folgendem Code:

while(<>){
    # Der Code, der übergeben wird
}

Die Option -a bringt perl noch einen Schritt näher zu awk. Damit werden die Wörter einer Zeile (die durch Leerzeichen getrennt sind) in das Array @F geladen. Den Worttrenner kann man mit der Option -F setzen:

perl -n -a -F; -e 'print $F[$#F]' datei.csv

gibt von jeder Zeile das letzte Element einer csv (Comma Separated Value) Datei aus.
Dies entspricht folgendem Code:

while(<>){
    @F = split($pattern);
    # Der übergebene Code
}

wobei $pattern das mit -F übergebene Pattern (im obigen Beispiel ";") ist. Dadurch sind auch reguläre Ausdrücke wie -F/[0-9]+/ möglich.

Es können auch die Schlüsselwörter BEGIN und END gesetzt werden um einen Block vor oder nach der Hauptschleife auszuführen:

perl -n -l -a -e 'BEGIN{$x=0} {$x+=$F[$#F]} END{print $x}' preisliste.txt

errechnet den Gesammtpreis einer Preisliste, in der am Ende jeder Zeile der Preis steht. Es wird also von jeder Zeile das letzte Wort addiert. Man könnte das Programm jetzt auch noch etwas kürzer schreiben:

perl -nlae '$x+=$F[$#F]; END{print $x}' preisliste.txt

Dies entspricht dem awk-Programm:

awk '{x+=$NF} END{print x}' preisliste.txt

Für das Suchen und Ersetzen mit Regulären Ausdrücken eignet sich die Option -p. Diese Funktioniert genau wie -n mit dem Unterschied, dass jede Zeile automatisch ausgegeben wird. So kann man wie mit sed Dateien ändern:

perl -pe 's/foo/bar/g' datei.txt > datei_new.txt

ersetzt jedes Vorkommen von “foo” durch “bar” und schreibt das Ergebnis in die Datei “datei_new.txt”.

Um die Datei direkt zu ändern, kann man die Option -i verwenden. Dieser kann optional ein String mitgegeben, der an den verwendeten Dateinamen angehängt den Dateinamen einer anzulegenden Sicherheitskopie ergibt:

perl -pi -e 's/foo/bar/g' *.txt
perl -pi.orig -e 's/foo/bar/g' datei.txt

Beim ersten Befehl jede Text-Datei im aktuellen Verzeichnis direkt geändert. Beim zweiten wird die “datei.txt” nach “datei.txt.orig” kopiert bevor jedes Vorkommen von “foo” durch “bar” ersetzt wird. (Man kann natürlich auch mit dem 2. Befehl beliebig viele Dateien bearbeiten, wenn man * benutzt.)

Module
Die Option -M erlaubt es einem beliebige Module einzubinden, die dann im Programm benutzt werden können. So kann man z.B. mit dem folgenden Befehl mit dem Modul LWP::Simple eine Webite laden und den HTML-Code ausgeben:

ls | perl -MLWP::Simple -e 'getprint("http://zinformatik.de")'

Mit dem folgenden Befehl werden von allen iso Dateien im Verzeichnis MD5-Summen erstellt:

ls *.iso | perl -MDigest::MD5 -nle 'open(FILE,$_); $d=Digest::MD5->new; $d->addfile(FILE); print $d->hexdigest'

Fazit
Für kleinere kosmetische Änderungen eines Textes oder einer Ausgabe sowie zum extrahieren von Informationen daraus ist awk meist besser geeignet. Bei komplexeren Aufgabenstellungen ist die Mächtigkeit von perl jedoch vorteilhafter.
Vor allem durch die Möglichkeit der Dateioperationen sollen manche Aktionen beschleunigt werden können:
Statt des Aufrufs:

find -name "*.bak" -exec rm "{}" \;

der für jede gefundene Datei einen neuen Prozess startet um sie zu löschen kann man folgenden Befehl nutzen:

find -name "*.bak" -print | perl -nle 'unlink'

Es ist jedenfalls nicht verkehrt beides zu kennen, ganz nach dem Motto: Für jeden Zweck die richtige Programmiersprache.

[UPDATE]Mehr informationen liefert der Befehl perldoc perlrun (perldoc muss installiert sein) oder die Seite http://p3rl.org/perlrun[/UPDATE]

Übrigens kann man die “Ursprungsversion” eines Kommandos, welches durch einen Alias überschrieben wurde durch ein Vorrangestelltes \ aufrufen. Also wenn es z.B. folgenden alias gibt:

alias ls="ls --color=auto"

so kann man durch die Eingabe von

\ls

den Befehl ls ohne –color=auto aufrufen.

Grundlegende Kommandos im Dateisystem

# Macht die Ausgabe von ls farbig:
alias ls='ls --color=auto' 
 
# Gibt zu jeder Datei weitere Informationen aus. Größenangaben immer "menschenlich lesbar":
alias ll='ls -lh' 
 
# Wie ll, aber es werden auch versteckte Dateien aufgelistet:
alias la='ls -lha' 
 
# Für Vertipper recht praktisch:
alias cd..='cd ..' 
alias cd-='cd -'
 
# Abkürzung für cd .. :
alias ..='cd ..' 
alias ...='cd ../..'
 
# Alle nicht existierenden Verzeichnisse automatisch erstellen:
alias mkdir='mkdir -p'
 
# Für Anfänger zu empfehlen (es wird bei jeder Datei nachgefragt)
alias rm='rm -i'
alias cp='cp -i'
alias mv='mv -i'

Befehle die immer mit bestimmten Optionen ausgeführt werden sollen sowie Abkürzungen

# Bei df die Größen immer "menschlich lesbar" anzeigen:
alias df='df -h' 
 
# Bei du die Größen immer "menschlich lesbar" anzeigen:
alias du='du -h' 
 
# Suche in less case-insensitive:
alias l='less -i' 
 
# Zeigt Änderungen einer Datei an (wie tail -f):
alias lf='less -i +F' 
 
# Beispielhafte Abkürzung für ssh
alias meinserver='ssh user@meinserver.tld'
 
# lässt grep case-insensitive arbeiten und markiert die Treffer farbig:
alias grep='grep -i --color=auto'

Die Follow-Option von less (less +F) ist recht praktisch, da sie einfach mit Strg+c unterbrochen und mit F weitergeführt werden kann. So kann man leicht nochmal zurück scrollen.

Befehle zum Suchen, Installieren und Updaten

# Da apt-get ja meist mit sudo aufgerufen wird:
alias apt-get='sudo apt-get' 
 
#Statt dessen kann man auch die folgenden Befehle nutzen:
alias agi='sudo apt-get install'
alias acs='apt-cache search'
 
# Das ganze System updaten:
alias update='sudo apt-get update && sudo apt-get upgrade'

Komplexere Befehle

# Starte Kommando in neuem Screen-Fenster:
alias s='screen -X screen' 
 
# Dateinamen im aktuellen Verzeichnis nach Ausdruck durchsuchen:
alias lg='ls --color=always | grep --color=always -i' 
 
# Timestamp generieren:
alias timestamp='date "+%Y%m%d%H%M%S"' 
 
# Verzeichnis mit aktuellem Timestamp erstellen:
alias tsdir='timestamp | xargs mkdir' 
 
# Änderungen bei allen angegebenen Logdateien live anzeigen:
alias mylogs='sudo tail -f /var/log/{syslog,messages}' 
 
# Einen Prozess (nach Namen) suchen:
alias psg='ps ax | grep -v grep | grep ' 
 
# Die öffentliche IP ausgeben:
alias myip="wget -qO - http://checkip.dyndns.org | sed 's/[a-zA-Z<>/ :]//g'" 
 
# Zuletzt bearbeitete Datei in vim öffnen:
alias lvim="vim -c \"normal '0\"" 
 
# Die 10 Prozesse anzeigen, die den meisten RAM verbrauchen:
alias psram='ps aux | sort -rnk 4 | head'
 
# Zeige alle Prozesse bei ps (außer ps selbst) mit langer Ausgabe
alias ps='ps ax | grep -v "ps ax"'

Livesuche in der History
Sucht man ein Kommando, welches man schon einmal eingegeben hat, so kann man die History (welche in der Datei ~/.bash_history gespeichert wird) durchsuchen. Die Bash stellt dafür sogar eine Livesuche bereit. Diese wird mit der Tastenkombination Strg+r eingeleitet. Danach kann man eine beliebige Zeichenkette eingeben, die in irgendeinem Befehl schonmal vorgekommen ist. Mit jedem eingegebenen Buchstaben werden Vorschläge gemacht, wobei die Suche immer Rückwärts läuft.
Durch erneutes Drücken von Strg+r kann man weiter suchen. So kann man dann z.b. mit Strg+r sudo Strg+r zum vorletzten sudo-Befehl gelangen.

Weitere History-Funktionen
Mit dem Befehl history werden alle eingegebenen Kommandos, die sich in der History befinden mit Zeilennummer ausgegeben. Gibt man dem Befehl noch eine Zahl x als Parameter mit, so werden nur die letzten x Einträge angezeigt. Mit der Option -c (clear) kann man die History löschen.
Normalerweise wird die Datei ~/.bash_history erst beim beenden der Shell geschrieben. Man kann sie aber auch sofort schreiben, indem man den Befehl history -w ausführt. Umgekehrt kann man die aktuelle History auch mittels history -r aus der Datei ~/.bash_history einlesen.

Praktische Tastenkombinationen

• Strg+l – (kleines L) löscht den Bildschirm
• Strg+u – löscht alles vor dem Cursor
• Strg+t – tauscht die letzten beiden Zeichen
• Alt+. – fügt das letzte Argument ein
• Strg+d – beendet die Sitzung bzw. sendet ein EOF (z.B. für at).

Praktische Variablen

• !! – kompletter letzter eingegebener Befehl
• !$ – letztes Argument
• $$ – PID der aktuellen Bash
• !String – letztes Kommando, das mit String angefangen hat
• !?String – letztes Kommando, welches String enthielt.

So kann man mit sudo !! den letzten Befehl mit root-Rechten erneut ausführen oder ihn mit echo “!!” > script.sh in eine Datei schreiben.
Nach einem Kopierbefehl wechselt man mit cd !$ in das Verzeichnis, wohin die Datei(en) kopiert wurde(n).
Mit kill -9 $$ wird die Bash geschlossen ohne dass die Historydatei geschrieben werden kann.

vi-Modus
Die Bash beinhaltet einen vi-Modus, wodurch man vi-Befehle in der Bash nutzen kann. Den Modus startet man mittels

set -o vi

Danach kann man mit ESC in den Kommandomodus gelangen und mit hjkl statt Pfeiltasten navigieren. auch dd, D , p , A, 0 und $,… funktionieren.
Die obige Zeile kann man sich auch in die ~/.bashrc schreiben, damit der vi-Modus standardmäßig aktiviert ist.
Leider funktioniert danach die Tastenkombination Strg+l nicht mehr. Diese kann man jedoch mit einem Binding wieder aktivieren. Dafür schreibt man folgendes in die ~/.bashrc:

# Strg+l - clear screen
bind -m vi-insert "\C-l":clear-screen

Geänderte Konfigurationsdatei einlesen ohne neues Terminal aufzumachen
kann man mit folgendem Befehl:

source ~/.bashrc

Prozesskontrolle
Um ein Programm im Hintergrund zu starten hängt man dem Befehl ein & an.
Hat man dies vergessen, so kann man das Programm mit Strg+z anhalten, wodurch man wieder einen Prompt bekommt. Dann kann man den Prozess mittels bg im Hintergrund weiterlaufen lassen. Um ihn wieder in den Vordergrund zu holen genügt ein fg.
Wenn mehrere Prozesse im Hintergrund laufen, so holt fg den letzten Prozess zurück, der in den Hintergrund geschickt wurde. Möchte man einen anderen Prozess in den Vordergrund holen, so kann man fg die entsprechende Job-ID (diese steht in Eckigen klammern, wenn ein Prozess gestoppt oder in den Hintergrund verschoben wird) als Argument mitgeben. Alternativ kann man als Paramter für fg ein % gefolgt von einigen Anfangsbuchstaben des Befehls mitgeben.

fg %v

holt zum Beispiel einen vim-Prozess aus dem Hintergrund (wenn keine anderen Prozesse mit v im Hintergrund sind).

Um zwei Befehle nacheinander auszuführen, kann man sie mit einem Semikolon trennen. Möchte man, dass der 2. Befehl nur ausgeführt wird, wenn der erste Befehl erfolgreich war, so trennt man sie mit &&. dies ist praktisch beim compilieren von Programmen:

./configure && make && make install

So wird make nur ausgeführt, wenn das configurescript ohne Fehler durchgelaufen ist. make install wird nur ausgeführt, wenn make auch wirklich compiliert hat.

Ich gehe hier auf nawk (new awk) ein, dass auf den meisten Linux-Distributionen der Standard ist. Es gibt noch eine erweiterte Version namens gawk (GNU awk), auf der die hier genannten Beispiele aber genauso funktionieren.

Wer irgendeine Programmiersprache (am besten C, Java oder Perl) beherrscht, wird mit awk recht schnell zurecht kommen. awk liest meist eine Textdatei (oder andere Eingabe) ein und zerstückelt sie direkt in Zeilen und diese wiederrum in Felder (Wörter). Dadurch hat man sich schon etwas Programmieraufwand gespart. Nun geht awk den Text Zeile für Zeile durch und führt das Programm auf jeder einzelnen Zeile aus. Es gibt einige Standardvariablen, die man verwenden kann:

• $0 ist die aktuelle Zeile
• $1 .. $n sind die Wörter der Zeile
• NF (Number of Fields) ist die Anzahl der Felder der aktuellen Zeile
• NR (Number of Records) ist die Nummer der aktuellen Zeile

Mit diesen Variablen kann man schon recht praktische Programme schreiben. Dabei wird für jede Zeile nach folgendem Schema vorgegangen

Muster { Aktion }

Wobei das Muster meist ein regulärer Ausdruck ist, bei dessen Gültigkeit (für die Zeile) die Aktion auf die Zeile ausgeführt wird. Es kann jedoch eine beliebige Bedingung sein. Oft wird das Muster weggelassen, was dazu führt, dass die Aktion auf jede Zeile ausgeführt wird.

Ein paar einfache Beispiele:

awk '{print $2}' datei.txt

Gibt von jeder Zeile das 2. Wort aus

awk '{print NF}' datei.txt

Gibt von jeder Zeile die Anzahl der Wörter aus

awk '{print $NF}' datei.txt

Gibt von jeder Zeile das letzte Wort aus

awk '{print NR ": " $0}' datei.txt

Gibt jede Zeile mit vorangestellter Zeilennummer aus.

Wie man sieht können Strings einfach verkettet werden indem sie aneinander geschrieben werden (ein Leerzeichen dazwischen erhöht die Lesbarkeit). Variablen werden hingegen mit , konkateniert. Ein Semikolon trennt (wie bei vielen Programmiersprachen) 2 Anweisungen.

awk 'END{print NR}' datei.txt

Gibt die Anzahl der Zeilen aus. Das END ist ein Muster, das besagt, dass die Aktion erst ausgeführt werden soll, wenn alle Zeilen bearbeitet wurden. Entsprechend gibt es ein Muster BEGIN, dessen Aktion vor dem Einlesen der Datei ausgeführt wird.

Die Hochkommata umschließen das eigentliche Programm und verhindern, dass die Shell Zeichen daraus interpretiert. Entsprechend müssen Strings innerhalb des Programms mit doppelten Anführungszeichen gekennzeichnet werden.

Variablen
Es gibt nur 2 Typen von Variablen: Zahlenwerte und Strings. Variablen brauchen nicht deklariert zu werden und werden standardmäßig mit 0 bzw. “” initialisiert. Wie bei Perl wird der Typ automatisch bestimmt.

Ein einfaches Beispiel könnte so aussehen:

awk '{sum+=$NF} END{print sum}' datei.txt

Dieses Programm addiert das letzte Wort jeder Zeile zu der Variablen sum hinzu und gibt am Ende den Inhalt von sum aus. Dies ist recht praktisch, wenn man sich die einzelnen Posten einer Bestellung in eine Datei schreibt wobei als letztes Wort jeweils der Preis steht. So kann einfach die Gesamtsumme berechnet werden ohne jeden Betrag einzeln in einen Taschenrechner tippen zu müssen.

Ein weiteres schönes Beispiel ist den Durchschnitt zu errechnen:

awk '{sum+=$NF} END{print sum/NR}' datei.txt

Hier wird das Ergebnis noch durch die Anzahl der Zeilen geteilt. Dies ist praktisch z.B. für einen Notendurchschnitt.

Ich kenne kaum eine Programmiersprache, bei der man mit so wenig Kenntnissen (Variablen, Print-Anweisung und Arithmetik) schon so viele praktische Dinge erledigen kann. Nimmt man nun noch einfache reguläre Ausdrücke hinzu, kann hat man noch mehr praktische Möglichkeiten.

Reguläre Ausdrücke als Muster Die folgenden Beispiele ließen sich so oder ähnlich auch mit anderen Kommandos realisieren, doch hier geht es ja um awk:

ls | awk '/png$/{print}'

awk '/foo/{print}' datei.txt

awk '/foo/{print NR": "$0}' datei.txt

ls -l | awk '/png$/{sum+=$5} END{print sum}'

ls -l | awk '/png$/{sum+=$5; print} END{ print sum/(1024*1024)" MB"}'

ls -l | awk '/png$/{sum+=$5; anz++; print} END{print "Anzahl der PNG-Dateien: "anz; print "Gesammtgröße der PNG-Dateien: "sum/1024" kB ( "sum" Bytes )"; print "Durchschnittliche Größe einer PNG-Datei: "(sum/anz)/1024" kB"}'

arr[5]=7; # setzt den 6. Wert des Arrays auf 7
arr[5,3]="hallo"; # setzt den 4. Wert des 6. Arrays auf "hallo". (Genauer gesagt setzt es "5 SUPSEP 3" auf "hallo")
arr["first"]=8; # assoziatives Array

#!/usr/bin/awk -f

ifconfig | awk '/eth0/{getline; print $2}'

ifconfig | awk '/eth0/{getline; print substr($2,index($2,":")+1)}'

awk 'length($0) > longest {line=$0; longest=length($0); num=NR} END{print num": "line}' datei.txt

awk '{
	for(i=1;i<=NF;i++){
		if(length($i)>length(biggest)){
			biggest=$i;
		}
	}
}
END{print biggest}' datei.txt

awk '{for(i=1;i<=NF;i++){if(length($i)>length(biggest)){biggest=$i;}}}END{print biggest}' datei.txt

ifconfig | awk '/eth0/{getline; if($2 ~ /[0-9]+\./){print substr($2,index($2,":")+1)} else {print ""}}'

function name(arg1, arg2){
...
}

#!/usr/bin/awk -f
 
function isprim(number){
	if(number==1)
	{
		return 0;
	}
	else if(number<4)
	{
		return 1;
	}
	else if(number%2==0)
	{
		return 0;
	}
	else if(number<9)
	{
		return 1;
	}
	else if(number%3==0)
	{
		return 0;
	}
	else
	{
		r=int(sqrt(number)+0.5);
		f=5;
		while(f<=r)
		{
			if(number%f==0)
			{
				return 0;
			}
			if(number%(f+2)==0)
			{
				return 0;
			}
			f=f+6;
		}
	}
	return 1;
}
 
/^[0-9]+$/{
	if(isprim($0)){
		prim=": prim";
	}else{
		prim="";
	}
	print $0,prim;
}

awk 'BEGIN{RS="\. |\.\n|\! |\!\n|\? |\?\n"} {print}' datei.txt