Kommando-Referenz

Die GNU Coreutils stellen – gemeinsam mit den fest in Dash und Bash eingebauten Kommandos – die im POSIX-Standard festgelegte Benutzerschnittstelle zur Verfügung. Für Operanden gelten folgende Konventionen:

Dir: Verzeichnispfad
Path: Datei- oder Verzeichnispfad
File: Dateipfad oder Standardeingabe

Dateien verwalten

Seine Dateien in der baumartigen Struktur des Dateisystems zu organisieren gehört zu den grundlegenden Aufgaben eines Benutzers.

Kommando	Operanden		Beschreibung
man	[`Section`]	`Command`	Handbuch zu einem Kommando im Pager anzeigen
Verzeichnisse
ls	[`Path`]		Dateien im (aktuellen) Verzeichnis auflisten
cd	[`Dir`]		Arbeitsverzeichnis wechseln
pwd			Arbeitsverzeichnis ausgeben
mkdir	`Dir`		Neues Unterverzeichnis anlegen
rmdir	`Dir`		Leeres Unterverzeichnis löschen
pathchk	`Path`		Gültigkeit eines Pfades prüfen
basename	`Path`		Vorne den Verzeichnispfad abschneiden
dirname	`Path`		Hinten den Dateinamen abschneiden
du	[`Dir`]		Speicherverbrauch ermitteln
df	[`Dir`]		Füllstand des Dateisystems anzeigen
find	`Dir`	tests	Dateien rekursiv suchen
Dateien
file	`Path`		Dateityp ermitteln
touch	`Path`		Datei anlegen; Änderungszeit setzen
mv	`Path`	`Dir`	Datei umbenennen oder verschieben
cp	`Path`	`Dir`	Datei in anderes Verzeichnis kopieren
dd	if=`In`	of=`Out`	Datei blockweise duplizieren
ln	`Path`	[`Name`]	(Symbolische) Verknüpfung auf Datei setzen
link	`Path`	[`Name`]	Harte Verknüpfung auf Datei setzen
unlink	`Path`		Harte Verknüpfung auf Datei löschen
rm	`Path`		Harte Verknüpfung auf Datei löschen
chmod	`Mode`	`Path`	Zugriffsrechte ändern
chown	`User`	`Path`	Besitzer einer Datei ändern
chgrp	`Group`	`Path`	Gruppe einer Datei ändern
mkfifo	`Path`		FIFO-Datei erzeugen
cmp	`Path`	`Path`	Dateien byteweise vergleichen
Archive
cksum	`File`		CRC-Prüfsumme berechnen
split	`File`		Datei in Häppchen zerlegen
compress	`File`		Datei mit dem LZW-Algorithmus komprimieren
uncompress	`File`		Komprimierte Datei entpacken
cpio			Liste von Dateien archivieren
tar	`File`		Dateien in Bandarchiv packen
pax	`File`		Portable Archive verwalten
zcat	`File`		Komprimierte Datei ausgeben

Texte verarbeiten

Editor
Kommando	Operanden		Beschreibung
ed	`File`		Im obskuren zeilenbasierten Editor öffnen
ex	`File`		Im uralten zeilenbasierter Editor öffnen
vi	`File`		Im visuellen Editor öffnen, beenden mit `Esc`-`:q!`
Anzeige
cat	`File`		Datei auf die Standardausgabe senden
head	`File`		Die ersten 10 Zeilen ausgeben
tail	`File`		Die letzten 10 Zeilen ausgeben
lp	`File`		Datei an den Drucker senden
more	`File`		Datei seitenweise anzeigen, beenden mit `q`
less	`File`		Datei im Pager anzeigen, beenden mit `q`
Formatierung
fold	`File`		Lange Zeilen nach 80 Zeichen umbrechen
pr	`File`		Textdatei auf 72 Spalte und 66 Zeilen paginieren
nl	`File`		Zeilen nummerieren
wc	`File`		Wörter (oder Zeilen) zählen
od	`File`		Datei in Oktal- oder Hexadezimalddarstellung ausgeben
cut	`File`		Spalten ausschneiden
column	`File`		Daten als Tabelle formatieren
Sortierung
tsort	`File`		Adjazenzliste topologisch sortieren
sort	`File`		Zeilen alphabetisch sortieren
uniq	`File`		Doppelte Zeilen unterdrücken
comm	`File`	`File`	Disjunkte und gemeinsame Zeilen ausgeben
join	`File`	`File`	Zeilen über gemeinsames Feld verbinden
paste	`File`	`File` …	Zeilen aus Dateien nebeneinander ausgeben
csplit	`File`	`Pattern`	Textdatei am Muster spalten
Filter
grep	[`Regex`]	`File`	Nur Zeilen ausgeben, die auf das Muster passen
sed	[`Script`]	`File`	Datenstrom manipulieren
awk	[`Program`]	`File`	Musterverarbeitungprogramm anwenden
tr	`Set`	[`Set`]	Zeichen im Datenstrom ersetzen
asa	`File`		Zeichen für Wagenrücklauf interpretieren
expand	`File`		Tabulatoren in Leerzeichen umwandeln
unexpand	`File`		Führende Leerzeichen in Tabulatoren umwandeln
iconv	`File`		Zeichenkodierung umwandeln
Interpreter
bc	`File`		arithmetische Ausdrücke berechnen
m4	`File`		M4-Makros expandieren
sh	`File`		Skript in POSIX-konformer Shell ausführen

Sitzungen verwalten

Benutzer
Kommando	Operanden		Beschreibung
logname			Eigenen Benutzernamen ausgeben
id	[`User`]		Gruppen des Benutzers ausgeben
who	[`Password`]		Angemeldete Benutzer auflisten
su	`User`		Identität wechseln
newgrp	`Group`		Effektive Gruppe wechseln
mailx	`File`		Elektropost senden und empfangen
mesg	{y \| n}		Schreibzugriffe durch `talk`, `write` und `wall` verbieten
talk	`User`	[`Terminal`]	Chat mit anderem Anwender starten
write	`User`	[`Terminal`]	Nachricht auf Konsole eines Anwenders senden
wall	`Message`		Nachricht auf Konsole aller Anwender senden
logout			Login-Shell verlassen
Umgebung
env	[`Name`=`Value`]…	[`Command`]	Ruft Programm mit veränderter Umgebung aufrufen
alias	`Name`=`Command`		Kommando substituieren
unalias	`Name`		Substitution aufheben
umask	`Mode`		Zugriffsrechte für neue Dateien maskieren
ulimit	`Size`		Maximale Dateigröße beschränken
fc	`First`	`Last`	Kommandos aus der Chronik editieren
history			Kommando-Chronik ausgeben
shopt			Shell-Optionen setzen
System
uname			Name des Betriebssystems ausgeben
date			Datum und Uhrzeit ausgeben
locale	[`Name`]		Sprache und Zeichensatz ausgeben
localedef	`Path`		Lokalisierungsdatei kompilieren
getconf	`Name`		Systemkonfiguration ausgeben, z.B. `PAGESIZE`
logger	`Message`		Nachricht ins Systemprotokoll schreiben
cal	`Month`	`Year`	Kalenderblatt ausgeben
Terminal
tty			Gerätedatei des Terminals ausgeben
stty			Eigenschaften des Terminals anzeigen und ändern
tput	`Operand`		Terminal initialisieren
tabs	`List`		Tabulator-Positionen festlegen

Prozesse kontrollieren

Prozesse
Kommando	Operanden		Beschreibung
ps			Prozesse in der Sitzung auflisten
pstree	{`Pid` \| `Uid`}		Baumstruktur aller Prozessen ausgeben
top			Prozessliste zyklisch aktualisieren, Beenden mit `q`
kill	`Pid`		Prozess mit `SIGTERM` beenden
nice	`Command`		Programm mit geringer Priorität starten
renice	{`Pid \| Uid}`		Priorität ändern
nohup	`Command`		Programm vom Terminal entkoppelt starten
time	`Command`		Rechenzeit eines Programms messen
fuser	`Path`		Prozesse auflisten, welche die Datei geöffnet halten
sleep	`Seconds`		Einige Sekunden warten
xargs	`Command`		Argumentliste bauen und Kommando ausführen
Jobs
jobs			Laufende Jobs auflisten
bg	`Job`		Angehaltenen Job im Hintergrund fortsetzen
fg	`Job`		Hintergrund-Job in den Vordergrund holen
wait	[`Pid`]		Auf aktive Jobs warten
disown	[`Job`]		Aktiven Job von der Shell entkoppeln
crontab	[`Path`]		Konfiguration für zyklische Jobs bearbeiten
at	`Time`	`Command`	Job zu einer bestimmten Uhrzeit starten
Interprozesskommunikation
ipcs			Semaphore, Speichersegmente und Warteschlangen auflisten
ipcrm	`Id`		Semaphor, Speichersegment oder Warteschlange löschen
Stapelverarbeitung
batch	`Command`		Job in die Queue stellen und bei geringer Last starten
qselect			Jobs mit Kriterien auflisten
qsub	`Script`		Skript an den Server senden
qalter	`Job`		Job neu priorisieren
qdel	`Job`		Job aus der Quene entfernen
qhold	`Job`		Job in Wartestellung versetzen
qrls	`Job`		Job aus Wartestellung befreien
qrerun	`Job`		Job erneut ausführen
qmove	`Source`	`Dest`	Job in eine andere Queue verschieben
qmsg	`Message`	`Job`	Nachricht an Job senden
qsig	`Job`		Signal an den Hauptprozess senden
qstat	{`Job` \| `Dest`	\| `Server`}	Status ausgeben

Eingebaute Kommandos

Ein-/Ausgabe
Kommando	Operanden		Beschreibung
:			Nichts tun (Leeres Kommando)
help			Hilfe zu eingebauten Kommandos ausgeben
type	`Name`		Auskunft über die Art des Symbols geben
echo	`String`		Variablen expandieren und Zeile ausgeben
printf	`Format`	`Args`	Formatstring füllen und ausgeben
read	[`Name`]		Zeile am IFS trennen und in Variablen einlesen
tee	[`Path`]		Datenstrom in Datei und Konsole ausgeben
mapfile	`Name`		Datenstrom zeilenweise in Reihung einlesen
readarray	`Name`		Obsolet, verwende `mapfile`
Variablen
set	[`Value`]		Variablen auflisten oder Shell-Optionen setzen
unset	`Name`		Variablen aus der Umgebung entfernen
shift	[`Num`]		Positionsparameter um soviele Stellen verschieben
export	`Name`[=`Value`]		Variable an Subshells vererben
readonly	`Name`[=`Value`]		Variable als schreibgeschützt deklarieren
local	`Name`[=`Value`]		Sichtbarkeit einer Variablen einschränken
declare	`Name`[=`Value`]		Variable deklarieren
typeset			Obsolet, verwende `declare`
getopts	`OptString`	`Name` $@	Optionen in Positionsparametern parsen
Ausdrücke
let	`Expression`		Arithmetischen Ausdruck auswerten
expr	`Expression`		Ausdruck auswerten
test	`Expression`		Logischen Ausdruck auswerten
[	`Expression`	]	Logischen Ausdruck auswerten
true			Immer Rückgabewert 1 liefern
false			Immer Rückgabewert 0 liefern
Ausführen
.	`Path`	[`Args`]	Skript in der aktuellen Shell ausführen
source	`Path`	[`Args`]	Skript in der aktuellen Shell ausführen
eval	`String`	…	Text als Kommando auswerten.
exec	`Command`	[`Args`]	Shell durch ein anderes Programm ersetzen
trap	`Command`	`Signal`	Kommando ausführen wenn Signal eintrifft
times			Zeitverbrauch aller Prozesse ausgeben.
hash	[`Command`]		Pfade auflisten oder Pfad merken
command	`Command`	[`Args`]	Kommando statt Funktion ausführen
builtin	`Command`	[`Args`]	Das eingebaute Kommando ausführen
enable	`Command`		Eingebaute Kommandos (de/re-)aktivieren
caller	`Expression`		Zeile und Pfad des aufrufenden Skripts ausgeben
exit	[`ExitCode`]		Aktuelle Shell beenden
Readline
bind	[`Command`]		Readline-Kommandos auflisten oder zuordnen
compgen	[`Word`]		Mögliche Vervollständigungen auflisten
compopt	[`Name`]		Optionen für die Vervollständigungs ändern
complete	[`Name`]	…	Strategie für Vervollständigung festlegen
dirs			Gemerkte Pfade auflisten
pushd	`Path`		Pfad wechseln und links einfügen
popd			Pfad wechseln und entfernen

Programme entwickeln

Übersetzer
Kommando	Operanden		Beschreibung
fort77	`File`.f		FORTRAN-Programm übersetzen
c99	`File`.c		C-Programm übersetzen
ctags	`File`.c		Index erstellen
cflow	`File`.c		Aufrufgraph erstellen
cxref	`File`.c		Kreuzreferenz erstellen
lex	`File`.l		Code für Scanner einer Syntax erzeugen
yacc	`File`.y		Code für Parser einer Grammatik erzeugen
make	[`Target`]		Build anstoßen
diff	`Old`.c	`New`.c	Patch erzeugen
patch	[`Old`.c]	`Patch`	Patch einspielen
gencat	`File`.cat	`File`.msg	Katalog mit Nachrichten erstellen
Binaries
ar [`Pos`]	`File`.a	`File`.o	Objekt im Archiv verändern
nm	`Prog`		Symbole im Archiv auflisten
strings	`Prog`		Zeichenketten aus Binärdatei extrahieren
strip	`Prog`		Debug-Symbole aus Programm entfernen
as	`File`.s		Assembler-Code in Objekt assemblieren
size	`Prog`.a		Segmentgrößen eines Objekts ausgeben
readelf	`Prog`		Kopf und Segmente eines Programms ausgeben
elfedit	`Prog`		Kopf eines Programms aktualisieren
objcopy	`In`.a	`Out`.a	Symbole in eine anderes Objekt kopieren
gdb	`Prog`	[`Pid`\|`Core`]	Programm im Debugger untersuchen
gprof	`Prog`	gprof.out	Profil aus Aufrufgraph erzeugen
SCCS Versionsverwaltung
sccs	`Subcmd`	`Operands`	Eines der folgenden Kommandos ausführen
admin	`File`		Verwaltungsdatei anlegen
sact	`Dir`		Status ausgeben
prs	`Dir`		Version ausgeben
get	`Dir`		Version laden oder Delta erzeugen
unget	`Dir`		Aktuelle Version laden
delta	`Dir`		Delta einspielen
rmdel	`Dir`		Delta entfernen
val	`Dir`		Datei validieren
what	`Dir`		Datei identifizieren
Unix-to-Unix
uucp	`File`	`Dest`	Datei auf einen anderen Rechner übertragen
uuencode	[`File`]	`Dir`	Binärdatei kodieren und Zielpfad setzen
uudecode	[`File`]		Binärdatei dekodieren und im Zielpfad speichern
uustat	`File`		Verbindungen mit anderen Rechnern auflisten
uux	`Command`		Befehl auf anderem Rechner ausführen

Benutzer	Gruppe	Alle
u	g	o
r	w	x	r	w	x	r	w	x
400	200	100	40	20	10	4	2	1
4000 = setuid	2000 = setgid	1000 = sticky

Ausgabe
-l	Lange Ausgabe
-n	Lange Ausgabe, Besitzer und Gruppe numerisch ausgeben
-o	Lange Ausgabe, nur den Besitzer ausgeben
-g	Lange Ausgabe, nur die Gruppe ausgeben
-a	Versteckte Dateien ausgeben
-A	Versteckte Dateien (außer `.` und `..`) ausgeben
-d	Verzeichnis ohne Inhalt ausgeben
-1	Eine Zeile pro Datei ausgeben
-m	Einträge als kommaseparierte Liste in einer Zeile ausgeben
-p	Verzeichnisse mit `/` markieren
-q	Nicht-druckbare Zeichen als `?` ausgeben
Sortierung
-S	Absteigend nach Größe sortieren
-c	Absteigend nach Erzeugungszeit sortieren
-t	Absteigend nach Änderungszeit sortieren
-u	Absteigend nach Zugriffszeit sortieren
-x	Spalten horizontal sortieren
-C	Spalten vertikal sortieren
-r	Sortierung umkehren
-f	Sortierung und Farbe deaktivieren
Größe
-i	Indexnummer (Inode) ausgeben
-s	Anzahl der belegten Blöcke ausgeben
-k	Kilobyte als Blockgröße verwenden
Traversierung
-R	Rekursiv alle Unterverzeichniss auflisten
-H	Symlinks in der Operandenliste folgen
-L	Symlinks immer folgen
-F	Symlinks nicht folgen; Spezialdateien markieren
Markierung
/	Verzeichnis
*	Ausführbare Datei
@	Symlink
\|	FIFO

-name Glob Der Name passt auf das Muster

-path Glob Dito, aber / und . nicht speziell behandeln

-nouser Der Besitzer existiert nicht

-nogroup Die Gruppe existiert nicht

-perm Mode Zugriffsrechte stimmen exakt überein

-perm -Mode Zugriffsrechte sind gesetzt

-type Type

Dateityp entspricht…

b	Blockgerät
c	Zeichenstromgerät
d	Verzeichnis
l	Symlink
p	FIFO
f	Datei
s	Socket

-links Num Anzahl Links

-user User Besitzer stimmt überein

-group Group Gruppe stimmt überein

-size Num[Unit]

Datei belegt soviele Speichereinheiten

c	Oktette	1
w	Wörter	2
b	Blöck	512
k	Kilobyte	1024
M	Megabyte	1.048.576
G	Gigabyte	1.073.741.824

-atime Days Zugriff vor mehr als … Tagen

-ctime Days Erzeugung vor mehr als … Tagen

-mtime Days Änderung vor mehr als … Tagen

-newer File Änderung vor der Referenzdatei

Aktion

-print Dateiname ausgeben (default)

-exec Command \; Kommando für jede Datei ausführen,

{} dienst als Platzhalter für den Pfad

-ok Command \; Kommando für jede Datei bestätigen

Modifikatoren
-o[aBcv]	Dateien in Archiv auf die Standardausgabe schreiben
-i[Bcdmrtuvf] [`Glob`]	Archiv von der Standardeingabe extrahieren
-p[adlmuv] `Dir`	Dateien in ein Verzeichnis kopieren
a	Zugriffszeit zurücksetzen
B	Blockfaktor 10 (5120 Oktette) festlegen
d	Verzeichnisse automatisch anlegen
c	Kompatibilitätsmodus für Header
r	Dateien interaktiv umbenennen
t	Nur ein Inhaltsverzeichnis schreiben
u	Unkonditional auch ältere Dateien kopieren
v	Verbosität erhöhen
l	Links anlegen statt Dateien zu kopieren
m	Änderungszeit neu setzen
f	Alle Dateien außer die im Muster kopieren

Benutzer
-H	Spaltenüberschriften
-s	Benutzername, (Pseudo-)Terminal und Anmeldzeit
-u	Idle-Zeit
-l	Login-Prozesse
-m	Terminal-Benutzer
-q	Benutzernamen und Anzahl Sitzungen
-T	Nachrichtenstatus jedes (Pseudo-)Terminals (`mesg`)
-a	Alles
Init
-r	Runlevel
-b	Zeitpunkt des Systemstart
-t	Letzte Änderung der Systemzeit
-d	Gestorbene Prozesse
-p	Laufende Prozesse

Maximum
-S	Weiches Limit setzen
-H	Hartes Limit setzen
-a	Alle Limits berichten
-b	Puffergröße für Sockets
-c	Corefiles
-d	Datensegment (DSS)
-e	Priorität für `nice`
-f	Dateigröße für Umleitungen
-i	Zugestellte Signale
-l	Gepinnter Arbeitsspeicher (Kilobyte)
-m	Belegter Arbeitsspeicher (RSS)
-n	Offene Dateien
-p	Puffer für Pipes
-q	Puffer für Warteschlangen
-r	Echtzeit-Priorität
-s	Stackgröße in Oktetten
-t	Rechenzeit in Sekunden
-u	Anzahl Benutzerprozesse
-v	Virtuelle Speichergröße
-x	Anzahl Dateisperren
-T	Anzahl Threads

Default
+`Format`	Ausgabe formatieren
%c	Lokales Datum und Zeit	`Mo 14 Sep 2015 17:18:23 CEST`
		`%a %d %b_ %Y__ %H:%M:%S %Z`
Datum
%x	Lokales Datum	`14.09.2015`
%D	Amerikanisch	`09/14/15`
%Y	Jahr	`2015`
%y	Jahr	`15`
%C	Jahrhundert	`20`
%m	Monat	`09`
%h	Monat	`Separator`
%b	Monat	`Separator`
%B	Monatsname	`September`
%a	Wochentag	`Mo`
%A	Wochentagname	`Montag`
%d	Tag des Monats	`14`
%e	Tag des Monats	`14`
Uhrzeit
%X	Lokale Uhrzeit	`17:18:23`
%T	Uhrzeit (24h)	`17:18:23`
%r	Uhrzeit (12h)	`05:18:23`
%H	Stunde (24h)	`17`
%I	Stunde (12h)	`05`
%M	Minute	`18`
%S	Sekunde	`23`
Index
%j	Tag im Jahr	`257`
%U	Woche im Jahr	`37`
%V	Woche im Jahr	`38`
%W	Woche im Jahr	`37`
%u	Wochentag	`1`
%w	Wochentag	`1`
%p	AM/PM
%Z	Zeitzone	`CEST`
Zeichen
%n	Zeilenumbruch
%t	Tabulator
%%	Prozentzeichen	`%`

Auswahl
-A		Alle
-e		Alle
-a		Alle mit einem Terminal
-d		Alle außer der Sitzungsleiter
-p `Pid`[,…]		Bestimmte Prozessnummern
-t `Term`[,…]		Bestimmte Terminals (TTY)
-u `User`[,…]		Effektiver Besitzer (UID)
-U `User`[,…]		Echter Besitzer
-g `Group`[,…]		Sitzung oder effektive Gruppe
-G `Group`[,…]		Echte Gruppe
Spalten
-l		Langes Format
-f		Viele Spalten
-F		Mehr Spalten
-n `Name`		`WCHAN` (statt `/boot/System.map`)
-o `Format`		Bestimmte Spalten
Spalten
F	-l	Flags
S	-l	Status (S=Sleeping, R=Running)
UID	-lfF	Besitzer
PID		Eigene Prozessnummer
PPID	-lfF	Prozessnummer des Elternprozesses
C	-lfF	Prozessorauslastung
PRI	-l	Priorität
NI	-l	Nettigkeit
ADDR	-l	Speicheradresse
SZ	-lF	Blockgröße im Speicher
WCHAN	-l	Ereignis, auf das der Prozess wartet
STIME	-fF	Startzeit
TTY		Terminal
TIME		Kumulative Rechenzeit
CMD	(-f)	Kommandoname, mit `-f` auch die Argumentliste

Signale
-l	Namen aller unterstützten Signale auflisten
-s `Signame`	Signal an Prozess senden
-`Signame`	Signal an Prozess senden
-`Signo`	Signal an Prozess senden
0	Lebendigkeit prüfen
1 = HUP	Terminal hat aufgelegt
2 = INT	Entspricht `Ctrl`-`C`
3 = QUIT	Entspricht `Ctrl`-`Q`
6 = ABRT	Prozess abwürgen
9 = KILL	Prozess töten
14 = ALRM	Zeitgeber
15 = TERM	Beenden

Zeitangaben
-l	Anstehende Jobs auflisten
-r	Job löschen
-m	Nachricht auch dann senden, wenn der Job nichts ausgegeben hat
-q `Character`	Job in eine bestimmte Queue hängen
-f `File`	Job aus Datei lesen
-t `Time`	Job zu einer bestimmte Uhrzeit starten
[HH:]MM [[[CCYY]-]MM-]DD]
midnight	Um 00:00
noon	Um 12:00
now	Sofort
Modifikatoren
today	Heute
tomorrow	Morgen um diese Zeit
next `Unit`	In der nächsten Einheit
+ `Count` `Unit`	In … Einheiten
Einheiten
minutes	Minuten
hours	Stunden
days	Tage
weeks	Wochen
months	Monate
years	Jahre

Spalten
-q	Warteschlangen auflisten
-m	Speichersegmente auflisten
-s	Semaphor-Sets auflisten
-a	Alle (`-bcopt`)
-b	Maximale Größe
-c	Besitzer und Gruppe
-o	Anzahl Nachrichten oder Prozesse
-p	PID des letzten Senders
-t	Zeitangaben

Escape-Sequenzen
-n	Escape-Sequenzen interpretieren
\a	Alarm
\b	Backspace
\c	Zeilenumbruch unterdrücken
\f	Form-Feed
\n	Zeilenumbruch
\r	Wagenrücklauf
\t	Tabulator
\v	Vertikaler Tabulator
\\	Backslash
\0[0…7][0…7][0…7]	Oktaler 8-Bit Wert

Escape-Sequenzen
\a	Alarm
\b	Backspace
\c	Zeilenumbruch unterdrücken
\f	Form-Feed
\n	Zeilenumbruch
\r	Wagenrücklauf
\t	Tabulator
\v	Vertikaler Tabulator
\\	Backslash
\0[0…7][0…7][0…7]	Oktaler 8-Bit Wert

Optionen
--		Weitere Operanden als Positionsparameter zuweisen
-o `Option`		Option einschalten
+o `Option`		Option ausschalten
-a	allexport	export-Flag bei allen neue und geänderte Variablen setzen
-b	notify	Job-Ende sofort berichten
-e	errexit	Shell sofort verlassen, wenn eine Kommando nicht 0 liefert
-f	noglob	Globbing ausschalten
-h	hashall	Pfad von Kommandos hashen
-k	keyword	Alle Zuweisungen in die Umgebung des Kommandos setzen
-m	monitor	Job-Kontrolle einschalten
-n	noexec	Kommandos lesen aber nicht ausführen
-p	privileged	Ein, wenn echte und effektive UID nicht übereinstimmen
-t	onecmd	Shell sofort nach dem ersten Kommando verlassen
-u	nounset	Expansion nicht definierter Variable als Fehler behandeln
-v	verbose	Eingabezeilen ausgeben
-x	xtrace	Kommandozeilen ausgeben
-B	braceexpand	Klammern expandieren
-C	noclobber	Existierende Dateien nie überschreiben
-E	errtrace	ERR Trap an Funktionen vererben
-H	histexpand	Chronik mit ! substituieren
-P	physical	Symlinks nie folgen
-T	functrace	DEBUG Trap an Funktionen vererben
	history	Chronik aktivieren
	ignoreeof	Shell bei EOF nicht verlassen
	interactive-comments	Kommentare in interaktiven Kommandos erlauben
	nolog	(ignoriert)
	pipefail	Status des letzten Fehlers
	posix	POSIX-konform verhalten
	emacs	Emacs-Modus (default)
	vi	Vi-Modus

Optionen
-p	Attribute und Werte auflisten
-f	Funktionsnamen und Definitionen auflisten
-F	Funktionsnamen mit Zeile und Datei ausgeben
-g	Globale Variable
Attribute
-a	Reihung
-A	Streutabelle
-i	Ganzzahl
-r	readonly setzen
-t	trace setzen
-x	export setzen
-l	Variablennamen in Kleinbuchstaben konvertieren
-u	Variablennamen in Großbuchstaben konvertieren

Datei
-e `Path`	Existiert
-s `Path`	Nicht leer
-r `Path`	Lesbar
-w `Path`	Schreibbar
-x `Path`	Ausführbar
-u `Path`	Set-UID Flag
-g `Path`	Set-GID Flag
Spezialdatei
-f `Path`	Normale Datei
-d `Path`	Verzeichnis
-h `Path`	Symlink
-L `Path`	Symlink
-p `Path`	FIFO
-b `Path`	Blockgerät
-c `Path`	Zeichengerät
-S `Path`	Sockel
-t `FileDesc`	Dateideskriptor für Terminal
Zeichenkette
`String`	Nicht leer (Länge > 0)
-n `String`	Nicht leer (Länge > 0)
-z `String`	Leer (Länge 0)
`String` = `String`	Beide Identisch
`String` != `String`	Verschieden
Algebra
`Number` -eq `Number`	Gleich
`Number` -ne `Number`	Ungleich
`Number` -gt `Number`	Größer als
`Number` -ge `Number`	Größer oder gleich
`Number` -lt `Number`	Kleiner als
`Number` -le `Number`	Kleiner oder gleich
Logik
`Expression` -a `Expression`	Beide Ausdrücke sind wahr
`Expression` -o `Expression`	Einer der Ausdrücke ist wahr

Dynamisches Laden
-a	Eingebaute Kommandos auflisten
-n	Deaktivierte Kommandos auflisten; mit Argument: Kommando deaktiveren
-p	Eingebaute Kommandos wiederverwendbar auflisten
-s	Eingebaute Kommandos der POSIX-Shell auflisten
-f	Kommandos aus Datei laden
-d	Geladenes Kommando löschen

Extraktion
-v	Verbosität erhöhen
-c	Diagnosemeldung unterdrücken
-t	Inhaltsverzeichnis ausgeben
-t	Inhaltsverzeichnis ausgeben
-x	Objekt extrahieren
-p	Inhalt eines oder aller Objekte ausgeben
-C	Existierende Dateien nicht überschreiben
-T	Lange Dateinamen abschneiden
Manipulation
-a	Objekt hinter `Posname` anhängen
-b	Objekt vor `Posname` einfügen
-i	Dito
-d	Objekte aus dem Archiv löschen
-m	Objekt vor oder hinter `Posname` oder ganz ans Ende verschieben
-q	Objekt ohne Prüfung hinten anhängen
-r	Objekt im Archiv ersetzen
-u	Älteres Objekt aktualisieren
-s	Symboltabelle neu aufbauen

Filter
-P	POSIX-konformes Format ausgeben
-A	Vollständigen Pfadname ausgeben
-f	Redundante Symbole für `.text`, `.data` und `.bss` ausgeben
-v	Nach Wert statt Name sortieren
-e	Nur externe und statisches Symbole ausgeben
-g	Nur externe Symbole ausgeben
-u	Nur undefinierte Symbole ausgeben
Zahlenformat
-t d	Dezimal (default)
-t o, -o	Oktal
-t x, -x	Hexadezimal

Literatur

The Open Group: Portable Operating System Interface
Wikipedia: List of Unix commands
NixSavy: Linux Commands In Structured Order
MaiZure: Decoded: GNU coreutils

1	Programme und Shell-Befehle
2	Kernel-Funktionen
3	Bibliotheks-Funktionen
4	Spezialdateien
5	Dateiformate
6	Spiele
7	Makropakete
8	Systemverwaltung
9	Kernel-Routinen

-m `Mode`	Zugriffsrechte setzen (statt `0777-umask`)
-p	Fehlende Zwischenverzeichnisse anlegen

-H	Symlinks in der Operandenliste folgen
-L	Symlinks immer folgen
-depth	Tiefensuche
-prune	Nicht in Unterverzeichnisse hinabsteigen
-xdev	Dateisystem nicht verlassen

-h	Symlinks folgen
-i	MIME-Typ ausgeben
-m `File`	Alternative Magic-Datenbank zusätzlich verwenden
-M `File`	Alternative Magic-Datenbank ausschließlich verwenden

-c	Nur existierende Dateien anfassen
-a	Nur Zugriffszeit setzen
-m	Nur Änderungszeit setzen
-r `File`	Datum der Referenzdatei verwenden
-d `Time`	Datum im Format `YYYY-MM-DD hh:mm:SS[,nnnn][zone]`
-t `Time`	Datum im Format `[[CC]YY]MMDDhhmm[.SS]`

-L	Logischen Pfad (Umgebungsvariable `PWD`) ausgeben
-P	Physikalischen Pfad ausgeben, Symlinks auflösen

-p	POSIX-Konformität prüfen
-P	Leere Namen und führenden Bindestrich anmeckern

-a	Größe für jede Datei ausgeben
-k	Kilobyte als Blockgröße verwenden
-s	Summen für Unterverzeichnisse bilden
-x	Dateisystem nicht verlassen
-H	Symlinks in der Operandenliste folgen
-L	Symlinks immer folgen

-k	Kilobyte als Blockgröße verwenden
-P	Portables Ausgabeformat verwenden

-i	Nachfragen, wenn Zieldatei existiert
-f	Bestätigung unterdrücken

-i	Nachfragen, wenn Zieldatei existiert
-f	Existierende Zieldatei vorher löschen
-p	Besitzer, Rechte, Änderungs- und Zugriffszeit klonen
-R	Rekursiv kopieren
-H	Symlinks in der Operandenliste folgen
-L	Symlinks immer folgen
-P	Symlinks nicht folgen

if=`Path`	Quelldatei
of=`Path`	Zieldatei
bs=`Expression`	Quell- und Ziel-Blockgröße (512 Oktette)
ibs=`Expression`	Quell-Blockgröße
obs=`Expression`	Ziel-Blockgröße
cbs=`Expression`	Blockgröße für Zeilenkonvertierung
skip=`Num`	Blöcke in Quelldatei überspringen
seek=`Num`	Blöcke in Zieldatei überspringen
count=`Num`	Maximal soviele Blöcke kopieren
conv=`Value`[,…]	Daten konvertieren:
conv=ascii	EBCDIC nach ASCII wandeln
conv=ebcdic	ASCII nach EBCDIC wandeln
conv=ibm	ASCII nach IBMwandeln
conv=block	Zeilen in feste Blöcke konvertieren
conv=unblock	Feste Blöcke in Zeilen konvertieren
conv=lcase	Groß- in Kleinbuchstaben wandeln
conv=ucase	Klein- in Großbuchstaben wandeln
conv=swab	Oktette paarweise tauschen
conv=noerror	Bei Fehlern nicht abbrechen
conv=notrunc	Zieldatei nicht kürzen
conv=sync	Synchron auf Platte schreiben

-f	Existierende Zieldatei vorher löschen
-s	Symlink erzeugen
-L	Symlinks folgen
-P	Harte Links direkt auf Symlinks anlegen

-i	Nachfragen
-f	Fehler ignorieren
-r	Rekursiv löschen
-R	Rekursiv löschen

-h	Symlinks selbst ändern
-H	Symlinks in der Operandenliste folgen
-L	Symlinks immer folgen
-P	Symlinks übergehen
-R	Rekursiv vorgehen

-b `Bits`	Bits pro Code, erlaubt sind 9–14
-c	Gepackte Daten auf die Standardausgabe schreiben
-f	Kompression erzwingen, auch wenn sie nichts bringt
-v	Prozentuale Verkleinerung ausgeben

-h	Symlinks selbst ändern
-H	Symlinks in Operandenliste folgen
-L	Symlinks immer folgen
-P	Symlinks übergehen
-R	Rekursiv vorgehen

-l	Position und Wert unterschiedlicher Oktette ausgeben
-s	Ausgaben unterdrücken

-a `Num`	Endungen mit sovielen (statt 2) stellen erzeugen
-b `Num`[km]	(Kilo-, Mega-)Bytes pro Ausgabedatei schreiben
-l `Num`	Zeilen pro Ausgabedatei schreiben

-c	Entpackte Daten auf die Standardausgabe schreiben
-f	Kompression erzwingen, auch wenn sie nichts bringt
-v	Dateiinformationen ausgeben

r	Dateien an das Archiv anhängen
x	Dateien aus dem Archiv extrahieren
t	Inhalt des Archivs ausgeben
u	Dateien im Archiv aktualisieren
c	Neues Archiv erzeugen
v	Verbosität erhöhen
w	Aktionen interaktiv bestätigen
f	Ersten Operand als Archiv verwenden
b	Blockfaktor (Vielfaches von 512 Oktetten) festlegen
l	Links prüfen
m	Änderungszeit neu setzen
o	Zugriffsrechte für den aufrufenden Benutzer setzen

-p `String`	Prompt im Kommando-Modus
-s	Ausgabe von Oktettzählern unterdrücken

-c `Command`	Initiales Kommando ausführen
-r	Datei nach Abbruch wiederherstellen
-R	Datei nur zum Lesen öffnen
-t `Tag`	Datei mit diesem `ctags`-Etikett öffnen
-s	Batch-Modus aktivieren
-v	Visuellen Modus aktivieren
-w `Size`	Fenstergröße festlegen

-d `Dest`	Drucker auswählen
-t `Title`	Name des Auftrag setzen
-n `Copies`	Anzahl der Kopien (1–100)
-o `Option`	Option der Form `name=value` setzen
-m	Nachricht nach Erledigung des Auftrags senden
-c	Kopie im Spoolverzeichnis ablegen
-s	Auftrags-ID unterdrücken
-w …

-c	Bildschirm nicht rollen
-e	Programm nach der letzten Zeile verlassen
-i	Ohne Groß-/Kleinschreibung suchen
-n `Number`	Pro Seite nur soviele Zeilen ausgeben
-p `Command`	Kommando beim Umblättern ausführen
-s	Aufeinanderfolgende Leerzeilen zusammenfassen
-t `Tag`	Datei mit diesem Etikett öffnen (`ctags`)
-u	Nichts unterstreichen

-b	Breite in Oktetten berechnen
-s	Nur an Leerzeichen umbrechen
-w `Width`	Breite festlegen

+`Page`	Soviele Seiten überspringen
-`Column`	Text auf soviele Spalten verteilen
-a	Spalten horizontal schreiben
-d	Zeilenumbruch verdoppeln
-e[`Char`][`Gap`]	Diese Zeichen als Tabulator mit dieser Breite ausgeben
-f	Seitenvorschub verwenden
-F	Seitenvorschub verwenden
-h `Header`	Kopfzeile festlegen
-i[`Char`][`Gap`]
-l `Lines`	Zeilen pro Seite festlegen (statt 66)
-m	Eingabedateien nebeneinander drucken
-n[`Char`][`Width`]	Zeilen 5-stellig nummerieren
-o `Offset`	Linker Rand mit sovielen Leerzeichen
-p	Vor jeder Seite pausieren, wenn die Stamdardausgabe ein Terminal ist
-r	Warnungen unterdrücken
-s[`Char`]	Spaltentrenner festlegen
-t	Kopf- und Fußzeilen unterdrücken
-w `Width`	Seitenbreite festlegen (statt 72 Zeichen)

-b `List`	Oktettposition auswählen (`[First][-Last][,…]`)
-c `List`	Nur diese Zeichen ausgeben
-d `Delimiter`	Feldtrennzeichen festlegen (statt Tabulator)
-f `List`	Felder auswählen (`[First][-Last][,…]`)
-s	Zeilen ohne Trennzeichen unterdrücken
-n	Zeichen nicht trennen (ignoriert)

-c `Width`	Breite des Terminals
-s `Separator`	Trennzeichen
-t	Spalten tabellarisch anordnen
-x	Spalten vor Zeilen füllen
-n	Trennzeichen nicht zusammenfassen
-e	Leerzeilen nicht ignorieren

-o `File`	Ausgabe in Datei schreiben
-c	Sortierfehler melden aber nicht sortieren
-C	Sortierung prüfen aber keine Fehler melden
-m	Mehrere sortierte Dateien zusammenführen
-u	Doppelte Zeilen unterdrücken
-d	Nur Leerzeichen und alphanumerische Zeichen berücksichtigen
-f	Groß-/Kleinschreibung ignorieren
-i	Nur druckbare Zeichen beachten
-n	Numerisch sortieren
-r	Sortierung umkehren
-b	Führende Leerzeichen ignorieren
-t `Char`	Felder am Zeichen `Char` trennen
-k `Keydef`	Nach Feld sortieren

-c	Wiederholungen zählen und vorne ausgeben
-d	Singuläre Zeilen unterdrücken
-u	Doppelte Zeilen unterdrücken
-f `Number`	Die ersten (durch Leerzeichen getrennte) Felder ignorieren
-s `Number`	Die ersten Zeichen ignorieren

-1	Zeilen nur in linker Datei unterdrücken
-2	Zeilen nur in rechter Datei unterdrücken
-3	Gemeinsame Zeilen unterdrücken

-1 `Field`	Feld in Datei 1
-2 `Field`	Feld in Datei 2
-t `Char`	Felder am Zeichen trennen
-e `String`	Leere Felder füllen
-o `List`	Felder für die Ausgabe wählen
-a `File`	Unpassende Zeilen in Datei 1 oder 2 ausgeben
-v `File`	Ausgabelogik umkehren

-f `Prefix`	Präfix für erzeugte Dateien (statt `xx`)
-n `Number`	Dateinamen mit sovielen Stellen (statt 2) bilden
-k	Bei Fehlern zuvor erzeugte Dateien behalten
-s	Dateigrößen unterdrücken

-e `Pattern`	Weitere Muster anwenden
-f `File`	Weitere Muster aus Datei lesen
-E	Erweiterten regulären Ausdruck verwenden
-F	Muster als feste Zeichenkette (und nicht als Regex) verwenden
-c	Passende Zeilen nur zählen
-i	Groß-/Kleinschreibung ignorieren
-l	Nur den Dateinamen beim ersten Treffer ausgeben
-n	Zeilennummer ausgeben
-q	Ausgabe unterdrücken
-s	Fehlermeldungen unterdrücken
-v	Ausgabelogik umkehren
-x	Ganze Zeilen vergleichen, impliziert `^…$`

-e `Script`	Weitere Skripte anwenden
-f `File`	Skripte aus Datei lesen
-n	Ausgabe des Musterbereichs unterdrücken