Nushell

Moderne strukturierte Daten-Shell, die Befehlsausgaben als Tabellen behandelt und Pipelines mit typisierten Daten, Filterung und plattformübergreifendem Scripting unterstützt.

Installation

Befehl	Beschreibung
brew install nushell	Installation auf macOS mit Homebrew
cargo install nu	Installation von crates.io
winget install nushell	Installation auf Windows mit winget
sudo apt install nushell	Installation auf Debian/Ubuntu
pacman -S nushell	Installation auf Arch Linux
nix-env -i nushell	Installation auf NixOS
nu	Nushell starten
nu --version	Installierte Version anzeigen
nu -c "ls"	Einzelnen Befehl ausführen und beenden
nu script.nu	Nushell-Skriptdatei ausführen
chsh -s /usr/bin/nu	Nushell als Standard-Shell festlegen

Grundlegende Befehle

Systeminformationen

Befehl	Beschreibung
sys	Vollständige Systeminformationen anzeigen
sys host	Host-Details anzeigen (Name, OS, Kernel)
sys mem	Speicherverbrauch anzeigen
sys cpu	CPU-Informationen anzeigen
sys disks	Festplattennutzung anzeigen
sys net	Netzwerkschnittstellen anzeigen
sys temp	Temperatursensoren anzeigen
date now	Aktuelles Datum und Uhrzeit anzeigen
date now | format date "%Y-%m-%d"	Aktuelles Datum formatieren
$nu.home-path	Home-Verzeichnispfad anzeigen
$nu.os-info	OS-Details anzeigen

Dateiauflistung

Befehl	Beschreibung
ls	Dateien als strukturierte Tabelle auflisten
ls -l	Ausführliche Auflistung mit Details
ls -a	Versteckte Dateien anzeigen
ls **/*.rs	Rekursiver Glob für Rust-Dateien
ls | where size > 1mb	Dateien größer als 1MB filtern
ls | where type == dir	Nur Verzeichnisse filtern
ls | sort-by modified -r	Nach Änderungsdatum sortieren (neueste zuerst)
ls | sort-by size -r	Nach Größe absteigend sortieren
ls | get name	Nur Dateinamen-Spalte abrufen

Prozessverwaltung

Befehl	Beschreibung
ps	Prozesse als Tabelle auflisten
ps | where cpu > 10	Prozesse mit >10% CPU finden
ps | where name =~ "node"	Prozesse nach Namensmuster finden
ps | sort-by mem -r | first 10	Top 10 Prozesse nach Speicher
ps | where pid == 1234	Prozess nach PID finden

Hilfesystem

Befehl	Beschreibung
help	Allgemeine Hilfe anzeigen
help commands	Alle verfügbaren Befehle auflisten
help ls	Hilfe für bestimmten Befehl anzeigen
help operators	Verfügbare Operatoren auflisten
help escapes	String-Escape-Sequenzen anzeigen

Pipeline & Filter

Tabellenoperationen

Befehl	Beschreibung
ls | select name size	Bestimmte Spalten auswählen
ls | reject modified	Bestimmte Spalten entfernen
ls | rename filename filesize	Spalten umbenennen
ls | first 5	Erste 5 Zeilen abrufen
ls | last 3	Letzte 3 Zeilen abrufen
ls | skip 10	Erste 10 Zeilen überspringen
ls | length	Anzahl der Zeilen zählen
ls | reverse	Zeilenreihenfolge umkehren
ls | shuffle	Zeilenreihenfolge zufällig mischen
ls | flatten	Verschachtelte Tabellen abflachen
ls | columns	Spaltennamen auflisten

Filtern & Sortieren

Befehl	Beschreibung
ls | where size > 1mb	Nach Vergleich filtern
ls | where name =~ "test"	Nach Regex-Übereinstimmung filtern
ls | where name starts-with "src"	Nach Präfix filtern
ls | where name ends-with ".md"	Nach Suffix filtern
ls | where type in ["file" "dir"]	Nach Werteliste filtern
ls | sort-by size -r	Absteigend sortieren
ls | sort-by name -i	Groß-/Kleinschreibung ignorierend sortieren
ls | uniq-by type	Duplikate nach Spalte entfernen
ls | group-by type	Zeilen nach Spaltenwert gruppieren

Transformation

Befehl	Beschreibung
ls | each { |it| $it.name }	Jede Zeile transformieren
ls | par-each { |it| $it.name }	Parallel transformieren
ls | update size { |it| $it.size / 1kb }	Spaltenwerte aktualisieren
ls | insert label { |it| $it.name + "-file" }	Neue Spalte hinzufügen
ls | reduce -f 0 { |it, acc| $acc + $it.size }	Werte akkumulieren
ls | enumerate	Index-Spalte hinzufügen
ls | window 3	Gleitendes Fenster von 3 Zeilen
ls | zip [1 2 3]	Mit einer anderen Liste verbinden
ls | transpose	Zeilen und Spalten tauschen

Datentypen

Primitive Typen

Befehl	Beschreibung
42	Integer
3.14	Float
"hello"	String
true / false	Boolean
null	Null-Wert
2024-01-15	Datum
5sec / 3min / 2hr	Zeitdauer
1kb / 5mb / 2gb	Dateigröße
0b1010	Binärliteral
0xff	Hexadezimalliteral

Sammlungen

Befehl	Beschreibung
[1 2 3]	Liste
[1 2 3] | append 4	An Liste anhängen
[1 2 3] | prepend 0	Vor Liste einfügen
{name: "Alice", age: 30}	Record
{a: 1} | merge {b: 2}	Records zusammenführen
[[name age]; ["Alice" 30] ["Bob" 25]]	Tabellenliteral
0..9	Bereich (0 bis 9)
0..<9	Exklusiver Bereich (0 bis 8)
0..2..10	Bereich mit Schrittweite (0, 2, 4, 6, 8, 10)

Typkonvertierungen

Befehl	Beschreibung
"42" | into int	String zu Integer
"3.14" | into float	String zu Float
42 | into string	Zahl zu String
"true" | into bool	String zu Boolean
"2024-01-15" | into datetime	String zu Datetime
1024 | into filesize	Zahl zu Dateigröße
5 | into duration --unit sec	Zahl zu Zeitdauer
42 | into binary	Zahl zu Binär
[1 2 3] | into record	Liste zu Record
{a: 1} | into record	In Record konvertieren

Arbeiten mit Dateien

Öffnen & Parsen

Befehl	Beschreibung
open data.json	JSON-Datei öffnen und parsen
open data.csv	CSV-Datei öffnen und parsen
open data.yaml	YAML-Datei öffnen und parsen
open data.toml	TOML-Datei öffnen und parsen
open data.xml	XML-Datei öffnen und parsen
open data.tsv	TSV-Datei öffnen und parsen
open data.sqlite	SQLite-Datenbank öffnen
open file.txt	Als Klartext öffnen
open data.json | get users	Öffnen und in Daten navigieren

Speichern & Konvertieren

Befehl	Beschreibung
"hello" | save hello.txt	String in Datei speichern
ls | save files.json	Tabelle als JSON speichern
ls | save files.csv	Tabelle als CSV speichern
ls | save files.yaml	Tabelle als YAML speichern
open data.json | to csv	JSON in CSV konvertieren
open data.csv | to json	CSV in JSON konvertieren
open data.json | save data.yaml	Zwischen Formaten konvertieren
open data.csv | save -f data.csv	Bestehende Datei überschreiben
"line1\nline2" | save -a log.txt	An Datei anhängen

Dateimanipulation

Befehl	Beschreibung
open file.txt | lines	Datei in Zeilen aufteilen
open file.txt | lines | length	Zeilen in Datei zählen
open file.csv | where status == "active"	CSV-Zeilen filtern
open file.json | select name email	Felder aus JSON auswählen
open file.json | to yaml | save file.yaml	JSON in YAML konvertieren
glob "**/*.md" | each { |f| open $f }	Alle passenden Dateien öffnen

String-Operationen

Groß-/Kleinschreibung & Formatierung

Befehl	Beschreibung
"hello world" | str upcase	In Großbuchstaben konvertieren
"HELLO" | str downcase	In Kleinbuchstaben konvertieren
"hello" | str capitalize	Ersten Buchstaben großschreiben
" hello " | str trim	Leerzeichen entfernen
"hello" | str trim --char "h"	Bestimmtes Zeichen entfernen
"hello" | str reverse	String umkehren

Suchen & Ersetzen

Befehl	Beschreibung
"hello world" | str replace "world" "nu"	Erstes Vorkommen ersetzen
"aabaa" | str replace -a "a" "x"	Alle Vorkommen ersetzen
"hello world" | str replace -r '\w+' 'word'	Mit Regex ersetzen
"hello world" | str contains "world"	Prüfen ob String enthält
"hello world" | str starts-with "hello"	Präfix prüfen
"hello world" | str ends-with "world"	Suffix prüfen
"hello world" | str index-of "world"	Position des Teilstrings finden

Aufteilen & Verbinden

Befehl	Beschreibung
"hello world" | split row " "	Nach Trennzeichen aufteilen
"a,b,c" | split row ","	CSV-artigen String aufteilen
"hello" | split chars	In Zeichen aufteilen
["hello" "world"] | str join " "	Liste zu String verbinden
["a" "b" "c"] | str join ","	Mit Komma verbinden
"hello" | str length	String-Länge ermitteln
"hello world" | str substring 0..5	Teilstring extrahieren

String-Interpolation

# Grundlegende Interpolation
let name = "World"
$"Hello, ($name)!"

# Ausdrucks-Interpolation
$"Total: (1 + 2 + 3)"

# Mehrzeilige Strings
$"Line 1
Line 2
Line 3"

# Rohe Strings (keine Escape-Zeichen)
r#'C:\Users\path'#

Benutzerdefinierte Befehle

Funktionen definieren

Befehl	Beschreibung
def greet [name: string] { $"Hello, ($name)!" }	Grundlegender benutzerdefinierter Befehl
def add [a: int, b: int] -> int { $a + $b }	Befehl mit Typannotationen
def greet [name = "World"] { ... }	Befehl mit Standardparameter
def "git branches" [] { git branch | lines }	Unterbefehl-artiger Name
def --wrapped cmd [...rest] { ... }	Beliebige zusätzliche Argumente akzeptieren

Variablen & Kontrollfluss

Befehl	Beschreibung
let x = 42	Unveränderliche Variable
mut x = 0; $x = $x + 1	Veränderliche Variable
const PI = 3.14159	Kompilierzeit-Konstante
if $x > 0 { "pos" } else { "neg" }	Bedingter Ausdruck
match $x { 1 => "one", 2 => "two", _ => "other" }	Pattern Matching
for item in [1 2 3] { print $item }	For-Schleife
while $x < 10 { $x = $x + 1 }	While-Schleife
loop { if $x > 10 { break }; $x += 1 }	Endlosschleife mit break
try { risky_op } catch { "failed" }	Fehlerbehandlung

Erweiterte Funktionen

# Funktion mit Flag-Parameter
def greet [
  name: string       # Name zum Begrüßen
  --excited (-e)     # Ausrufezeichen verwenden
] {
  if $excited {
    $"Hello, ($name)!"
  } else {
    $"Hello, ($name)."
  }
}

# Funktion mit Rest-Parametern
def sum [...nums: int] -> int {
  $nums | math sum
}

# Pipeline-Eingabefunktion
def double-all [] {
  each { |x| $x * 2 }
}
# Verwendung: [1 2 3] | double-all

Mathematik & Aggregation

Befehl	Beschreibung
[1 2 3 4 5] | math sum	Summe der Werte
[1 2 3 4 5] | math avg	Durchschnitt der Werte
[1 2 3 4 5] | math min	Minimalwert
[1 2 3 4 5] | math max	Maximalwert
[1 2 3 4 5] | math median	Medianwert
[1 2 3 4 5] | math stddev	Standardabweichung
[1 2 3 4 5] | math variance	Varianz
[1 2 3] | math product	Produkt der Werte
10 | math abs	Absolutwert
10 | math sqrt	Quadratwurzel
2 | math round -p 2	Auf Genauigkeit runden
10 | math log 2	Logarithmus Basis 2

HTTP & Netzwerk

Befehl	Beschreibung
http get https://api.example.com/data	GET-Anfrage
http post https://api.example.com/data {name: "test"}	POST-Anfrage mit JSON
http put https://api.example.com/data/1 {name: "updated"}	PUT-Anfrage
http delete https://api.example.com/data/1	DELETE-Anfrage
http get url --headers [Accept application/json]	GET mit benutzerdefinierten Headern
http get url | get data	GET und Feld extrahieren
port 8080	Prüfen ob Port belegt ist

HTTP-Beispiel

# JSON-API abrufen und verarbeiten
let users = (http get "https://jsonplaceholder.typicode.com/users")
$users | select name email | first 5

# POST mit Headern und Body
http post "https://api.example.com/items" {
  name: "New Item"
  price: 29.99
} --headers [Authorization $"Bearer ($env.API_TOKEN)"]

Konfiguration

Konfigurationspfade

Befehl	Beschreibung
$nu.config-path	Konfigurationsdateipfad anzeigen
$nu.env-path	Umgebungs-Konfigurationsdateipfad anzeigen
$nu.default-config-dir	Konfigurationsverzeichnis anzeigen
config nu	Konfiguration im Editor öffnen
config env	Umgebungs-Konfiguration im Editor öffnen

Konfigurationseinstellungen

Befehl	Beschreibung
$env.config.show_banner = false	Startbanner deaktivieren
$env.config.buffer_editor = "vim"	Editor für Ctrl+O festlegen
$env.config.history.file_format = "sqlite"	SQLite-Verlauf verwenden
$env.config.history.max_size = 100_000	Maximale Verlaufseinträge festlegen
$env.config.completions.external.enable = true	Externe Vervollständigungen aktivieren
$env.config.cursor_shape.emacs = "line"	Cursorform festlegen
$env.config.footer_mode = "25"	Fußzeile für große Tabellen anzeigen
$env.config.table.mode = "rounded"	Tabellenrandstil festlegen

Umgebung & PATH

Befehl	Beschreibung
$env.PATH = ($env.PATH | prepend "/usr/local/bin")	Zu PATH hinzufügen
$env.PATH = ($env.PATH | append "~/.local/bin")	An PATH anhängen
$env.EDITOR = "vim"	Umgebungsvariable festlegen
alias ll = ls -l	Befehlsalias erstellen
source ~/.config/nushell/custom.nu	Zusätzliche Konfiguration einbinden

Konfigurationsbeispiel

# env.nu — Umgebungskonfiguration
$env.PATH = ($env.PATH | split row (char esep)
  | prepend "/usr/local/bin"
  | prepend ($env.HOME | path join ".cargo" "bin")
  | append ($env.HOME | path join "go" "bin")
)

$env.EDITOR = "nvim"
$env.VISUAL = "nvim"
$env.PAGER = "less"

# config.nu — Shell-Konfiguration
$env.config = {
  show_banner: false
  buffer_editor: "nvim"
  table: {
    mode: rounded
    index_mode: auto
    trim: {
      methodology: wrapping
      wrapping_try_keep_words: true
    }
  }
  history: {
    file_format: "sqlite"
    max_size: 100_000
    sync_on_enter: true
    isolation: false
  }
  completions: {
    case_sensitive: false
    quick: true
    partial: true
    algorithm: "prefix"
    external: {
      enable: true
      max_results: 100
    }
  }
}

Module & Overlays

Befehl	Beschreibung
module greet { export def hello [] { "hi" } }	Modul inline definieren
use greet hello	Befehl aus Modul importieren
use greet *	Alles aus Modul importieren
use utils.nu	Aus Dateimodul importieren
overlay use spam	Overlay aktivieren
overlay hide spam	Overlay deaktivieren
overlay list	Aktive Overlays auflisten

Modul-Beispiel

# Datei: utils.nu
export def "str kebab" [] {
  $in | str downcase | str replace -a " " "-"
}

export def "str title" [] {
  $in | split row " "
  | each { |w| $w | str capitalize }
  | str join " "
}

# Verwendung:
# use utils.nu
# "Hello World" | str kebab    # "hello-world"
# "hello world" | str title    # "Hello World"

Datenbankoperationen

Befehl	Beschreibung
open data.db	SQLite-Datenbank öffnen
open data.db | query db "SELECT * FROM users"	SQL-Abfrage ausführen
open data.db | query db "SELECT * FROM users WHERE age > 30"	Gefilterte Abfrage
open data.db | schema	Datenbankschema anzeigen
[[name age]; ["Alice" 30]] | into sqlite data.db	SQLite aus Tabelle erstellen
ls | into sqlite -t files data.db	Tabelle in SQLite speichern

Plugin-System

Befehl	Beschreibung
plugin list	Installierte Plugins auflisten
plugin add /path/to/plugin	Plugin registrieren
plugin rm plugin_name	Plugin entfernen
plugin use plugin_name	Plugin laden
cargo install nu_plugin_formats	Formate-Plugin installieren
cargo install nu_plugin_query	Query-Plugin installieren
cargo install nu_plugin_gstat	Git-Status-Plugin installieren

Best Practices

1. Strukturierte Daten verwenden — Nushell glänzt, wenn man mit Tabellen und Records statt mit rohen Strings arbeitet. Befehle durch select, where und sort-by statt grep und awk pipen.

2. Funktionsparameter typisieren — Typannotationen zu benutzerdefinierten Befehlen hinzufügen (name: string, count: int), um Fehler früh zu erkennen und bessere Autovervollständigung zu ermöglichen.

3. Unveränderliche Variablen bevorzugen — Standardmäßig let verwenden und mut nur bei echtem Bedarf für Mutation einsetzen. Dies verhindert versehentliche Zustandsänderungen in Skripten.

4. SQLite-Verlauf verwenden — $env.config.history.file_format = "sqlite" setzen für schnellere Suchen, bessere Korruptionsresistenz und reichhaltigere Metadaten.

5. par-each für Performance nutzen — Bei der Verarbeitung vieler unabhängiger Elemente läuft par-each in parallelen Threads und kann deutlich schneller als each sein.

6. Module für wiederverwendbaren Code verwenden — Benutzerdefinierte Befehle in .nu-Moduldateien organisieren und mit use statt source importieren. Module haben ordnungsgemäßes Namespacing und Exports.

7. into für Typkonvertierungen verwenden — Immer explizite Typkonvertierung (into int, into string, etc.) statt impliziter Umwandlung für zuverlässige Skripte nutzen.

8. Vervollständigungen konfigurieren — Externe Vervollständigungen und Carapace für Shell-Completion-Unterstützung über alle CLI-Tools aktivieren.

9. String-Interpolation verwenden — $"Hello, ($name)!" statt String-Verkettung mit + für saubereren, besser lesbaren Code bevorzugen.

10. Fehler mit try/catch behandeln — Operationen, die fehlschlagen können (Dateizugriff, HTTP, Parsing), in try { } catch { } Blöcke einschließen für robuste Skripte.

11. Mit describe testen — expression | describe verwenden, um den Typ eines beliebigen Werts während der Entwicklung und beim Debugging zu untersuchen.

12. Closures konsistent verwenden — Nushell-Closures verwenden die { |params| body } Syntax. Immer die Pipe-Zeichen einschließen, auch bei einzelnen Parametern, für Klarheit.