Einführung

Hallo und herzlich Willkommen beim Nushell Projekt. Das Ziel diese Projekts ist es, die Philosophie von Unix Shells, wo Pipes einfache Befehle miteinander verbinden, mit modernen Ansätzen zu verbinden.

Nu ist von vielen Seiten beeinflusst: traditionelle Shells wie Bash, objektbasierte Shells wie PowerShell, funktionale Programmierung, Systems Programming und viele Weitere. Aber statt die eierlegende Wollmilchsau zu sein, liegt der Fokus von Nu darauf, die angebotenen Funktionen gut zu beherrschen:

  • Flexible cross-plattform Shell mit einem modernen Verhalten
  • Ausgaben von Kommandozeilenprogrammen mit einer Shell zu verarbeiten, die Struktur von Daten versteht
  • Ein Interface besitzen, das den modernen Bedürfnissen gerecht wird

Der einfachste Weg zu verstehen, was Nu alles leisten kann, ist entlang von Beispielen. Los geht's!

Das Erste was auffällt, wenn ein Befehl wie ls ausgeführt wird, ist, dass anstatt eines Blocks von Text eine strukturierte Tabelle als Ausgabe erscheint.

> ls
╭────┬───────────────────────┬──────┬───────────┬─────────────╮
│ #  │         name          │ type │   size    │  modified   │
├────┼───────────────────────┼──────┼───────────┼─────────────┤
│  0404.html              │ file429 B │ 3 days ago  │
│  1 │ CONTRIBUTING.md       │ file955 B │ 8 mins ago  │
│  2 │ Gemfile               │ file1.1 KiB │ 3 days ago  │
│  3 │ Gemfile.lock          │ file6.9 KiB │ 3 days ago  │
│  4 │ LICENSE               │ file1.1 KiB │ 3 days ago  │
│  5 │ README.md             │ file213 B │ 3 days ago  │
...

Diese Tabelle ist mehr als nur eine andere Darstellungsform. Wie Tabellen in Spreadsheets erlaubt es diese Tabelle mit den Daten interaktiver zu arbeiten.

Um das zu demonstrieren, wird der Inhalt der Tabelle zunächst nach der Größe sortiert. Um das zu realisieren, wird die Ausgabe von ls genommen und in ein Befehl gegeben, der Tabellen auf Basis von Daten in einer Spalte neu anordnen kann.

> ls | sort-by size | reverse
╭────┬───────────────────────┬──────┬───────────┬─────────────╮
│ #  │         name          │ type │   size    │  modified   │
├────┼───────────────────────┼──────┼───────────┼─────────────┤
│  0 │ Gemfile.lock          │ file6.9 KiB │ 3 days ago  │
│  1 │ SUMMARY.md            │ file3.7 KiB │ 3 days ago  │
│  2 │ Gemfile               │ file1.1 KiB │ 3 days ago  │
│  3 │ LICENSE               │ file1.1 KiB │ 3 days ago  │
│  4 │ CONTRIBUTING.md       │ file955 B │ 9 mins ago  │
│  5 │ books.md              │ file687 B │ 3 days ago  │
...

Um das Ganze zu realisieren, mussten hierzu nicht Argumente an ls übergeben werden. Stattdessen wird der sort-by Befehl verwendet, den Nu bereitstellt, um Daten zu sortieren. Damit die größten Dateien oben erscheinen wurde zusätzlich die Option reverse angegeben.

Nu stellt sehr viele Befehle bereit, die mit Tabellen arbeiten können. Beispielsweise kann die Ausgabe von ls auch derart gefiltert werden, dass nur Datei mit einer Größe von mehr als einem Kilobyte angezeigt werden:

> ls | where size > 1kb
╭───┬───────────────────┬──────┬─────────┬────────────╮
│ # │       name        │ type │  size   │  modified  │
├───┼───────────────────┼──────┼─────────┼────────────┤
│ 0 │ Gemfile           │ file1.1 KiB │ 3 days ago │
│ 1 │ Gemfile.lock      │ file6.9 KiB │ 3 days ago │
│ 2 │ LICENSE           │ file1.1 KiB │ 3 days ago │
│ 3 │ SUMMARY.md        │ file3.7 KiB │ 3 days ago │
╰───┴───────────────────┴──────┴─────────┴────────────╯

Wie in der Unix-Philosophie, erlauben Befehle, die untereinander Daten austauschen können, viele verschiedene Kombinationen um Aufgaben zu lösen. Wie in folgendem Beispiel:

> ps
╭─────┬──────┬──────────────────────┬─────────┬───────┬───────────┬──────────╮
│  #  │ pid  │         name         │ status  │  cpu  │    mem    │ virtual  │
├─────┼──────┼──────────────────────┼─────────┼───────┼───────────┼──────────┤
│   07570 │ nu                   │ Running │  1.9623.2 MiB │ 32.8 GiB │
│   13533 │ remindd              │ Sleep   │  0.00103.6 MiB │ 32.3 GiB │
│   23495 │ TVCacheExtension     │ Sleep   │  0.0011.9 MiB │ 32.2 GiB │
│   33490 │ MusicCacheExtension  │ Sleep   │  0.0012.9 MiB │ 32.2 GiB │
...

Der ps Befehl erlaubt es auf Linux-Systemen alle laufenden Prozesse, deren Status und Name abzufragen. Des Weiteren gibt er Informationen zu CPU-Last der einzelnen Prozesse an.

Was macht man, wenn man nur Prozesse sehen möchte, die aktuelle aktiv die CPU nutzen? Wie zuvor beim ls Befehl, kann mit der durch ps zurückgegebenen Tabelle gearbeitet werden:

> ps | where cpu > 5
╭───┬──────┬────────────────┬─────────┬────────┬───────────┬──────────╮
│ # │ pid  │      name      │ status  │  cpu   │    mem    │ virtual  │
├───┼──────┼────────────────┼─────────┼────────┼───────────┼──────────┤
│ 01583 │ Terminal       │ Running │  20.69127.8 MiB │ 33.0 GiB │
│ 1579 │ photoanalysisd │ Running │ 139.5099.9 MiB │ 32.3 GiB │
╰───┴──────┴────────────────┴─────────┴────────┴───────────┴──────────╯

Bis jetzt wurden ls und ps genutzt, um Dateien und Prozesse aufzulisten. Nu besitzt aber noch viele weitere Befehle die nützliche Informationen in Tabellenform ausgeben. Dazu wird nun ein Block auf die Befehle date und sys geworfen.

Wenn date now aufgerufen wird, werden Informationen zum aktuellen Datum und der aktuellen Uhrzeit ausgegeben.

> date now
2022-03-07 14:14:51.684619600 -08:00

Um das Datum in Tabellenform zu bekommen, kann es zusätzlich in date to-table gegeben werden:

> date now | date to-table
╭───┬──────┬───────┬─────┬──────┬────────┬────────┬──────────╮
│ # │ year │ month │ day │ hour │ minute │ second │ timezone │
├───┼──────┼───────┼─────┼──────┼────────┼────────┼──────────┤
│ 020223714453 │ -08:00   │
╰───┴──────┴───────┴─────┴──────┴────────┴────────┴──────────╯

Der Aufruf von sys gibt Informationen zum System aus, auf dem Nu läuft:

> sys
╭───────┬───────────────────╮
│ host{record 6 fields} │
│ cpu   │ [table 4 rows]    │
│ disks │ [table 3 rows]    │
│ mem   │ {record 4 fields} │
│ temp  │ [table 1 row]     │
│ net   │ [table 4 rows]    │
╰───────┴───────────────────╯

Diese Ausgabe unterscheidet sich nun von den vorherigen. Der sys Befehl gibt eine Tabelle zurück, die selbst strukturierte Tabellen in den Zellen enthält anstatt nur einfache Werte. Um auf die Daten zuzugreifen, wird der get Befehl verwendet:

> sys | get host
╭────────────────┬────────────────────────╮
│ name           │ Debian GNU/Linux       │
│ os version     │ 11                     │
│ kernel version │ 5.10.92-v8+            │
│ hostname       │ lifeless               │
│ uptime         │ 19day 21hr 34min 45sec │
│ sessions       │ [table 1 row]          │
╰────────────────┴────────────────────────╯

Der get Befehl erlaubt es, in die Inhalte einer Tabellenzelle einzutauchen. Hier wird beispielsweise die Spalte "host" näher betrachtet, die Informationen über den Host, auf dem Nu läuft, enthält. Der Name des Betriebssystem (OS), die CPU und mehr. Nun sollen die Namen der Nutzer auf dem System ausgegeben werden:

> sys | get host.sessions.name
╭───┬────╮
│ 0 │ jt │
╰───┴────╯

Aktuelle existiert nur ein Nutzer namens "jt". Wie zu sehen ist, kann ein ganzer Pfad für Spalten angegeben werden - nicht nur der Name der Spalte. Nu wird den Pfad nehmen und durch die entsprechenden Daten in der Tabelle gehen.

Und noch etwas anderes ist anders. Anstatt einer Tabelle mit Daten wurde nur ein einzelnes Element ausgegeben: der String "jt". Nu arbeitet sowohl mit Tabellen voller Daten als auch mit Strings. Strings sind ein wichtiger Bestandteil, um mit Befehlen außerhalb von Nu zu arbeiten.

Nun soll aufgezeigt werden, wie mit Strings außerhalb von Nu gearbeitet wird. Dazu wird das vorige Beispiel erweitert. Die Daten werden an den externen echo Befehl weitergegeben (das ^ teilt Nu mit, dass nicht der eingebaute echo Befehl verwendet werden soll):

> sys | get host.sessions.name | each { |it| ^echo $it }
jt

Das sieht jetzt genau gleich aus wie die Ausgabe zuvor. Was soll das? Es ist ähnlich aber mit einem entscheidenden Unterschied: ^echo wurde aufgerufen. Das erlaubt es uns Daten aus Nu heraus an beliebige Befehle außerhalb von Nu zu geben wie echo oder git.

Hinweis: Hilfe zu allen in Nu eingebauten Befehlen kann mit dem Befehl help angezeigt werden:

> help path
Explore and manipulate paths.

There are three ways to represent a path:

* As a path literal, e.g., '/home/viking/spam.txt'
* As a structured path: a table with 'parent', 'stem', and 'extension' (and
* 'prefix' on Windows) columns. This format is produced by the 'path parse'
  subcommand.
* As an inner list of path parts, e.g., '[[ / home viking spam.txt ]]'.
  Splitting into parts is done by the `path split` command.

All subcommands accept all three variants as an input. Furthermore, the 'path
join' subcommand can be used to join the structured path or path parts back into
the path literal.

Usage:
  > path

Subcommands:
  path basename - Get the final component of a path
  path dirname - Get the parent directory of a path
  path exists - Check whether a path exists
  path expand - Try to expand a path to its absolute form
  path join - Join a structured path or a list of path parts.
  path parse - Convert a path into structured data.
  path relative-to - Get a path as relative to another path.
  path split - Split a path into parts by a separator.
  path type - Get the type of the object a path refers to (e.g., file, dir, symlink)

Flags:
  -h, --help
      Display this help message