# fish — die benutzerfreundliche Shell mit Autosuggestions

> Praxis-Guide zu fish: Variablen, Funktionen, Abbreviations und Universal Variables in der benutzerfreundlichen, nicht-POSIX-kompatiblen Shell.

Source: https://www.jpkc.com/db/cheatsheets/shell-system/fish/

<!-- PROSE:intro -->
fish – die Friendly Interactive Shell – setzt auf Komfort statt Konvention: Autosuggestions, Syntax-Highlighting und intelligente Tab-Vervollständigung funktionieren sofort, ganz ohne Konfiguration. Der zentrale Stolperstein ist die eigene, nicht-POSIX-kompatible Syntax – statt `export` nutzt du `set -x`, statt `&&`/`||` schreibst du `and`/`or`. Dieser Guide zeigt dir Variablen, Funktionen, Abbreviations und die String-Tools, die du im Alltag wirklich brauchst.
<!-- PROSE:intro:end -->

## Grundlagen

`fish` — Eine Fish-Shell-Sitzung starten.

```bash
fish
```

`fish -c '<command>'` — Einen Kommando-String ausführen und beenden.

```bash
fish -c 'echo Hello World'
```

`fish -l` — Als Login-Shell starten.

```bash
fish -l
```

`fish -n <script>` — Syntax prüfen, ohne auszuführen (No-Execute-Modus).

```bash
fish -n myscript.fish
```

`fish_config` — Die webbasierte Konfigurationsoberfläche im Browser öffnen.

```bash
fish_config
```

`fish_config theme choose <name>` — Ein Farbschema von der Kommandozeile aus setzen.

```bash
fish_config theme choose 'Dracula'
```

`fish --version` — Die installierte Fish-Version anzeigen.

```bash
fish --version
```

## Variablen & Umgebung

`set <var> <value>` — Eine lokale Variable setzen (nur im aktuellen Scope).

```bash
set name 'World'
```

`set -x <var> <value>` — Eine Variable setzen und exportieren (für Kindprozesse verfügbar).

```bash
set -x EDITOR vim
```

`set -U <var> <value>` — Eine Universal Variable setzen (bleibt über Sitzungen und Neustarts erhalten).

```bash
set -U fish_greeting 'Welcome back!'
```

`set -e <var>` — Eine Variable löschen (unset).

```bash
set -e TEMP_VAR
```

`set -S <var>` — Ausführliche Infos zu einer Variable anzeigen (Scope, Export-Status).

```bash
set -S PATH
```

`set -l <var> <value>` — Eine lokale Variable setzen (nur im aktuellen Block).

```bash
set -l tmp_file /tmp/output.txt
```

`fish_add_path <dir>` — Ein Verzeichnis dauerhaft zum PATH hinzufügen (universal).

```bash
fish_add_path ~/.local/bin
```

## Abbreviations & Aliase

`abbr -a <name> <expansion>` — Eine Abbreviation anlegen (expandiert beim Tippen inline).

```bash
abbr -a gco 'git checkout'
```

`abbr -a --position command <name> <expansion>` — Abbreviation anlegen, die nur in Kommando-Position greift.

```bash
abbr -a --position command l 'ls -la'
```

`abbr -e <name>` — Eine Abbreviation löschen.

```bash
abbr -e gco
```

`abbr -l` — Alle Abbreviation-Namen auflisten.

```bash
abbr -l
```

`abbr --show` — Alle Abbreviations samt ihrer Expansionen anzeigen.

```bash
abbr --show
```

`alias <name> '<command>'` — Einen Funktions-Alias anlegen (Wrapper um eine Funktion).

```bash
alias ll 'ls -la'
```

`funcsave <name>` — Eine Funktion/einen Alias dauerhaft auf die Platte speichern.

```bash
funcsave ll
```

## Funktionen

`function <name>; ...; end` — Eine Funktion definieren.

```bash
function greet; echo "Hello, $argv[1]"; end
```

`function <name> -a <args>; ...; end` — Eine Funktion mit benannten Argumenten definieren.

```bash
function greet -a name; echo "Hello, $name"; end
```

`function <name> -d '<desc>'` — Eine Funktion mit Beschreibung definieren.

```bash
function serve -d 'Start dev server'; python3 -m http.server; end
```

`functions <name>` — Die Definition einer Funktion anzeigen.

```bash
functions greet
```

`functions -e <name>` — Eine Funktion löschen.

```bash
functions -e greet
```

`funcsave <name>` — Funktion nach ~/.config/fish/functions/<name>.fish speichern.

```bash
funcsave greet
```

`functions -n` — Alle definierten Funktionsnamen auflisten.

```bash
functions -n
```

## Kontrollfluss

`if <condition>; ...; else; ...; end` — Bedingte Ausführung.

```bash
if test -f config.yaml; echo 'Found'; else; echo 'Missing'; end
```

`switch <value>; case <pattern>; ...; end` — Mustervergleich (wie case/switch).

```bash
switch $os; case Linux; echo 'Linux'; case Darwin; echo 'Mac'; end
```

`for <var> in <list>; ...; end` — Über eine Liste von Werten iterieren.

```bash
for f in *.txt; echo $f; end
```

`while <condition>; ...; end` — Schleife, solange eine Bedingung wahr ist.

```bash
while test $count -lt 10; set count (math $count + 1); end
```

`begin; ...; end` — Kommandos in einem Block gruppieren (für Umleitung oder Scoping).

```bash
begin; echo stdout; echo stderr >&2; end 2>/dev/null
```

`and <command>` — Kommando nur ausführen, wenn das vorige erfolgreich war.

```bash
make build; and make test
```

`or <command>` — Kommando nur ausführen, wenn das vorige fehlschlug.

```bash
test -f .env; or echo '.env not found'
```

## Strings & Mathematik

`string match '<pattern>' <string>` — Strings gegen ein Glob- oder Regex-Muster matchen.

```bash
string match '*.txt' readme.txt
```

`string replace '<old>' '<new>' <string>` — Erstes Vorkommen in einem String ersetzen.

```bash
string replace 'foo' 'bar' 'foobar'
```

`string split '<sep>' <string>` — Einen String an einem Trennzeichen aufteilen.

```bash
string split ',' 'a,b,c'
```

`string trim <string>` — Führende und nachfolgende Leerzeichen entfernen.

```bash
string trim '  hello  '
```

`string length <string>` — Die Länge eines Strings zurückgeben.

```bash
string length 'hello'
```

`string sub -s <start> -l <len> <string>` — Einen Teilstring extrahieren.

```bash
string sub -s 1 -l 5 'Hello World'
```

`math '<expression>'` — Einen mathematischen Ausdruck auswerten.

```bash
math '2 ^ 10'
```

## Vervollständigung & History

`complete -c <cmd> -s <short> -l <long> -d '<desc>'` — Eine Tab-Vervollständigung für ein Kommando hinzufügen.

```bash
complete -c myapp -s v -l verbose -d 'Enable verbose output'
```

`complete -c <cmd> -a '<args>'` — Argument-Vervollständigungen für ein Kommando hinzufügen.

```bash
complete -c myapp -a 'start stop restart'
```

`history search <term>` — Die Kommando-History durchsuchen.

```bash
history search git
```

`history delete --exact '<cmd>'` — Einen bestimmten Eintrag aus der History löschen.

```bash
history delete --exact 'rm -rf /tmp/test'
```

`history clear` — Die gesamte Kommando-History löschen.

```bash
history clear
```

`history merge` — History aus anderen Fish-Sitzungen zusammenführen.

```bash
history merge
```

<!-- PROSE:outro -->
## Fazit

fish nimmt dir viel Tipparbeit ab: Autosuggestions, Syntax-Highlighting und Vervollständigungen stehen ohne jede Einrichtung bereit, und mit `set -U`, `funcsave` und `fish_config` baust du dir dauerhaft deine eigene Umgebung. Der wichtigste Stolperstein bleibt die nicht-POSIX-kompatible Syntax: Snippets aus bash/zsh oder von Stack Overflow laufen oft nicht unverändert – `export`, `&&`/`||` und Command-Substitution musst du auf `set -x`, `and`/`or` und fish-Klammern `(…)` übersetzen. Für portable Skripte, die überall laufen müssen, bleibt eine `#!/bin/sh`-Shebang die sichere Wahl; als komfortable interaktive Alltags-Shell spielt fish dagegen seine Stärken voll aus.

## Weiterführende Links

- [ubuntuusers-Wiki: Fish](https://wiki.ubuntuusers.de/Fish/) – deutschsprachige Einführung in Installation und Nutzung der fish-Shell
- [fish – offizielle Dokumentation](https://fishshell.com/docs/current/) – vollständige Referenz und Tutorial (englisch)
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [bash](https://www.jpkc.com/db/cheatsheets/shell-system/bash/) – die weit verbreitete POSIX-Shell und Standard auf den meisten Linux-Systemen
- [zsh](https://www.jpkc.com/db/cheatsheets/shell-system/zsh/) – mächtige POSIX-kompatible Shell mit umfangreichen Erweiterungen
- [env](https://www.jpkc.com/db/cheatsheets/shell-system/env/) – Umgebungsvariablen anzeigen und Kommandos in angepasster Umgebung starten