Merge pull request #259 from sebastian-xyz/main

add more german documentation

Author: sophiajt

.vuepress/config.js

@@ -179,7 +179,7 @@ module.exports = {
         label: "Deutsch",
         editLinkText: "Diese Seite auf GitHub bearbeiten",
         nav: [
-          { text: "Book", link: "/de/book/" },
+          { text: "Buch", link: "/de/book/" },
           { text: "Contributor Book", link: "/contributor-book/" },
           { text: "Cookbook", link: "/cookbook/" },
           { text: "Blog", link: "/blog/" },
@@ -194,8 +194,13 @@ module.exports = {
                 "",
                 "installation",
                 "konfiguration",
+                "3rdpartyprompts",
                 "eigene_befehle",
                 "aliase",
+                "mathematik",
+                "variablen_und_unterausdruecke",
+                "escaping",
+                "plugins",
                 "von_bash_kommend",
                 "command_reference",
               ],

book/3rdpartyprompts.md

@@ -10,7 +10,7 @@ nerdfonts are not required but they make the presentation much better.
 
 ## oh-my-posh
 
-[site](ttps://ohmyposh.dev/)
+[site](https://ohmyposh.dev/)
 
 [repo](https://github.com/JanDeDobbeleer/oh-my-posh)
 

de/book/3rdpartyprompts.md

@@ -0,0 +1,43 @@
+# Konfiguration von Drittanbieter-Prompts
+
+## nerdfonts
+
+nerdfonts sind nicht zwangsweise notwendig, machen aber die Darstellung viel besser.
+
+[Webseite](https://www.nerdfonts.com)
+
+[Repository](https://github.com/ryanoasis/nerd-fonts)
+
+## oh-my-posh
+
+[Webseite](https://ohmyposh.dev/)
+
+[Repository](https://github.com/JanDeDobbeleer/oh-my-posh)
+
+Wenn oh-my-posh verwendet werden soll, kann dies in wenigen Schritten für Nushell erreicht werden. Die Integration in Nushell funktioniert sehr gut. Die folgenden Schritte werden dazu benötigt:
+
+1. oh-my-posh installieren und die Farbschemata herunterladen entsprechend dieser [Anleitung](https://ohmyposh.dev/docs/linux#installation)
+2. Herunterladen und installieren einer [nerd font](https://github.com/ryanoasis/nerd-fonts).
+3. PROMPT_COMMAND in `~/.config/nushell/config.nu` setzen und `M365Princess.omp.json` beliebig ändern entsprechend der [Demo](https://ohmyposh.dev/docs/themes).
+
+```shell
+> let-env PROMPT_COMMAND = { oh-my-posh --config ~/.poshthemes/M365Princess.omp.json }
+```
+
+## Starship
+
+[Webseite](https://starship.rs/)
+
+[Repository](https://github.com/starship/starship)
+
+1. Den obigen Links folgen und starship installieren.
+2. nerdfonts entsprechend persönlicher Präferenzen installieren.
+3. Die `STARSHIP_SHELL` Umgebungsvariable auf `nu` setzen, indem der folgende Befehl ausgeführt wird: `let-env STARSHIP_SHELL = "nu"`
+4. Wenn die standardmäßige Uhr mit Zeit und Datum auf der rechten Seite dargestellt werden soll, sollte der folgende Befehl ausgeführt werden: `hide PROMPT_COMMAND_RIGHT`
+5. Wenn der standardmäßige Indikator verwendet werden soll, kann der folgende Befehl ausgeführt werden: `let-env PROMPT_INDICATOR = " "`
+6. starship kann als Prompt auf der linken Seite mit dem folgenden Befehl festgelegt werden: `let-env PROMPT_COMMAND = { starship prompt --cmd-duration $env.CMD_DURATION_MS --status $env.LAST_EXIT_CODE | str trim }`. Ein Hinweis: Unter Umständen muss `str trim` in der Nushell-Prompt nicht verwendet werden, wenn starship's standardmäßig aktive Einstellung für neue Zeilen in der `starship.toml` mittels `add_newline = false` deaktiviert wurde. Es gibt Berichte, dass dies teilweise nicht gut im Zusammenspiel mit Nushell-Prompts funktioniert. Wir arbeiten noch daran!
+7. Da Nushell Prompts auf der rechten Seite unterstützt, kann auch mit starship's Möglichkeit einer solchen Prompt experimentiert werden. Die rechte Prompt in Nushell zu setzen funktioniert identisch, wie das Setzen der Linken. Es muss lediglich `PROMPT_COMMAND_RIGHT` gesetzt werden. 
+
+## Purs
+
+[Repository](https://github.com/xcambar/purs)

de/book/escaping.md

@@ -0,0 +1,16 @@
+# Aufruf von Systembefehlen
+
+Nushell stellt einen identischen Satz an Befehlen für verschiedene Systeme zur Verfügung, die überall dieselbe Syntax und Funktionalität haben. Manchmal ist es jedoch nötig, den gleichnamigen, vom System selbst bereitgestellten, Befehl aufzurufen. Um beispielsweise den `ls` oder `date` Befehl des Systems auszuführen, wird das Zirkumflex (`^`) dem Befehl vorangestellt:
+
+Nushell Befehl:
+
+```
+> ls
+```
+
+Aufruf des Systembefehls:
+
+```
+> ^ls
+```
+

de/book/installation.md

@@ -38,9 +38,9 @@ Damit Rust richtig funktioniert, muss eine kompatible Compiler-Suite auf dem Sys
 
 * Linux: GCC oder Clang
 * macOS: Clang (Xcode installieren)
-* Windows: [Visual Studio Community Edition](https://visualstudio.microsoft.com/vs/community/)
-
-Für Windows, wenn die Visual Studio Community Edition installiert wird, sollte sichergestellt werden, dass auch die "C++ build tools" installiert werden, da `link.exe` benötigt wird, das als Teil der optionalen Installationsoptionen angeboten wird. Damit ist das System bereit für den nächsten Schritt.
+* Windows: MSVC (installieren von [Visual Studio Community Edition](https://visualstudio.microsoft.com/vs/community/) oder der [Visual Studio Build Tools](https://visualstudio.microsoft.com/downloads/#build-tools-for-visual-studio-2022))
+    * Sicherstellen, dass "Desktop development with C++" installiert wird
+    * Jede Visual Studio Edition sollte funktionieren (Community ist gratis)
 
 ### Rust installieren
 

de/book/mathematik.md

@@ -0,0 +1,72 @@
+# Mathematik
+
+Manchmal müssen lediglich ein paar Zahlen addiert werden, um eine Aufgabe zu erledigen. Nushell bietet dazu einen Satz an grundlegenden mathematischen Funktionen an. Mathematische Ausdrücke sind überall dort verfügbar, wo ein Befehl aufgerufen werden kann.
+
+## Addieren, Subtrahieren, Multiplizieren, Dividieren
+
+```
+> 1 + 3
+4
+```
+
+In Nushell, können die Operationen Addition, Subtraktion, Multiplikation und Division mit den dafür üblichen Symbolen `+`, `-`, `*` und `/` aufgerufen werden. Die Reihenfolge der Operatoren wird dabei berücksichtigt. Ein Beispiel: `1 + 2 * 3` wird behandelt als `1 + (2 * 3)`. Was zum nächsten Konzept führt: Klammern.
+
+## Klammern
+
+Klammern können verwendet werden, um mathematische Ausdrücke zu gruppieren. Das erlaubt es `(1 + 2) * 3` zu verwenden, um beispielsweise die Addition vor der Multiplikation auszuführen.
+
+## `in` und `not-in`
+
+Um herauszufinden, ob ein Wert in einem Datensatz ist oder nicht, können die Operatoren `in` und `not-in` verwendet werden.
+
+```
+> 1 in [1 2 3]
+true
+```
+
+```
+> 1 not-in [1 2 3]
+false
+```
+
+## =~ und !~
+
+Um zu überprüfen, ob ein String innerhalb eines anderen Strings zu finden ist oder nicht, können die Operatoren `=~` und `!~` verwendet werden.
+
+```
+> "foobar" =~ "foo"
+true
+```
+
+```
+> "foobar" !~ "baz"
+true
+```
+
+## Vergleiche
+
+Die folgenden Vergleichsoperatoren sind ebenfalls verfügbar:
+
+* `<` - kleiner als
+* `<=` - kleiner gleich
+* `>` - größer als
+* `>=` - größer gleich
+* `==` - gleich
+* `!=` - ungleich
+
+## Verknüpfungsoperatoren
+
+Nushell unterstützt auch die Operatoren `&&` ("und") und `||` ("oder") um zwei Operationen die Bool-Werte zurückgeben zu verbinden. Zum Beispiel: `ls | where name in ["one" "two" "three"] && size > 10kb`
+
+## Reihenfolge von Operationen
+
+Mathematische Operationen werden in der folgenden Reihenfolge ausgewertet (von der höchsten Priorität zur niedrigsten Priorität):
+
+* Klammern (`()`)
+* Multiplikation (`*`), Division (`/`) und Potenz (`**`)
+* Addition (`+`) und Subtraktion (`-`)
+
+```
+> 3 * (1 + 2)
+9
+```

de/book/plugins.md

@@ -0,0 +1,17 @@
+# Plugins
+
+Die Funktionen von Nushell können mittels Plugins erweitert werden. Diese Plugins können einen Großteil der selben Operationen ausführen, wie die internen Befehle. Noch dazu haben Plugins den Vorteil, dass sie separat und flexibel zu Nushell hinzugefügt werden können.
+
+Um ein Plugin hinzuzufügen, muss es erstellt werden und dann der Befehl `register` auf dieses Plugin aufgerufen werden. Wenn das getan wird, muss Nushell auch mitgeteilt werden, welches Protokoll vom Plugin verwendet wird. 
+
+Ein Beispiel:
+
+```
+> register ./my_plugins/nu-plugin-inc -e capnp
+```
+
+Wenn der Befehl registriert wurde, kann er als Teil der internen Befehle verwendet werden.
+
+```
+> inc --help
+```

de/book/variablen_und_unterausdruecke.md

@@ -0,0 +1,83 @@
+# Variablen und Unterausdrücke
+
+Es gibt zwei Arten von auszuwertenden Ausdrücken in Nushell: Variablen und Unterausdrücke. Diese werden durch das Dollar Symbol (`$`) eingeleitet. Das gibt den Hinweis, dass Nushell an dieser Stelle einen Ausdruck auswerten muss, um einen Wert zu erhalten, der für die Ausführung eines gesamten Befehls benötigt wird. Beide Formen des Ausdrucks haben eine einfache Variante und eine 'Pfad'-Variante, wenn mit komplexeren Daten gearbeitet wird.
+
+## Variablen
+
+Die einfachere Variante der auszuwertenden Ausdrücke ist die Variable. Während der Auswertung, wird die Variable durch ihren Wert ersetzt.
+
+Wenn eine Variable erzeugt wurde, kann der Inhalt dieser Variable ausgegeben werden, indem `$` vor dem Variablennamen verwendet wird:
+
+```
+> let my-value = 4
+> echo $my-value
+4
+```
+
+## Pfade von Variablen
+
+Ein Pfad einer Variable funktioniert ähnlich wie ein strukturierter Datentyp. Es kann mittels Referenzen auf den Inhalt der Variable beziehungsweise die Spalten in der Variable zugegriffen werden, um final bei einem bestimmten Wert zu landen. Wenn beispielsweise anstatt der `4` im obigen Beispiel, der Variablen eine Tabelle zugewiesen wurde:
+
+```
+> let my-value = [[name]; [testuser]]
+```
+
+Hier kann ein Pfad der Variable `$my-value` verwendet werden, um den Wert der Spalte `name` in nur einem Schritt zu bekommen:
+
+```
+> echo $my-value.name
+testuser
+```
+
+## Unterausdrücke
+
+Unterausdrücke können jederzeit ausgewertet und die Ergebnisse verwendet werden, indem der Ausdruck in Klammern `()` gepackt wird. Hinweis: In älteren Versionen von Nushell (älter als 0.32) wurde `$()` benutzt.
+
+Die Klammern enthalten eine Pipeline, die bis zum Ende durchlaufen wird und deren Ergebnis dann verwendet wird.  Hier einige Beispiele: `(ls)` würde den `ls` Befehl ausführen und die entsprechende Tabelle zurückgeben und `(git branch --show-current)` führt den externen Befehl `git` aus und gibt einen String mit dem Namen des aktuellen Branch zurück. Diese Klammern können auch verwendet werden, um mathematische Ausdrücke, wie `(2 + 3)`, auszuwerten.
+
+Unterausdrücke können auch ganze Pipelines statt nur einzelner Befehle enthalten. Um eine Liste von Dateien mit einer Größe größer als 10 Kilobytes zu bekommen, kann die folgende Pipeline verwendet und einer Variable zugewiesen werden:
+
+```
+> let names-of-big-files = (ls | where size > 10kb)
+> echo $names-of-big-files
+───┬────────────┬──────┬──────────┬──────────────
+ # │    name    │ type │   size   │   modified   
+───┼────────────┼──────┼──────────┼──────────────
+ 0 │ Cargo.lock │ File │ 155.3 KB │ 17 hours ago 
+ 1 │ README.md  │ File │  15.9 KB │ 17 hours ago 
+───┴────────────┴──────┴──────────┴──────────────
+```
+
+## Unterausdrücke und Pfade
+
+Unterausdrücke unterstützen auch Pfade. Um beispielsweise eine Liste der Dateinamen im aktuellen Ordner zu bekommen, kann diese Pipeline verwendet werden:
+
+```
+> ls | get name
+```
+
+Dasselbe Ergebnis kann auch in nur einem Schritt erreicht werden, indem ein Unterausdruck mit Pfad verwendet wird:
+
+```
+> echo (ls).name
+```
+
+Welcher Stil gewählt wird, hängt vom Anwendungsfall und den persönlichen Vorlieben ab.
+
+## Short-hand Unterausdrücke
+
+Nushell erlaubt den Zugriff auf Spalten in Tabellen in Unterausdrücken durch einfache Short-Hands. Wenn beispielsweise nur Zeilen in `ls` angezeigt werden sollen, in der die Größe der Datei größer als 10 Kilobytes ist, kann der folgende Befehl verwendet werden:
+
+```
+> ls | where size > 10kb
+```
+
+`where size > 10kb`  ist ein Befehl mit zwei Teilen: Dem Befehlsnamen `where` und dem short-hand Ausdruck `size > 10kb`. Hier wird auch klar, warum das Ganze short-hand heißt: `size` ist hier die gekürzte Version von `$it.size`. Das Ganze könnte auch mit einer der folgenden ausführlicheren Varianten erreicht werden:
+
+```
+> ls | where $it.size > 10kb
+> ls | where ($it.size > 10kb)
+> ls | where {|$it| $it.size > 10kb }
+```
+
+Damit diese short-hand Syntax funktioniert, muss der Name der Spalte auf der linken Seite der Operation sein (wie bei `size` in `size > 10kb`).