Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 5: Aliase und Funktionen

Ziel: Eigene Abkürzungen bauen und für jede Aufgabe richtig zwischen Alias, Funktion und Skript wählen. · Dauer: ca. 60 min · Voraussetzung: Tag 4

Briefing

  • Alias: reiner Textersatz am Zeilenanfang. Kein Argument-Handling, keine Logik.
  • Funktion: läuft in der aktuellen Shell. Sie kann cd, Variablen setzen, Argumente prüfen.
  • Skript: eigener Prozess mit eigener Sprache. Es liegt im PATH und ist auch für xargs, make, CI und andere Programme aufrufbar.
  • zsh kennt zusätzlich globale Aliase (überall in der Zeile) und Suffix-Aliase (Dateiendung entscheidet).
  • Ablage im Lab: ein Thema pro Datei unter ~/term-lab/config/zsh/*.zsh. Die Lab-.zshrc lädt alle automatisch. Im echten Leben heißt der Ordner ~/.config/zsh/ (Tag 13).
Brauche ich ...                      -> nimm
nur eine kürzere Schreibweise?       -> Alias
Argumente, if/case, cd, Variablen?   -> Funktion
andere Sprache, Aufruf von außen?    -> Skript in ~/term-lab/bin

Drill 1: Der erste Alias

Starte die Lab-Shell und wechsle ins Projekt:

~/term-lab/lab
cd ~/term-lab/projekt
alias gl1='git log --oneline -3'
gl1

Erwartet:

2e4e6aa (HEAD -> main) chore: Config, Manifeste, Report
a57983c feat: Warenkorb und HTTP-Server
1dc0abc init: Projektgerüst

Jetzt einmal falsch, alles in einer Zeile:

alias gl2='git log --oneline -3'; gl2

Erwartet:

zsh: command not found: gl2

Warum? zsh ersetzt Aliase beim Einlesen der Zeile. Zu diesem Zeitpunkt gab es gl2 noch nicht. In Dateien gilt dasselbe: Ein Alias wirkt erst ab der nächsten Zeile.

Nachschlagen und entfernen:

alias gl1
type gl1
unalias gl1 gl2
type gl1

Erwartet:

gl1='git log --oneline -3'
gl1 is an alias for git log --oneline -3
gl1 not found

Flüchtige Aliase sind mit der Shell weg. Dauerhaft wird es erst in einer Datei (Drill 2).

Fortschritt speichern? Kostenlos registrieren

Drill 2: Aliase in eine Moduldatei

cat > ~/term-lab/config/zsh/aliases.zsh <<'EOF'
# aliases.zsh – Aliase aus Tag 5 (Tag 6 ergänzt moderne Werkzeuge)
alias ..='cd ..'
alias ...='cd ../..'
alias md='mkdir -p'
alias h='history -10'
alias reload='exec zsh'          # Shell neu starten statt "source ~/.zshrc"
alias path='print -l $path'      # PATH zeilenweise

alias g='git'
alias gs='git status -sb'
alias gl='git log --oneline --graph -15'
EOF
reload
type gs gl

Erwartet:

gs is an alias for git status -sb
gl is an alias for git log --oneline --graph -15

Tipp: exec zsh ersetzt die Shell durch eine frische. Das ist sauberer als source ~/.zshrc, weil keine alten Aliase oder Funktionen übrig bleiben. ZDOTDIR und LAB sind exportiert, reload wirkt im Lab also wie exec ~/term-lab/lab aus Tag 1.

Die vollständige Datei mit allen Aliasen aus Tag 5 und 6 liegt unter $BUCH/zsh/aliases.zsh.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Aliase umgehen und sichtbar machen

Tag 6 legt ls auf eza. Manchmal willst du trotzdem das Original:

alias ls='eza --group-directories-first'
whence -w ls cd gs
\ls -d cmd
command ls -d cmd
echo =ls

Erwartet:

ls: alias
cd: builtin
gs: alias
cmd
cmd
/bin/ls
  • \ls und command ls umgehen den Alias.
  • =ls ist eine zsh-Expansion und liefert den Pfad des echten Programms.

Was steckt hinter einem Alias, bevor du Enter drückst? Tippe gs und dann ⌃X a:

[lab] projekt % git status -sb

Das Widget _expand_alias ersetzt den Alias direkt in der Zeile. Es kommt mit dem Completion-System, also ab compinit (Tag 2). Prüfen:

bindkey | grep _expand_alias

Erwartet:

"^Xa" _expand_alias

Tipp: alias sudo='sudo ' (mit Leerzeichen am Ende) lässt zsh auch das nächste Wort als Alias prüfen. Dann funktioniert sudo ll.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Globale Aliase

Globale Aliase (-g) werden überall in der Zeile ersetzt, nicht nur am Anfang. Ideal für Pipe-Enden, die du ständig tippst:

cat >> ~/term-lab/config/zsh/aliases.zsh <<'EOF'

# Globale Aliase: werden überall in der Zeile ersetzt
alias -g G='| grep -i'
alias -g L='| less -R'
alias -g H='| head'
alias -g C='| wc -l'
alias -g J='| jq .'
alias -g NE='2>/dev/null'
EOF
reload
grep ERROR logs/app.log C
grep ERROR logs/app.log G checkout H -3

Erwartet:

      50
2026-10-05T08:06:42 checkout ERROR request_id=r0006 user=u06
2026-10-05T08:16:52 checkout ERROR request_id=r0016 user=u16
2026-10-05T08:26:02 checkout ERROR request_id=r0026 user=u03

Die Kehrseite: Ein einzelnes großes G ist jetzt nirgends mehr harmlos.

print -r -- Status G

Erwartet (gekürzt):

usage: grep [-abcdDEFGHhIiJLlMmnOopqRSsUVvwXxZz] [-A num] [-B num] [-C[num]]

In Anführungszeichen ("Status G") passiert nichts. Halte globale Aliase deshalb kurz, großgeschrieben und wenige.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Suffix-Aliase

Ein Suffix-Alias (-s) macht eine Datei „ausführbar”: Tippst du nur den Dateinamen, startet zsh das passende Programm.

cat >> ~/term-lab/config/zsh/aliases.zsh <<'EOF'

# Suffix-Aliase: Dateiname tippen öffnet die Datei mit dem Programm
alias -s md=bat
alias -s log='less +G'
alias -s {json,yaml,yml}=bat
EOF
reload
alias -s
config/app.json

Erwartet (gekürzt):

json=bat
log='less +G'
md=bat
yaml=bat
yml=bat
─────┬──────────────────────────────────────────────────────────
     │ File: config/app.json
─────┼──────────────────────────────────────────────────────────
   1 │ {"service":"shop","port":8080,"replicas":3,
   2 │  "features":{"rabatt":false,"newsletter":true}}
─────┴──────────────────────────────────────────────────────────

logs/app.log springt jetzt direkt ans Ende des Logs (+G), q beendet less. bat kommt in Tag 6 ausführlich.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Die erste Funktion – mkcd

Ein Alias kann kein cd in ein Argument machen, das erst noch angelegt wird. Eine Funktion schon:

cat > ~/term-lab/config/zsh/functions.zsh <<'EOF'
# functions.zsh – Shell-Funktionen aus Tag 5

# Verzeichnis anlegen und hineinwechseln
mkcd() {
  [[ -n $1 ]] || { print -u2 "usage: mkcd <dir>"; return 2; }
  mkdir -p -- "$1" && cd -- "$1"
}

# n Ebenen nach oben: up 3
up() {
  local n=${1:-1} d=
  [[ $n == <-> ]] || { print -u2 "usage: up [n]"; return 2; }
  repeat $n d+=../
  cd -- "$d"
}

# Sicherungskopie mit Zeitstempel: bak datei...
bak() {
  local f
  for f in "$@"; do
    cp -p -- "$f" "$f.$(date +%Y%m%d-%H%M%S).bak" && print "✔ $f gesichert"
  done
}
EOF
reload
mkcd /tmp/lab-demo/a/b && pwd
up 2; pwd
mkcd; echo "rc=$?"

Erwartet:

/tmp/lab-demo/a/b
/tmp/lab-demo
usage: mkcd <dir>
rc=2

Die Bausteine, die in jeder guten Funktion stecken:

  • local hält Variablen in der Funktion. Ohne local überschreibst du globale Variablen.
  • "$1" und "$@" immer in Anführungszeichen. -- schützt vor Dateinamen, die mit - beginnen.
  • print -u2 schreibt Fehler nach stderr. return 2 liefert einen Exit-Code für && und ||.
  • <-> ist ein zsh-Muster für „nur Ziffern”.
cd ~/term-lab/projekt
type mkcd
functions up | head -4

Erwartet (gekürzt):

mkcd is a shell function from /Users/du/term-lab/config/zsh/functions.zsh
up () {
    local n=${1:-1} d=
    [[ $n == <-> ]] || {
        print -u2 "usage: up [n]"

Fortschritt speichern? Kostenlos registrieren

Drill 7: Werkzeugkasten – extract, port, please

Drei Klassiker, die in fast jeder Senior-Konfiguration stecken:

cat >> ~/term-lab/config/zsh/functions.zsh <<'EOF'

# Archive entpacken, egal welches Format
extract() {
  local f
  for f in "$@"; do
    [[ -f $f ]] || { print -u2 "extract: '$f' ist keine Datei"; return 1; }
    case ${f:l} in
      *.tar.gz|*.tgz)   tar -xzf "$f" ;;
      *.tar.bz2|*.tbz2) tar -xjf "$f" ;;
      *.tar.xz|*.txz)   tar -xJf "$f" ;;
      *.tar)            tar -xf "$f" ;;
      *.zip)            unzip -q "$f" ;;
      *.gz)             gunzip -k "$f" ;;
      *.bz2)            bunzip2 -k "$f" ;;
      *)  print -u2 "extract: unbekanntes Format: $f"; return 1 ;;
    esac
  done
}

# Wer lauscht auf Port X? (ohne Argument: alle TCP-Listener)
port() {
  if [[ -n $1 ]]; then
    lsof -nP -iTCP:"$1" -sTCP:LISTEN
  else
    lsof -nP -iTCP -sTCP:LISTEN
  fi
}

# Letzten Befehl mit sudo wiederholen – zeigt ihn vorher an
please() {
  local last
  last=$(fc -ln -1) || return 1
  print -P "%F{yellow}sudo $last%f"
  read -q "?Ausführen? [y/N] " || { print; return 1; }
  print
  eval "sudo $last"
}
EOF
reload

${f:l} macht den Namen klein, damit auch ARCHIV.ZIP passt. Jetzt testen:

tar -czf /tmp/lab-cfg.tgz config
mkcd /tmp/lab-x && extract /tmp/lab-cfg.tgz && ls config
extract nix.rar
cd ~/term-lab/projekt

Erwartet:

app.json  app.yaml
extract: 'nix.rar' ist keine Datei

Einen Webserver starten und finden:

python3 -m http.server 8765 >/dev/null 2>&1 &
port 8765
kill %1
port 8765; echo "rc=$?"

Erwartet (gekürzt):

COMMAND   PID USER FD   TYPE             DEVICE SIZE/OFF NODE NAME
Python  77787 du    4u  IPv6 0x1833b23dbc67a68      0t0  TCP *:8765 (LISTEN)
rc=1

please holt die letzte Zeile aus der History und fragt nach:

ls /var/root
please

Erwartet (Antwort n):

Permission denied: /var/root - code: 13
sudo ls /var/root
Ausführen? [y/N] n

Sicherheit: please führt per eval mit Root-Rechten aus, was in der History steht. Die Rückfrage ist Absicht. Baue nie ein please ohne Bestätigung.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Autoload-Funktionen und echte Skripte

Viele Funktionen machen die Startzeit langsam. zsh kann Funktionen erst beim ersten Aufruf laden. Eine Datei pro Funktion, der Dateiname ist der Funktionsname:

mkdir -p ~/term-lab/config/zsh/functions
cat > ~/term-lab/config/zsh/functions/gmerged <<'EOF'
# gmerged – lokale Branches, die schon in main gemergt sind
git branch --merged "${1:-main}" | grep -vE '^\*|^ *(main|master)$'
EOF
cat >> ~/term-lab/config/zsh/functions.zsh <<'EOF'

# Autoload: Funktionen aus eigenen Dateien, geladen beim ersten Aufruf
fpath=("$LAB/config/zsh/functions" $fpath)
autoload -Uz gmerged
EOF
reload
type gmerged
git branch lab-alt && gmerged
type gmerged
git branch -d lab-alt

Erwartet (gekürzt):

gmerged is an autoload shell function
  lab-alt
gmerged is a shell function from /Users/du/term-lab/config/zsh/functions/gmerged
Branch lab-alt entfernt (war 2e4e6aa).

Ein Skript wählst du, wenn andere Programme es aufrufen sollen oder du Bash-Semantik willst. Es landet in ~/term-lab/bin, das seit Tag 0 im PATH liegt:

cat > ~/term-lab/bin/loglevels <<'EOF'
#!/usr/bin/env bash
# loglevels – zählt Log-Level (3. Spalte) in Logdateien
set -euo pipefail
(( $# )) || { echo "usage: loglevels <datei>..." >&2; exit 2; }
awk '{ n[$3]++ } END { for (l in n) printf "%-6s %d\n", l, n[l] }' "$@" | sort
EOF
chmod +x ~/term-lab/bin/loglevels
shellcheck ~/term-lab/bin/loglevels && echo "✔ shellcheck"
loglevels logs/app.log
echo logs/app.log | xargs loglevels | head -1
echo /tmp/lab-y | xargs mkcd

Erwartet:

✔ shellcheck
DEBUG  50
ERROR  50
INFO   350
WARN   50
DEBUG  50
xargs: mkcd: No such file or directory

Die letzten beiden Zeilen zeigen den Unterschied: xargs startet Programme. Das Skript loglevels ist eins, die Funktion mkcd lebt nur in deiner Shell.

Fortschritt speichern? Kostenlos registrieren

Shortcut-Tabelle

Taste / Befehl Wirkung Merkhilfe
⌃X a Alias in der Zeile ausschreiben eXpand alias
\ls, command ls Alias umgehen Backslash = „roh”
=ls Pfad des echten Programms „ist gleich” welche Datei
type x, whence -v x Alias, Funktion, Builtin oder Datei? „was ist x?”
functions x Quelltext einer Funktion zeigt den Körper
unalias x, unfunction x Alias oder Funktion entfernen un- macht rückgängig
alias -g, alias -s globale und Suffix-Aliase listen global, suffix
reload (exec zsh) frische Shell mit neuer Konfig neu laden

Kontrollpunkt

c() { eval "$2" >/dev/null 2>&1 && echo "✔ $1" || echo "✘ $1"; }
c "Alias gs"             '[[ $(whence -w gs) == "gs: alias" ]]'
c "globaler Alias G"     '(( ${+galiases[G]} ))'
c "Suffix-Alias json"    '(( ${+saliases[json]} ))'
c "Funktion mkcd"        '[[ $(whence -w mkcd) == "mkcd: function" ]]'
c "mkcd ohne Argument"   '! mkcd'
c "extract, port, please" 'whence extract port please'
c "Autoload gmerged"     '(( ${fpath[(I)*config/zsh/functions]} ))'
c "Skript loglevels"     '[[ -x $LAB/bin/loglevels ]] && shellcheck $LAB/bin/loglevels'

Erwartet: acht Zeilen mit ✔.

Challenge

Schreib eine Funktion gcd, die ins Wurzelverzeichnis des aktuellen Git-Repos springt und außerhalb eines Repos mit Exit-Code 1 und einer Meldung abbricht. Teste sie aus ~/term-lab/projekt/internal/cart heraus.

Hinweis: git rev-parse --show-toplevel liefert die Wurzel; ein Alias reicht hier nicht, weil du einen Fehlerfall behandeln musst.

Lösung

cat >> ~/term-lab/config/zsh/functions.zsh <<'EOF'

# Ins Wurzelverzeichnis des Git-Repos springen
gcd() {
  local root
  root=$(git rev-parse --show-toplevel 2>/dev/null) \
    || { print -u2 "gcd: kein Git-Repo"; return 1; }
  cd -- "$root"
}
EOF
reload
cd ~/term-lab/projekt/internal/cart && gcd && pwd
cd /tmp && gcd; echo "rc=$?"

Erwartet (gekürzt):

/Users/du/term-lab/projekt
gcd: kein Git-Repo
rc=1

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Aliase sind persönlich. In Skripten, Makefiles, CI-Jobs und Runbooks immer die vollen Befehle schreiben.
  • Überschreibe keine Standardbefehle mit anderem Verhalten (rm='rm -i' erzieht zu Unachtsamkeit auf fremden Servern ohne diesen Alias).
  • Team-Werkzeuge gehören als Skript in ein Repo mit shellcheck in der CI, nicht als Funktion in deine .zshrc.
  • Gemeinsame Konfigurationen wie ~/.config/zsh/*.zsh mit chezmoi verwalten und versionieren (Tag 13).
  • Keine Secrets in Aliasen oder Funktionen. Tokens kommen aus Keychain oder Secret Store, nicht aus der .zshrc.