add functions, positional parameters, case and read
- functions: name() { ...; }, function name { ...; }, return, local,
unset -f; in pipes, & and $(...) they run in a subshell that gets all
function definitions and the positional parameters
- positional parameters $0, $1 ... ${10}, $#, "$@", "$*", $$; set by
gosh script args, gosh -c command name args, function calls,
source file args and set --; shift; for x without "in"
- case word in pattern|pattern) ...;; esac and { list; } groups
- read [-r] [-p prompt] [name ...] with $IFS splitting and $REPLY
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Florian WaltherandClaude Opus 5.5 committed
1 parent
9fe8b06fba
commit
443367f66f
9 files changed
+1629
-98
No files matched your search
@@ -11,9 +11,10 @@ Built-in commands:
|
||||
exit [code] - Exit shell with status code (default: $?)
|
||||
quit [code] - Quit shell with status code (default: $?)
|
||||
set VAR=val - Set environment variable
|
||||
set -- args - Set the positional parameters $1, $2, ...
|
||||
export VAR=val - Export environment variable
|
||||
unset VAR - Remove a variable
|
||||
source file - Run the commands of file in this shell (also: . file)
|
||||
unset VAR - Remove a variable (unset -f name: a function)
|
||||
source file [args] - Run the commands of file in this shell (also: . file)
|
||||
jobs - List background and stopped jobs
|
||||
fg [%n] - Continue job n (default: current job) in the foreground
|
||||
bg [%n] - Continue stopped job n in the background
|
||||
@@ -23,6 +24,12 @@ Built-in commands:
|
||||
: - Do nothing (exit status 0)
|
||||
break [n] - Leave the innermost (or n-th) for/while/until loop
|
||||
continue [n] - Continue with the next iteration of a loop
|
||||
return [n] - Leave a function or sourced file with status n
|
||||
local VAR[=val] - Variable that gets its old value back when the
|
||||
function returns
|
||||
shift [n] - Remove the first n positional parameters (default 1)
|
||||
read [-r] [-p prompt] [VAR ...] - Read a line into variables (split
|
||||
at $IFS; the last one gets the rest; default $REPLY)
|
||||
help - Show this help
|
||||
|
||||
Features:
|
||||
@@ -50,6 +57,9 @@ Features:
|
||||
a pattern
|
||||
- Environment variable expansion ($VAR, ${VAR}, ${VAR:-default});
|
||||
using an unset variable is an error, use ${VAR:-} for an empty default
|
||||
- Positional parameters: $0, $1 ... $9, ${10}, $# (count), "$@" (one
|
||||
word each), "$*" (one word), $$ (process ID); set by gosh script
|
||||
args, gosh -c command name args, functions, set -- and source
|
||||
- Command substitution: $(command) is replaced by the output of command
|
||||
(run in a subshell); unquoted it is split into words, "$(command)"
|
||||
stays one word
|
||||
@@ -57,7 +67,10 @@ Features:
|
||||
a || b (b only if a failed); $? is the exit status of the last command
|
||||
- Control structures: if cmd; then ...; elif cmd; then ...; else ...; fi,
|
||||
for x in words; do ...; done, while cmd; do ...; done, until ...,
|
||||
case word in pattern|pattern) ...;; esac, { cmd; cmd; } groups;
|
||||
! cmd negates the status; they can span several lines (prompt "> ")
|
||||
- Functions: name() { ...; } (or function name { ...; }); the arguments
|
||||
are $1, $2, ...; in pipes, & and $(...) they run in a subshell
|
||||
- Pipes (a | b) and redirections: < file, > file, >> file, 2> file,
|
||||
2>> file, 2>&1, >&2, &> file (stdout and stderr), &>> file
|
||||
- Job control: command & runs in the background, Ctrl+Z stops the
|
||||
@@ -75,8 +88,8 @@ Features:
|
||||
### Aufruf
|
||||
|
||||
```
|
||||
gosh [-l] [-i] [--norc] [--noprofile] [script]
|
||||
gosh [-l] [--noprofile] -c command
|
||||
gosh [-l] [-i] [--norc] [--noprofile] [script [args ...]]
|
||||
gosh [-l] [--noprofile] -c command [name [args ...]]
|
||||
gosh -version
|
||||
```
|
||||
|
||||
@@ -84,7 +97,8 @@ gosh -version
|
||||
|------------------------|------------------------------------------------------------------|
|
||||
| `gosh` | interaktive Shell (wenn stdin ein Terminal ist) |
|
||||
| `gosh -c 'befehl'` | führt den Befehl aus und beendet sich |
|
||||
| `gosh skript.gosh` | führt das Skript Zeile für Zeile aus |
|
||||
| `gosh -c 'befehl' name a b` | wie oben, mit `$0` = `name`, `$1` = `a`, `$2` = `b` |
|
||||
| `gosh skript.gosh a b` | führt das Skript Zeile für Zeile aus, `$1` = `a`, `$2` = `b` |
|
||||
| `befehle \| gosh` | liest die Befehle von stdin |
|
||||
| `-i` | erzwingt den interaktiven Modus, auch ohne Terminal |
|
||||
| `-l`, `--login` | Login-Shell, liest die Profil-Dateien (siehe unten) |
|
||||
@@ -137,7 +151,7 @@ export PATH=$HOME/bin:$PATH
|
||||
|
||||
### Kontrollstrukturen
|
||||
|
||||
gosh kennt `if`, `for`, `while` und `until` wie `sh`, auf einer Zeile oder über mehrere Zeilen:
|
||||
gosh kennt `if`, `for`, `while`, `until`, `case` und `{ …; }` wie `sh`, auf einer Zeile oder über mehrere Zeilen:
|
||||
|
||||
```bash
|
||||
if [ -f ~/.goshrc ]; then
|
||||
@@ -161,6 +175,15 @@ while [ $n -gt 0 ]; do
|
||||
done
|
||||
|
||||
until ping -c1 -W1 server >/dev/null; do sleep 1; done
|
||||
|
||||
case "$1" in
|
||||
start|run) echo "starte" ;;
|
||||
stop) echo "stoppe" ;;
|
||||
*.tar.gz) tar xzf "$1" ;;
|
||||
*) echo "unbekannt: $1" ;;
|
||||
esac
|
||||
|
||||
test -d build || { echo "kein build-Verzeichnis"; exit 1; }
|
||||
```
|
||||
|
||||
| Konstrukt | Bedeutung |
|
||||
@@ -169,17 +192,110 @@ until ping -c1 -W1 server >/dev/null; do sleep 1; done
|
||||
| `for x in wörter; do …; done` | setzt `x` nacheinander auf jedes Wort |
|
||||
| `while befehl; do …; done` | wiederholt, solange `befehl` erfolgreich ist |
|
||||
| `until befehl; do …; done` | wiederholt, bis `befehl` erfolgreich ist |
|
||||
| `case wort in muster\|muster) …;; esac` | führt den ersten Zweig aus, dessen Muster auf `wort` passt |
|
||||
| `{ befehl; befehl; }` | fasst Befehle zusammen (z. B. nach `\|\|`) |
|
||||
| `! befehl` | kehrt den Exit-Status um |
|
||||
| `break [n]`, `continue [n]` | verlässt die (n-te) Schleife bzw. springt zum nächsten Durchlauf |
|
||||
| `:` | tut nichts, Exit-Status 0 (z. B. `while :; do …; done`) |
|
||||
|
||||
- Bedingungen sind normale Befehle (auch Listen mit `&&`/`||`), meist `test` bzw. `[ … ]` (z. B. `[ -f datei ]`, `[ "$a" = b ]`, `[ $n -lt 3 ]`).
|
||||
- Die Wörter nach `for … in` werden wie Argumente expandiert: `*.go`, `{1..10}`, `$VAR`, `$(befehl)`. Ohne `in` läuft die Schleife nicht (Positionsparameter gibt es nicht).
|
||||
- Die Wörter nach `for … in` werden wie Argumente expandiert: `*.go`, `{1..10}`, `$VAR`, `$(befehl)`, `"$@"`. Ohne `in` läuft die Schleife über die Positionsparameter (`for a; do …` ist `for a in "$@"; do …`).
|
||||
- `case`: Die Muster sind Wildcards wie bei Dateinamen (`*`, `?`, `[…]`), nur passen `*` und `?` hier auch auf `/`. Mehrere Muster werden mit `|` getrennt, das `(` vor dem Muster ist optional, das `;;` im letzten Zweig auch. Zeichen in Anführungszeichen passen nur wörtlich (`"*")` passt nur auf `*`). Wie überall in gosh sind Werte von Variablen keine Muster: Nach `p='*.go'` passt `$p)` nur auf den Text `*.go`. Passt kein Muster, ist der Status 0.
|
||||
- `{ …; }`: `{` und `}` sind nur am Anfang eines Befehls Schlüsselwörter, vor dem `}` muss deshalb ein `;` oder ein Zeilenumbruch stehen. Die Befehle laufen in der Shell selbst (keine Subshell).
|
||||
- Variablen, `$(...)` und Wildcards im Rumpf werden bei jedem Durchlauf neu ersetzt.
|
||||
- Ist ein Befehl noch nicht vollständig (z. B. nach `if …; then` oder `for …` + Enter, nach `&&`, `|` oder einem `\` am Zeilenende), zeigt gosh den Fortsetzungs-Prompt `> `; Ctrl+C verwirft die angefangene Eingabe. Skripte und Startdateien lesen entsprechend weiter.
|
||||
- Ctrl+C bricht die ganze Befehlszeile ab, also auch eine Schleife (`while true; do sleep 1; done`).
|
||||
- Der Exit-Status ist der des zuletzt ausgeführten Befehls; ein `if` ohne passenden Zweig und eine Schleife ohne Durchlauf haben den Status 0.
|
||||
- Nicht unterstützt: Kontrollstrukturen in Pipes (`for …; done | sort`), mit Umleitung (`done > datei`) oder im Hintergrund (`done &`), außerdem `case`, Funktionen und `read`. Arithmetik geht z. B. mit `n=$(expr $n + 1)`.
|
||||
- Nicht unterstützt: Kontrollstrukturen in Pipes (`for …; done | sort`, `… | while read line`), mit Umleitung (`done > datei`, `done < datei`) oder im Hintergrund (`done &`), außerdem `( … )`-Subshells. Funktionen lassen sich dagegen in Pipes und mit Umleitungen verwenden (siehe unten), damit lässt sich das oft umgehen. Arithmetik geht z. B. mit `n=$(expr $n + 1)`.
|
||||
|
||||
### Funktionen
|
||||
|
||||
```bash
|
||||
# Definition (auch: function gruss { … })
|
||||
gruss() {
|
||||
local name=${1:-Welt} # local: nur in der Funktion
|
||||
echo "Hallo $name"
|
||||
}
|
||||
|
||||
gruss # Hallo Welt
|
||||
gruss Flo # Hallo Flo
|
||||
gruss Flo > datei # Umleitungen gelten für alle Befehle der Funktion
|
||||
gruss Flo | tr a-z A-Z # auch in Pipes
|
||||
x=$(gruss Flo)
|
||||
|
||||
ist_root() {
|
||||
[ "$(id -u)" = 0 ] && return 0
|
||||
return 1
|
||||
}
|
||||
ist_root || echo "kein root"
|
||||
|
||||
# Zeilen einer Datei verarbeiten: die Funktion liest von stdin
|
||||
zeilen() {
|
||||
while read -r zeile; do echo "> $zeile"; done
|
||||
}
|
||||
zeilen < /etc/hostname
|
||||
```
|
||||
|
||||
- Eine Funktion wird mit `name() { …; }`, `name () { …; }` oder `function name { …; }` definiert. Der Rumpf ist ein zusammengesetzter Befehl, meist `{ …; }`, aber auch `if`, `for`, `while` oder `case` sind möglich. Die Definition darf über mehrere Zeilen gehen.
|
||||
- Die Argumente des Aufrufs sind in der Funktion `$1`, `$2`, …, `$#` und `"$@"`; danach haben die Positionsparameter wieder ihre alten Werte. `$0` bleibt der Name des Skripts.
|
||||
- `return [n]` beendet die Funktion mit dem Status `n` (ohne `n`: der Status des letzten Befehls). Ohne `return` ist der Status der des letzten Befehls.
|
||||
- Funktionen laufen in der Shell selbst: Variablen, die sie setzen, und `cd` gelten danach weiter. `local name[=wert]` macht eine Variable lokal, sie bekommt beim Verlassen der Funktion ihren alten Wert zurück (Funktionen, die von dort aufgerufen werden, sehen den lokalen Wert).
|
||||
- `name=wert funktion` setzt die Variable nur während des Aufrufs.
|
||||
- In einer Pipeline, im Hintergrund (`funktion &`) und in `$(...)` läuft eine Funktion in einer Subshell, Änderungen an Variablen gehen dort also verloren (wie in `sh`). Die Subshell kennt alle Funktionen.
|
||||
- Eine Funktion hat Vorrang vor Built-ins und Programmen gleichen Namens. Weil es noch kein `command` gibt, kann eine Funktion `ls` das Programm `ls` aber nicht aufrufen. Mit `\ls` umgeht man nur Aliase. Besser ist ein anderer Name, z. B. `ll() { ls -l "$@"; }`.
|
||||
- `unset -f name` entfernt eine Funktion. Rekursion ist erlaubt, aber nur bis zu einer Tiefe von 1000.
|
||||
- Namen dürfen aus Buchstaben, Ziffern, `_`, `-` und `.` bestehen (nicht mit einer Ziffer oder `-` beginnend). Funktionen werden auch mit Tab vervollständigt.
|
||||
|
||||
### Positionsparameter
|
||||
|
||||
| Parameter | Bedeutung |
|
||||
|--------------------|------------------------------------------------------------------|
|
||||
| `$0` | Name des Skripts (bzw. `name` bei `gosh -c befehl name`) |
|
||||
| `$1` … `$9`, `${10}` | die Argumente |
|
||||
| `$#` | Anzahl der Argumente |
|
||||
| `"$@"` | alle Argumente, jedes als eigenes Wort |
|
||||
| `"$*"` | alle Argumente als ein Wort, durch Leerzeichen getrennt |
|
||||
| `$$` | Prozess-ID der Shell |
|
||||
|
||||
```bash
|
||||
#!/usr/bin/gosh
|
||||
# aufruf: skript.gosh [-v] datei ...
|
||||
if [ $# -eq 0 ]; then
|
||||
echo "usage: $0 [-v] datei ..." >&2
|
||||
exit 2
|
||||
fi
|
||||
verbose=no
|
||||
case $1 in
|
||||
-v) verbose=yes; shift ;;
|
||||
esac
|
||||
for f in "$@"; do
|
||||
test $verbose = yes && echo "verarbeite $f"
|
||||
wc -l "$f"
|
||||
done
|
||||
```
|
||||
|
||||
- Gesetzt werden sie von `gosh skript a b`, `gosh -c befehl name a b`, beim Aufruf einer Funktion, mit `source datei a b` (nur während die Datei läuft) und mit `set -- a b c`.
|
||||
- `shift [n]` entfernt die ersten `n` (Standard: 1) Parameter, `$2` wird zu `$1` usw.
|
||||
- Wie bei Variablen ist ein nicht gesetzter Parameter ein Fehler: `$1` ohne Argumente meldet `1: unbound variable`. Für optionale Argumente `${1:-}` bzw. `${1:-standard}` verwenden oder vorher `$#` prüfen.
|
||||
- `"$@"` ohne Argumente ergibt kein Wort (auch nicht das leere). Ohne Anführungszeichen verhalten sich `$@` und `$*` wie `"$@"`, da gosh Werte nie an Leerzeichen teilt.
|
||||
|
||||
### read
|
||||
|
||||
`read` liest eine Zeile von stdin und verteilt sie auf Variablen:
|
||||
|
||||
```bash
|
||||
read -p "Name? " name # Eingabe vom Terminal mit Prompt
|
||||
read vorname nachname < name.txt # erste Zeile einer Datei
|
||||
read -r zeile # Backslashes nicht auswerten
|
||||
while read -r zeile; do echo "$zeile"; done # in einem Skript: alle Zeilen von stdin
|
||||
```
|
||||
|
||||
- `read name1 name2 …` teilt die Zeile an den Zeichen von `$IFS` (Standard: Leerzeichen, Tab, Zeilenumbruch). Jede Variable bekommt ein Feld, die letzte den Rest der Zeile. Bei zu wenigen Feldern werden die übrigen Variablen leer. Leerzeichen am Anfang und Ende werden entfernt. Andere `IFS`-Zeichen trennen genau ein Feld (`IFS=:` macht aus `a::b` die Felder `a`, ``, `b`).
|
||||
- Ohne Namen landet die ganze Zeile unverändert in `$REPLY`.
|
||||
- Ohne `-r` maskiert `\` das nächste Zeichen (`a\ b` bleibt ein Feld), und ein `\` am Zeilenende setzt die Zeile fort. `-p prompt` gibt den Prompt auf stderr aus, wenn stdin ein Terminal ist.
|
||||
- Der Status ist 0, oder 1 am Ende der Eingabe (die Variablen werden trotzdem mit dem Rest gesetzt). So endet `while read …` nach der letzten Zeile.
|
||||
- `read` liest Byte für Byte und damit nie mehr als eine Zeile, den Rest bekommen die nächsten Befehle. Ctrl+C bricht `read` in der interaktiven Shell ab (Status 130).
|
||||
- `read` verändert die Shell und lässt sich deshalb nicht in einer Pipeline verwenden (`echo a | read x`, in `sh` wirkungslos). Umleitungen funktionieren: `read x < datei`.
|
||||
|
||||
### Variablen
|
||||
|
||||
@@ -215,7 +331,7 @@ $ vim $(grep -l TODO *.go)
|
||||
$ echo "Dateien: $(ls | wc -l)"
|
||||
```
|
||||
|
||||
- Der Befehl läuft in einer eigenen Subshell (einem neuen gosh-Prozess): `cd`, `set` oder `export` darin ändern die laufende Shell nicht. Er darf alles enthalten, was gosh kann (Pipes, `;`, `&&`, Umleitungen, verschachtelte `$(...)`), und liest von der gleichen Eingabe, Fehlermeldungen gehen auf stderr.
|
||||
- Der Befehl läuft in einer eigenen Subshell (einem neuen gosh-Prozess): `cd`, `set` oder `export` darin ändern die laufende Shell nicht. Die Subshell kennt die Funktionen und Positionsparameter der Shell. Er darf alles enthalten, was gosh kann (Pipes, `;`, `&&`, Umleitungen, verschachtelte `$(...)`), und liest von der gleichen Eingabe, Fehlermeldungen gehen auf stderr.
|
||||
- Abschließende Zeilenumbrüche der Ausgabe werden entfernt.
|
||||
- Ohne Anführungszeichen wird die Ausgabe an Leerzeichen, Tabs und Zeilenumbrüchen in mehrere Wörter geteilt, `"$(befehl)"` bleibt ein einziges Wort (mit den Zeilenumbrüchen darin).
|
||||
- Anders als in `sh` werden Wildcards in der Ausgabe nicht expandiert, und Zeichen wie `;` oder `|` darin sind normaler Text: Die Ausgabe ist immer nur Daten.
|
||||
|
||||
Reference in new issue
Block a user