Nushell

Eine neue Art von Shell.

Example of nushell

Inhaltsverzeichnis

Status
Nu kennenlernen
Installation
Konfiguration
Philosophie
Ziele
Offiziell unterstützt von
Mitwirken
Lizenz

Status

Dieses Projekt hat ein Minimum-Viable-Product-Niveau an Qualität erreicht. Viele Menschen nutzen es als ihren täglichen Begleiter, aber es kann bei einigen Befehlen instabil sein. Nus Design kann sich im Laufe der Reifung ändern.

Nu kennenlernen

Das Nushell-Buch ist die primäre Quelle der Nushell-Dokumentation. Du findest eine vollständige Liste der Nu-Befehle im Buch, und wir haben viele Beispiele für die Verwendung von Nu in unserem Kochbuch.

Wir sind auch aktiv auf Discord; komm und plaudere mit uns!

Installation

Um Nu schnell zu installieren:

# Linux und macOS
brew install nushell
# Windows
winget install nushell

Um Nu in GitHub Action zu verwenden, schau dir setup-nu für weitere Details an.

Detaillierte Installationsanweisungen findest du im Installationskapitel des Buches. Nu ist über viele Paketmanager verfügbar:

Details darüber, welche Plattformen das Nushell-Team aktiv unterstützt, findest du in unserer Plattform-Support-Richtlinie.

Konfiguration

Die Standardkonfigurationen findest du unter sample_config, das sind die Konfigurationsdateien, die man erhält, wenn man Nushell zum ersten Mal startet.

Es setzt die gesamte Standardkonfiguration, um Nushell auszuführen. Von hier aus kann man diese Datei dann für die eigenen spezifischen Bedürfnisse anpassen.

Um zu sehen, wo sich config.nu auf deinem System befindet, gib einfach diesen Befehl ein.

$nu.config-path

Bitte schau in unserem Buch nach der gesamten Nushell-Dokumentation.

Philosophie

Nu lässt sich von Projekten wie PowerShell, funktionalen Programmiersprachen und modernen CLI-Tools inspirieren. Anstatt Dateien und Daten als rohe Textströme zu betrachten, betrachtet Nu jede Eingabe als etwas mit Struktur. Wenn du zum Beispiel den Inhalt eines Verzeichnisses auflistest, erhältst du eine Tabelle von Zeilen, wobei jede Zeile ein Element in diesem Verzeichnis darstellt. Diese Werte können durch eine Reihe von Schritten geleitet werden, in einer Reihe von Befehlen, die als 'Pipeline' bezeichnet werden.

Pipelines

In Unix ist es üblich, Befehle zu verketten, um einen komplexen Befehl über mehrere Schritte aufzuteilen. Nu geht noch einen Schritt weiter und baut stark auf der Idee von Pipelines auf. Wie in der Unix-Philosophie erlaubt Nu Befehlen, auf stdout auszugeben und von stdin zu lesen. Zusätzlich können Befehle strukturierte Daten ausgeben (man kann sich das als eine dritte Art von Stream vorstellen). Befehle, die in der Pipeline arbeiten, fallen in eine von drei Kategorien:

Befehle, die einen Stream erzeugen (z. B. ls)
Befehle, die einen Stream filtern (z. B. where type == "dir")
Befehle, die die Ausgabe der Pipeline konsumieren (z. B. table)

Befehle werden durch das Pipe-Symbol (|) getrennt, um eine von links nach rechts fließende Pipeline zu kennzeichnen.

ls | where type == "dir" | table
# => ╭────┬──────────┬──────┬─────────┬───────────────╮
# => │ #  │   name   │ type │  size   │   modified    │
# => ├────┼──────────┼──────┼─────────┼───────────────┤
# => │  0 │ .cargo   │ dir  │     0 B │ 9 minutes ago │
# => │  1 │ assets   │ dir  │     0 B │ 2 weeks ago   │
# => │  2 │ crates   │ dir  │ 4.0 KiB │ 2 weeks ago   │
# => │  3 │ docker   │ dir  │     0 B │ 2 weeks ago   │
# => │  4 │ docs     │ dir  │     0 B │ 2 weeks ago   │
# => │  5 │ images   │ dir  │     0 B │ 2 weeks ago   │
# => │  6 │ pkg_mgrs │ dir  │     0 B │ 2 weeks ago   │
# => │  7 │ samples  │ dir  │     0 B │ 2 weeks ago   │
# => │  8 │ src      │ dir  │ 4.0 KiB │ 2 weeks ago   │
# => │  9 │ target   │ dir  │     0 B │ a day ago     │
# => │ 10 │ tests    │ dir  │ 4.0 KiB │ 2 weeks ago   │
# => │ 11 │ wix      │ dir  │     0 B │ 2 weeks ago   │
# => ╰────┴──────────┴──────┴─────────┴───────────────╯

Da du die Ausgabe einer Pipeline meistens sehen möchtest, wird table angenommen. Wir hätten das Obige auch so schreiben können:

ls | where type == "dir"

In der Lage zu sein, dieselben Befehle zu verwenden und sie unterschiedlich zu kombinieren, ist eine wichtige Philosophie in Nu. Zum Beispiel könnten wir den eingebauten Befehl ps verwenden, um eine Liste der laufenden Prozesse zu erhalten, mit demselben where wie oben.

ps | where cpu > 0
# => ╭───┬───────┬───────────┬───────┬───────────┬───────────╮
# => │ # │  pid  │   name    │  cpu  │    mem    │  virtual  │
# => ├───┼───────┼───────────┼───────┼───────────┼───────────┤
# => │ 0 │  2240 │ Slack.exe │ 16.40 │ 178.3 MiB │ 232.6 MiB │
# => │ 1 │ 16948 │ Slack.exe │ 16.32 │ 205.0 MiB │ 197.9 MiB │
# => │ 2 │ 17700 │ nu.exe    │  3.77 │  26.1 MiB │   8.8 MiB │
# => ╰───┴───────┴───────────┴───────┴───────────┴───────────╯

Dateien öffnen

Nu kann Datei- und URL-Inhalte als Rohtext oder strukturierte Daten laden (wenn es das Format erkennt). Zum Beispiel kannst du eine .toml-Datei als strukturierte Daten laden und sie erkunden:

open Cargo.toml
# => ╭──────────────────┬────────────────────╮
# => │ bin              │ [table 1 row]      │
# => │ dependencies     │ {record 25 fields} │
# => │ dev-dependencies │ {record 8 fields}  │
# => │ features         │ {record 10 fields} │
# => │ package          │ {record 13 fields} │
# => │ patch            │ {record 1 field}   │
# => │ profile          │ {record 3 fields}  │
# => │ target           │ {record 3 fields}  │
# => │ workspace        │ {record 1 field}   │
# => ╰──────────────────┴────────────────────╯

Wir können dies in einen Befehl leiten, der den Inhalt einer der Spalten abruft:

open Cargo.toml | get package
# => ╭───────────────┬────────────────────────────────────╮
# => │ authors       │ [list 1 item]                      │
# => │ default-run   │ nu                                 │
# => │ description   │ A new type of shell                │
# => │ documentation │ https://www.nushell.sh/book/       │
# => │ edition       │ 2018                               │
# => │ exclude       │ [list 1 item]                      │
# => │ homepage      │ https://www.nushell.sh             │
# => │ license       │ MIT                                │
# => │ metadata      │ {record 1 field}                   │
# => │ name          │ nu                                 │
# => │ repository    │ https://github.com/nushell/nushell │
# => │ rust-version  │ 1.60                               │
# => │ version       │ 0.72.0                             │
# => ╰───────────────┴────────────────────────────────────╯

Und wenn nötig, können wir noch tiefer gehen:

open Cargo.toml | get package.version
# => 0.72.0

Plugins

Nu unterstützt Plugins, die der Shell zusätzliche Funktionalität bieten und demselben strukturierten Datenmodell folgen, das eingebaute Befehle verwenden. Es gibt einige Beispiele in den Verzeichnissen crates/nu_plugins_*.

Plugins sind Binärdateien, die in deinem Pfad verfügbar sind und einer Namenskonvention nu_plugin_* folgen. Diese Binärdateien interagieren mit nu über ein einfaches JSON-RPC-Protokoll, bei dem sich der Befehl identifiziert und seine Konfiguration weitergibt, wodurch er für die Verwendung verfügbar wird. Wenn das Plugin ein Filter ist, werden Datenströme elementweise an es gesendet, und es kann Daten über stdin/stdout zurückstreamen. Wenn das Plugin eine Senke ist, erhält es den vollständigen Vektor der endgültigen Daten und hat freie Hand über stdin/stdout, um es nach Belieben zu verwenden.

Das awesome-nu-Repo listet eine Vielzahl von nu-Plugins auf, während das Showcase-Repo informative Blogbeiträge zeigt, die über Nushell geschrieben wurden, zusammen mit Videos, die technische Themen hervorheben, die präsentiert wurden.

Ziele

Nu hält sich eng an eine Reihe von Zielen, die seine Designphilosophie ausmachen. Wenn Funktionen hinzugefügt werden, werden sie gegen diese Ziele geprüft.

Zuallererst ist Nu plattformübergreifend. Befehle und Techniken sollten über Plattformen hinweg funktionieren und Nu hat erstklassige Unterstützung für Windows, macOS und Linux.
Nu gewährleistet Kompatibilität mit bestehenden plattformspezifischen ausführbaren Dateien.
Nus Workflow und Tools sollten die Benutzerfreundlichkeit haben, die man von moderner Software im Jahr 2022 (und darüber hinaus) erwartet.
Nu betrachtet Daten entweder als strukturiert oder unstrukturiert. Es ist eine strukturierte Shell wie PowerShell.
Schließlich betrachtet Nu Daten funktional. Anstatt Mutation zu verwenden, dienen Pipelines als Mittel, um Daten ohne veränderlichen Zustand zu laden, zu ändern und zu speichern.

Offiziell unterstützt von

Bitte reiche ein Issue oder einen PR ein, um zu dieser Liste hinzugefügt zu werden.

Mitwirken

Siehe Mitwirken für Details. Danke an alle Menschen, die bereits beigetragen haben!

Lizenz

Das Projekt wird unter der MIT-Lizenz zur Verfügung gestellt. Siehe die Datei LICENSE für weitere Informationen.