Am tradus in germana capitolul 6 din "Tour of Rust"

lessons/de/chapter_6.yaml

@@ -0,0 +1,189 @@
+- title: Kapitel 6 – Text
+  content_markdown: >
+    Wenn Sie das Modul zur Pflege von Rust einsetzen, müssen Sie es sich merken, bevor Sie darüber reden
+    Weitere Informationen zum Text.
+
+    Rust hat viele wichtige Texte in verschiedenen Texten und Modulen geschrieben, die es zu repräsentieren gilt
+    Nachdem Sie die Oktavebene erreicht haben, müssen Sie sich mit der alten Schule vertraut machen.
+
+    aus anderen Sprachen. Allerdings verfügt Rust über viele großartige Tools zur Verwaltung 
+    diese Bedenken.
+- title: String-Literale
+  content_markdown: >
+    String-Literale werden immer dargestellt
+    unter Verwendung der **utf-8**-Kodierung des Unicode-Zeichensatzes.
+
+    String-Literale sind vom Typ „&'static str“:
+
+    * '&' dient als Verweis auf den Speicherort, ohne dass „&mut“ vom Compiler verwendet wird
+    Sie haben keine Änderungserlaubnis.
+
+    * 'static' bedeutet, dass die String-Daten bis zum Ende verfügbar sind
+    das Programm (es stürzt nie ab).
+
+    * 'str' bezeichnet eine Folge von Bytes, die immer gültigen Text im **utf-8**-Format bilden
+
+    Speicherdetails:
+
+    * Der Rust-Compiler wird die Zeichenfolge wahrscheinlich in das Datensegment von einfügen
+    Programmspeicher.
+  code: >-
+    https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=fn+main%28%29+%7B%0A++++let+a%3A+%26%27static+str+%3D+%22hallo+%F0%9F%A6%80%22%3B%0A++++println%21%28%22%7B%7D+%7B%7D%22%2C+a%2C+a.len%28%29%29%3B%0A%7D%0A
+- title: Was ist utf-8
+  content_markdown: "Da immer mehr Sprachen auf Computern verwendet wurden, brauchte die Welt Möglichkeiten, mehr Textzeichen darzustellen, als ASCII erlaubte (1 Byte erlaubte nur 256 Zeichen).\n\nEs wurde **utf-8** eingeführt , mit einer variablen Länge von Bytes (1-4 Bytes), was den Bereich möglicher Zeichen erheblich vergrößert.\n\nEin Vorteil von Zeichen variabler Größe besteht darin, dass der Text keine unnötigen Bytes mehr für sehr häufige ASCII-Zeichen enthält (die nur 1 erfordern). Byte in **utf-8**).\n\nEin Nachteil von Zeichen variabler Größe besteht darin, dass Zeichensuchen nicht mehr schnell durchgeführt werden können \n(** konstante Zeit O(1 )**) mit einfacher Indizierung (Beispiel : `my_text[3]`, um das 4. Zeichen zu erhalten).\nDie vorherigen Zeichen können variable Breiten haben, wodurch sich ändert, wo das 4. Zeichen tatsächlich in der Bytefolge beginnt.\n\nStattdessen müssen wir eine Schleife durch ein **utf- 8** Bytefolge, um zu verstehen, wo die Unicode-Zeichen tatsächlich beginnen (** lineare Zeit **O(n)**).\n\nFerris: „Meistens bin ich einfach nur froh, dass ich **utf-8 habe ** um Emoticons mit meinen Unterwasserfreunden zu rendern.\"\n\n<span class=\"emoji\">\U0001F420\U0001F419\U0001F41F\U0001F42C\U0001F40B</span>\n"
+- title: Escape-Sequenzen
+  content_markdown: >
+    Es ist eine Herausforderung, bestimmte Zeichen visuell darzustellen, daher müssen Escape-Sequenzen (*Escape-Codes*)
+    Sie ermöglichen es uns, ein Symbol an ihre Stelle zu setzen.
+
+
+    Rust unterstützt gängige Escape-Codes von C-basierten Sprachen:
+
+    * `\n` - Neue Zeile
+
+    * `\r` - Wagenrücklauf
+
+    * `\t` - tab
+
+    * `\\\` - backslash
+
+    * `\0` - nul
+
+    * `\'` - Einzelzitate
+
+
+    Die vollständige Liste ist vorhanden
+    [Hier](https://doc.rust-lang.org/reference/tokens.html).
+  code: >-
+    https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&code=fn+main%28%29+%7B%0A++++let+a%3A+%26%27static+str+%3D+%22Ferris+sagt%3A%5Ct%5C%22hallo%5C%22%22%3B%0A++++println%21%28%22%7B%7D%22%2C+a%29%3B%0A%7D%0A
+- title: String-Literale in mehreren Zeilen
+  content_markdown: |
+    Strings in Rust sind standardmäßig mehrzeilig.
+
+    Verwenden Sie am Ende der Zeile ein `\`, wenn Sie keinen Zeilenumbruch wünschen.
+  code: >-
+    https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=fn%20main()%20%7B%0A%20%20%20%20let%20haiku%3A%20%26'static%20str%20%3D%20%22%0A%20%20%20%20%20%20%20%20I%20write%2C%20erase%2C%20rewrite%0A%20%20%20%20%20%20%20%20Erase%20again%2C%20and%20then%0A%20%20%20%20%20%20%20%20A%20poppy%20blooms.%0A%20%20%20%20%20%20%20%20-%20Katsushika%20Hokusai%22%3B%0A%20%20%20%20println!(%22%7B%7D%22%2C%20haiku)%3B%0A%20%20%20%20%0A%20%20%20%20%0A%20%20%20%20println!(%22salutare%20%5C%0A%20%20%20%20lume%22)%20%2F%2F%20observati%20cum%20spatierea%20de%20dinainte%20de%20%22l%22%20este%20ignorata%0A%7D%0A
+- title: Rohe Literalzeichenfolgen
+  content_markdown: >
+    Rohzeichenfolgen (auf Englisch *raw strings*) ermöglichen es uns, eine Folge von Zeichen zu schreiben,
+    Wort für Wort, beginnend mit `r#` und endend mit `#`. Dies ermöglicht uns das Einfügen
+
+    Zeichen, die sonst dazu führen könnten, dass wir eine normale Zeichenfolge mit einem Literal verwechseln
+    (z. B. doppelte Anführungszeichen und Backslashes).
+  code: >-
+    https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=fn%20main()%20%7B%0A%20%20%20%20let%20a%3A%20%26'static%20str%20%3D%20r%23%22%0A%20%20%20%20%20%20%20%20%3Cdiv%20class%3D%22sfat%22%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20Sirurile%20de%20caractere%20brute%20sunt%20folositoare%20in%20unele%20situatii.%0A%20%20%20%20%20%20%20%20%3C%2Fdiv%3E%0A%20%20%20%20%20%20%20%20%22%23%3B%0A%20%20%20%20println!(%22%7B%7D%22%2C%20a)%3B%0A%7D%0A
+- title: Literale Zeichenfolgen aus Dateien
+  content_markdown: >
+    Wenn Sie sehr großen Text haben, sollten Sie das Makro „include_str!“ verwenden
+    So fügen Sie Text aus lokalen Dateien in Ihr Programm ein:
+
+
+    ```rust
+
+    let halo_html = include_str!("halo.html");
+
+    ```
+- title: Zeichen-Teilzeichenfolgen
+  content_markdown: >
+    Eine Teilzeichenfolge von Zeichen (im Englischen *string slice*) ist ein Verweis auf eine Folge von Bytes im Speicher, die vorhanden sein müssen
+    immer im gültigen UTF-8-Format vorliegen.
+
+    Ein Teilstring eines Teilstrings (auf Englisch *sub-slice*) von „str“ muss ebenfalls im gültigen UTF-8-Format vorliegen.
+
+
+    Gängige Methoden von `&str`:
+
+    * `len` ermitteln Sie die Länge des Zeichenfolgenliterals in Bytes (nicht die Anzahl der Zeichen).
+
+    * `starts_with`/`ends_with` für Grundprüfungen.
+
+    * `is_empty` gibt *true* zurück, wenn die Länge null ist.
+
+    * `find` gibt einen zurück `Option<usize>` der ersten Stelle in einem Text.
+  code: >-
+    https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=fn%20main()%20%7B%0A%20%20%20%20let%20a%20%3D%20%22salut%20%F0%9F%A6%80%22%3B%0A%20%20%20%20println!(%22%7B%7D%22%2C%20a.len())%3B%0A%20%20%20%20let%20primul_cuvant%20%3D%20%26a%5B0..5%5D%3B%0A%20%20%20%20let%20al_doilea_cuvant%20%3D%20%26a%5B6..10%5D%3B%0A%20%20%20%20%2F%2F%20let%20jumatate_de_crab%20%3D%20%26a%5B6..8%5D%3B%20E%C8%98UEAZ%C4%82%0A%20%20%20%20%2F%2F%20Rust%20nu%20accepta%20subsiruri%20formate%20din%20caractere%20Unicode%20invalide%0A%20%20%20%20println!(%22%7B%7D%20%7B%7D%22%2C%20primul_cuvant%2C%20al_doilea_cuvant)%3B%0A%7D%0A
+- title: der Typ `char`
+  content_markdown: >
+    Angesichts der vielen Schwierigkeiten bei der Arbeit mit Unicode bietet Rust eine Möglichkeit dazu
+    Nimmt eine Folge von UTF-8-Bytes als Zeichenvektor vom Typ `char`.
+
+
+    Ein `char` ist immer 4 Bytes lang (was eine effiziente Suche nach einzelnen Zeichen ermöglicht).
+  code: >-
+    https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=fn%20main()%20%7B%0A%20%20%20%20%2F%2F%20colecteaza%20caracterele%20ca%20vector%20de%20char-uri%0A%20%20%20%20let%20chars%20%3D%20%22salut%20%F0%9F%A6%80%22.chars().collect%3A%3A%3CVec%3Cchar%3E%3E()%3B%0A%20%20%20%20println!(%22%7B%7D%22%2C%20chars.len())%3B%20%2F%2F%20ar%20trebui%20sa%20fie%207%0A%20%20%20%20%2F%2F%20cum%20un%20char%20ocupa%204%20biti%2C%20putem%20converti%20la%20u32%0A%20%20%20%20println!(%22%7B%7D%22%2C%20chars%5B3%5D%20as%20u32)%3B%0A%7D%0A
+- title: Zeichenfolgen
+  content_markdown: >
+    Eine Zeichenfolge (auf Englisch *string*) ist eine Struktur, die eine Folge von UTF-8-Bytes im Heap-Speicher enthält.
+
+
+    Da sich sein Speicher auf dem Heap befindet, kann er erweitert, geändert usw. werden. auf eine Weise, die Saiten hervorruft
+    von Literalzeichen kann nicht geändert werden.
+
+
+    Gängige Methoden:
+
+
+    * `push_str` um mehrere UTF-8-Bytes an das Ende einer Zeichenfolge anzuhängen.
+
+    * `replace` um UTF-8-Byte-Sequenzen durch andere zu ersetzen.
+
+    * `to_lowercase`/`to_uppercase` um zwischen Groß- und Kleinschreibung zu wechseln.
+
+    * `trim` um Leerzeichen zu entfernen.
+
+
+    Wenn eine Zeichenfolge gelöscht wird (drop), wird auch ihr Heapspeicher gelöscht.
+
+
+    Strings haben einen `+`-Operator, der den String mit einem `&str` erweitert. (Der String auf der linken Seite ist `verbraucht` und sein Puffer
+    wird wiederverwendet, um den Endwert zu speichern. Die Zeichenfolge auf der rechten Seite wurde nur ausgeliehen, um die Verkettung durchzuführen.)
+    aber es ist möglicherweise nicht so ergonomisch, wie Sie hoffen.
+  code: >-
+    https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=fn%20main()%20%7B%0A%20%20%20%20let%20mut%20salutarelume%20%3D%20String%3A%3Afrom(%22salutare%22)%3B%0A%20%20%20%20salutarelume.push_str(%22%20lume%22)%3B%0A%20%20%20%20salutarelume%20%3D%20salutarelume%20%2B%20%22!%22%3B%0A%20%20%20%20println!(%22%7B%7D%22%2C%20salutarelume)%3B%0A%7D%0A
+- title: Text als Funktionsparameter
+  content_markdown: >
+    Zeichenfolgen (Literale) werden im Allgemeinen als Teilzeichenfolgen an Funktionen übergeben.
+
+    Dies bietet in den meisten Szenarien große Flexibilität, wenn es nicht benötigt wird
+    das Eigentum tatsächlich zu übertragen.
+  code: >-
+    https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=fn%20spune_tare(msg%3A%26str)%7B%0A%20%20%20%20println!(%22%7B%7D!!!%22%2Cmsg.to_string().to_uppercase())%3B%0A%7D%0A%0Afn%20main()%20%7B%0A%20%20%20%20%2F%2F%20spune_tare%20poate%20imprumuta%20un%20%26'static%20str%20ca%20%26str%0A%20%20%20%20spune_tare(%22salut%22)%3B%0A%20%20%20%20%2F%2F%20spune_tare%20poate%2C%20de%20asemenea%2C%20imprumuta%20un%20String%20ca%20%26str%0A%20%20%20%20spune_tare(%26String%3A%3Afrom(%22la%20revedere%22))%3B%0A%7D%0A
+- title: Konstruktion und Charaktercharakter
+  content_markdown: |
+    `concat` und `join` sind zwei einfache, aber effektive Möglichkeiten, Strings zu erstellen.
+  code: >-
+    https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=fn%20main()%20%7B%0A%20%20%20%20let%20salutarelume%20%3D%20%5B%22salutare%22%2C%20%22%20%22%2C%20%22lume%22%2C%20%22!%22%5D.concat()%3B%0A%20%20%20%20let%20abc%20%3D%20%5B%22a%22%2C%20%22b%22%2C%20%22c%22%5D.join(%22%2C%22)%3B%0A%20%20%20%20println!(%22%7B%7D%22%2C%20salutarelume)%3B%0A%20%20%20%20println!(%22%7B%7D%22%2Cabc)%3B%0A%7D%0A
+- title: Zeichenfolgen formatieren
+  content_markdown: >
+    Mit dem Makro `format!` können wir eine Zeichenfolge erstellen, indem wir eine parametrisierte Zeichenfolge definieren
+    mit Platzhaltern dafür, wo und wie die Werte platziert werden sollen (Beispiel: `{}`).
+
+
+    `format!` verwendet die gleichen parametrisierten Strings wie `println!`.
+
+
+    Die Möglichkeiten dieser Funktion sind zu groß für die *Rundgang durch Rust*;
+    siehe Dokumentation [Hier](https://doc.rust-lang.org/std/fmt/).
+  code: >-
+    https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=fn%20main()%20%7B%0A%20%20%20%20let%20a%20%3D%2042%3B%0A%20%20%20%20let%20f%20%3D%20format!(%22secretul%20vietii%3A%20%7B%7D%22%2Ca)%3B%0A%20%20%20%20println!(%22%7B%7D%22%2Cf)%3B%0A%7D%0A
+- title: Konvertieren von Zeichenfolgen
+  content_markdown: |
+    Viele Typen können mit `to_string` in einen String konvertiert werden.
+
+    Die generische Funktion `parse` kann zum Konvertieren von Zeichenfolgen (Literalen) verwendet werden.
+    in einem typisierten Wert. Diese Funktion gibt ein `Result` zurück, da sie möglicherweise fehlschlägt.
+  code: >-
+    https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=fn%20main()%20-%3E%20Result%3C()%2C%20std%3A%3Anum%3A%3AParseIntError%3E%20%7B%0A%20%20%20%20let%20a%20%3D%2042%3B%0A%20%20%20%20let%20a_string%20%3D%20a.to_string()%3B%0A%20%20%20%20let%20b%20%3D%20a_string.parse%3A%3A%3Ci32%3E()%3F%3B%0A%20%20%20%20println!(%22%7B%7D%20%7B%7D%22%2C%20a%2C%20b)%3B%0A%20%20%20%20Ok(())%0A%7D%0A
+- title: Kapitel 6 - Schlüssig
+  content_markdown: >
+    Jetzt kennen Sie die Grundlagen des Textes! Wie Sie gesehen haben, erledigt Unicode den Zweck
+    mit dem etwas komplizierteren Text, aber der Standardbibliothek 
+
+    es verfügt über viele Funktionen, die die Verwaltung erleichtern.  
+
+
+    Bisher haben wir die Rust-Sprache hauptsächlich durch die Linse eines prozeduralen Paradigmas betrachtet
+    (also nur Funktionen und Daten),
+
+    Aber es ist jetzt an der Zeit, über die Eigenschaften und Fähigkeiten zu sprechen, die sich daraus ergeben
+    das objektorientierte Paradigma der Rust-Programmiersprache.