From b611341577d5cd11fd8cb203da5748d77c5842fa Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sat, 11 May 2024 17:27:32 +0200 Subject: [PATCH 01/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/appendix-06-translation.md | 2 +- src/appendix-07-nightly-rust.md | 7 +++++++ 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/src/appendix-06-translation.md b/src/appendix-06-translation.md index 95d55a89..766c9fc9 100644 --- a/src/appendix-06-translation.md +++ b/src/appendix-06-translation.md @@ -23,7 +23,7 @@ eine neue Übersetzung zu informieren! - [Esperanto](https://github.com/psychoslave/Rust-libro) - [ελληνική](https://github.com/TChatzigiannakis/rust-book-greek) - [Svenska](https://github.com/sebras/book) -- [Farsi](https://github.com/pomokhtari/rust-book-fa) +- [Farsi](https://github.com/RustFarsi/book) - [Deutsch](https://github.com/rust-lang-de/rustbook-de) - [हिंदी](https://github.com/venkatarun95/rust-book-hindi) - [ไทย](https://github.com/rust-lang-th/book-th) diff --git a/src/appendix-07-nightly-rust.md b/src/appendix-07-nightly-rust.md index 2810440f..46606523 100644 --- a/src/appendix-07-nightly-rust.md +++ b/src/appendix-07-nightly-rust.md @@ -127,6 +127,13 @@ melden und sie vor der nächsten stabilen Version korrigieren lassen! Ein Bruch in einer Beta-Version ist relativ selten, aber `rustc` ist immer noch ein Stück Software und es gibt Fehler. +### Wartungsdauer + +Das Rust-Projekt unterstützt die neueste stabile Version. Wenn eine neue +stabile Version veröffentlicht wird, erreicht die alte Version ihr +Lebensende (engl. end of life, EOL). Das bedeutet, dass jede Version +sechs Wochen lang unterstützt wird. + ### Instabile Funktionalitäten Bei diesem Veröffentlichungsmodell gibt es noch einen weiteren Haken: Instabile From a6f4122c44696b25963641cb7c8f1190785990ef Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sat, 11 May 2024 17:31:02 +0200 Subject: [PATCH 02/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch00-00-introduction.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch00-00-introduction.md b/src/ch00-00-introduction.md index 8f616b25..f8e6d2af 100644 --- a/src/ch00-00-introduction.md +++ b/src/ch00-00-introduction.md @@ -34,8 +34,8 @@ Systemprogrammierung: Rust-Ökosystem schmerzlos und konsistent. * Das Formatierungstool Rustfmt sorgt für einen einheitlichen Codierstil bei den Entwicklern. -* Der Rust Sprachdienst (Language Server) ermöglicht Codevervollständigung und - im Code angezeigte Fehlermeldungen innerhalb der Entwicklungsumgebung (IDE). +* Der rust-analyzer ermöglicht Codevervollständigung und im Code angezeigte + Fehlermeldungen innerhalb der Entwicklungsumgebung (IDE). Durch den Einsatz dieser und anderer Werkzeuge des Rust-Ökosystems können Entwickler produktiv arbeiten, während sie Code auf Systemebene schreiben. From df524201e01a0a7df21e1e0da9e6c737aa313f95 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sat, 11 May 2024 17:49:13 +0200 Subject: [PATCH 03/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch01-01-installation.md | 17 +++++------------ 1 file changed, 5 insertions(+), 12 deletions(-) diff --git a/src/ch01-01-installation.md b/src/ch01-01-installation.md index 5704e0e6..16d2974e 100644 --- a/src/ch01-01-installation.md +++ b/src/ch01-01-installation.md @@ -67,17 +67,10 @@ kannst du das Paket `build-essential` installieren. Rufe [https://www.rust-lang.org/tools/install][install] auf und folge den Anweisungen, um Rust in Windows zu installieren. Während der Installation -wirst du eine Meldung erhalten, dass du auch die MSVC Bauwerkzeuge für Visual -Studio 2013 oder höher benötigst. - -Um die Bauwerkzeuge zu erhalten, musst du [Visual Studio 2022][visualstudio] -installieren. Wenn du gefragt wirst, welche Komponenten installiert werden -sollen, gib folgendes an: - -* „Desktop Development with C++“ -* Das Windows 10 oder 11 SDK -* Das englische Sprachpaket zusammen mit einem beliebigen anderen Sprachpaket - deiner Wahl. +wirst du aufgefordert, Visual Studio zu installieren. Dieses enthält einen +Linker und die nativen Bibliotheken, die zum Kompilieren von Programmen +benötigt werden. Wenn du an dieser Stelle weitere Hilfe brauchst, geht zu +[https://rust-lang.github.io/rustup/installation/windows-msvc.html][msvc]. Der Rest dieses Buchs verwendet Befehle, die sowohl in *cmd.exe* als auch in der PowerShell funktionieren. Falls es spezifische Unterschiede geben sollte, @@ -152,5 +145,5 @@ Standardbibliothek verwenden sollst, dann schau in der API-Dokumentation nach! [community]: https://www.rust-lang.org/community [install]: https://www.rust-lang.org/tools/install +[msvc]: https://rust-lang.github.io/rustup/installation/windows-msvc.html [otherinstall]: https://forge.rust-lang.org/infra/other-installation-methods.html -[visualstudio]: https://visualstudio.microsoft.com/downloads/ From e335287f76dbd0fc7f80fb717e4c54abd8439984 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sat, 11 May 2024 17:54:33 +0200 Subject: [PATCH 04/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch02-00-guessing-game-tutorial.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/ch02-00-guessing-game-tutorial.md b/src/ch02-00-guessing-game-tutorial.md index a89b527f..224d4a8f 100644 --- a/src/ch02-00-guessing-game-tutorial.md +++ b/src/ch02-00-guessing-game-tutorial.md @@ -611,10 +611,10 @@ Code deines Projekts in die Versionskontrolle eingecheckt. Wenn du eine Kiste aktualisieren *willst*, bietet Cargo den Befehl `update` an, der die Datei *Cargo.lock* ignoriert und alle neuesten Versionen, die deinen Spezifikationen entsprechen, in *Cargo.toml* herausfindet. Cargo schreibt diese -Versionen dann in die Datei *Cargo.lock*. Andernfalls wird Cargo standardmäßig -nur nach Versionen größer als 0.8.5 und kleiner als 0.9.0 suchen. Wenn die -Kiste `rand` zwei neue Versionen 0.8.6 und 0.9.0 veröffentlicht hat, würdest du -folgendes sehen, wenn du `cargo update` ausführst: +Versionen dann in die Datei *Cargo.lock*. In diesem Fall wird Cargo nur nach +Versionen größer als 0.8.5 und kleiner als 0.9.0 suchen. Wenn die Kiste `rand` +zwei neue Versionen 0.8.6 und 0.9.0 veröffentlicht hat, würdest du folgendes +sehen, wenn du `cargo update` ausführst: ```console $ cargo update @@ -865,7 +865,7 @@ numerischen Typ zu schließen. Der Grund für den Fehler liegt darin, dass Rust eine Zeichenkette und einen Zahlentyp nicht vergleichen kann. Letztendlich wollen wir den `String`, den das Programm als Eingabe liest, in -einen echten Zahlentyp umwandeln, damit wir ihn numerisch mit der Geheimzahl +einen Zahlentyp umwandeln, damit wir ihn numerisch mit der Geheimzahl vergleichen können. Das tun wir, indem wir folgendes zum `main`-Funktionsrumpf hinzufügen: From f55f17898dd3d8b79940bbefadf91fa4ae916be9 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sat, 11 May 2024 18:00:57 +0200 Subject: [PATCH 05/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch03-05-control-flow.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/ch03-05-control-flow.md b/src/ch03-05-control-flow.md index 287639fd..ac16c799 100644 --- a/src/ch03-05-control-flow.md +++ b/src/ch03-05-control-flow.md @@ -367,6 +367,9 @@ wir ein Semikolon, um die Anweisung zu beenden, die `result` den Wert zuweist. Schließlich geben wir den Wert in `result` aus, der in diesem Fall `20` beträgt. +Du kannst auch innerhalb einer Schleife `return` aufrufen. Während `break` nur +die aktuelle Schleife verlässt, verlässt `return` immer die aktuelle Funktion. + #### Schleifenlabel zur eindeutigen Unterscheidung mehrerer Schleifen Wenn du Schleifen innerhalb von Schleifen hast, gelten `break` und `continue` @@ -460,7 +463,7 @@ wären, wenn du `loop`, `if`, `else` und `break` verwenden würdest, und es ist klarer. Solange eine Bedingung zu `true` auswertet, läuft der Code ab; andernfalls wird die Schleife verlassen. -#### Wiederholen anhand einer Kollektion mit `for` +#### Durchlaufen einer Kollektion mit `for` Du kannst das `while`-Konstrukt verwenden, um die Elemente einer Kollektion, z.B. ein Array, in einer Schleife zu durchlaufen. Die Schleife in Codeblock 3-4 From 848af6a9674e4a1a8c85f3de1f2be9199b8e113c Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sat, 11 May 2024 18:09:12 +0200 Subject: [PATCH 06/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch04-03-slices.md | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/ch04-03-slices.md b/src/ch04-03-slices.md index e67d15d5..36816de3 100644 --- a/src/ch04-03-slices.md +++ b/src/ch04-03-slices.md @@ -1,8 +1,9 @@ ## Der Anteilstyp (slice) Mit *Anteilstypen* kannst du auf eine zusammenhängende Folge von Elementen in -einer Kollektion referenzieren anstatt auf die gesamte Kollektion. Ein -Anteilstyp ist eine Art Referenz und hat daher keine Eigentümerschaft. +einer [Kollektion][collection] referenzieren anstatt auf die gesamte +Kollektion. Ein Anteilstyp ist eine Art Referenz und hat daher keine +Eigentümerschaft. Hier ist ein kleines Programmierproblem: Schreibe eine Funktion, die eine Zeichenkette mit durch Leerzeichen getrennten Wörtern entgegennimmt und das @@ -523,6 +524,6 @@ Datenteilen zu einer `struct` ansehen. [ch13-2]: ch13-02-iterators.html [ch6]: ch06-02-match.html#muster-die-werte-binden -[deref-coercions]: -ch15-02-deref.html#implizite-automatische-umwandlung-mit-funktionen-und-methoden +[collection]: ch08-00-common-collections.md +[deref-coercions]: ch15-02-deref.html#implizite-automatische-umwandlung-mit-funktionen-und-methoden [strings]: ch08-02-strings.html From 6375427185da3b969d6ae26d06b077fbad29923e Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sat, 11 May 2024 18:13:58 +0200 Subject: [PATCH 07/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch05-01-defining-structs.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch05-01-defining-structs.md b/src/ch05-01-defining-structs.md index 71a29037..2580eb6c 100644 --- a/src/ch05-01-defining-structs.md +++ b/src/ch05-01-defining-structs.md @@ -224,7 +224,7 @@ fn main() { ``` Codeblock 5-6: Erstellen einer neuen `User`-Instanz unter -Verwendung eines Werts von `user1`. +Verwendung aller Werte von `user1` bis auf einen. Durch Verwenden der Strukturaktualisierungssyntax können wir dasselbe Ergebnis mit weniger Code erreichen, wie Codeblock 5-7 zeigt. Die Syntax `..` gibt an, From e78f2a1dc0dda19235e52ac0ad8fc1db7a39d113 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sat, 11 May 2024 18:41:07 +0200 Subject: [PATCH 08/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch07-01-packages-and-crates.md | 25 ++++++++++--------- ...ng-modules-to-control-scope-and-privacy.md | 23 ++++++++--------- ...referring-to-an-item-in-the-module-tree.md | 6 ++--- ...g-paths-into-scope-with-the-use-keyword.md | 11 ++++---- ...separating-modules-into-different-files.md | 2 +- 5 files changed, 33 insertions(+), 34 deletions(-) diff --git a/src/ch07-01-packages-and-crates.md b/src/ch07-01-packages-and-crates.md index 1f065b42..51e42a30 100644 --- a/src/ch07-01-packages-and-crates.md +++ b/src/ch07-01-packages-and-crates.md @@ -41,12 +41,13 @@ Bibliothekskiste, von der die binäre Kiste abhängt. Andere Projekte können vo der Cargo-Bibliothekskiste abhängen, um die gleiche Logik wie das Cargo-Befehlszeilenwerkzeug zu verwenden. -Ein Paket kann beliebig viele Binärkisten enthalten, aber höchstens eine +Es gibt zwei Arten von Kisten: Binärkisten und Bibliothekskisten. Ein Paket +kann beliebig viele Binärkisten enthalten, aber höchstens eine Bibliothekskiste. Ein Paket muss mindestens eine Kiste enthalten, unabhängig davon, ob es sich um eine Bibliothek oder eine binäre Kiste handelt. Lass uns durchgehen, was passiert, wenn wir ein Paket erstellen. Zuerst geben -wir den Befehl `cargo new` ein: +wir den Befehl `cargo new my-project` ein: ```console $ cargo new my-project @@ -58,16 +59,16 @@ $ ls my-project/src main.rs ``` -Nachdem wir `cargo new` ausgeführt haben, verwenden wir `ls`, um zu sehen, was -Cargo erzeugt. Im Projektverzeichnis gibt es eine Datei *Cargo.toml*, die uns -ein Paket gibt. Es gibt auch ein Verzeichnis *src*, das *main.rs* enthält. -Öffne *Cargo.toml* in deinem Texteditor und beachte, dass *src/main.rs* nicht -erwähnt wird. Cargo folgt der Konvention, dass *src/main.rs* die Kistenwurzel -einer binären Kiste mit dem gleichen Namen wie das Paket ist. Ebenso weiß -Cargo, dass, wenn das Paketverzeichnis *src/lib.rs* enthält, das Paket eine -Bibliothekskiste mit dem gleichen Namen wie das Paket enthält, und *src/lib.rs* -deren Kistenstamm ist. Cargo übergibt die Kistenwurzel-Dateien an `rustc`, um -die Bibliothek oder Binärdatei zu bauen. +Nachdem wir `cargo new my-project` ausgeführt haben, verwenden wir `ls`, um zu +sehen, was Cargo erzeugt. Im Projektverzeichnis gibt es eine Datei +*Cargo.toml*, die uns ein Paket gibt. Es gibt auch ein Verzeichnis *src*, das +*main.rs* enthält. Öffne *Cargo.toml* in deinem Texteditor und beachte, dass +*src/main.rs* nicht erwähnt wird. Cargo folgt der Konvention, dass +*src/main.rs* die Kistenwurzel einer binären Kiste mit dem gleichen Namen wie +das Paket ist. Ebenso weiß Cargo, dass, wenn das Paketverzeichnis *src/lib.rs* +enthält, das Paket eine Bibliothekskiste mit dem gleichen Namen wie das Paket +enthält, und *src/lib.rs* deren Kistenstamm ist. Cargo übergibt die +Kistenwurzel-Dateien an `rustc`, um die Bibliothek oder Binärdatei zu bauen. Hier haben wir ein Paket, das nur *src/main.rs* enthält, d.h. es enthält nur eine binäre Kiste mit dem Namen `my-project`. Wenn ein Paket *src/main.rs* und diff --git a/src/ch07-02-defining-modules-to-control-scope-and-privacy.md b/src/ch07-02-defining-modules-to-control-scope-and-privacy.md index b49c58f7..3b0703fe 100644 --- a/src/ch07-02-defining-modules-to-control-scope-and-privacy.md +++ b/src/ch07-02-defining-modules-to-control-scope-and-privacy.md @@ -7,17 +7,14 @@ Schlüsselwort `pub`, um Elemente öffentlich zu machen. Wir werden auch das Schlüsselwort `as`, externe Pakete und den Stern-Operator (glob operator) besprechen. -Zunächst werden wir mit einer Liste von Regeln beginnen, damit du bei der -künftigen Organisation deines Codes leicht nachschlagen kannst. Dann werden wir -jede der Regeln im Detail erklären. - ### Spickzettel für Module -Hier bieten wir eine Kurzreferenz darüber, wie Module, Pfade, das Schlüsselwort -`use` und das Schlüsselwort `pub` im Compiler funktionieren und wie die meisten -Entwickler ihren Code organisieren. Wir werden im Laufe dieses Kapitels -Beispiele für jede dieser Regeln durchgehen, aber dies ist ein guter Ort, um -sich daran zu erinnern, wie Module funktionieren. +Bevor wir zu den Details von Modulen und Pfaden kommen, stellen wir hier eine +kurze Referenz zusammen, wie Module, Pfade, das Schlüsselwort `use` und das +Schlüsselwort `pub` im Compiler funktionieren und wie die meisten Entwickler +ihren Code organisieren. Wir werden im Laufe dieses Kapitels Beispiele für jede +dieser Regeln durchgehen, aber dies ist ein guter Ort, um sich daran zu +erinnern, wie Module funktionieren. - **Beginne bei der Kistenwurzel (crate root)**: Beim Kompilieren einer Kiste sucht der Compiler zuerst in der Wurzeldatei der Kiste (normalerweise @@ -132,7 +129,7 @@ der Küche, Geschirrspüler waschen ab und Manager erledigen Verwaltungsarbeiten Um unsere Kiste auf diese Weise zu strukturieren, können wir ihre Funktionen in verschachtelten Modulen organisieren. Erstelle eine neue Bibliothek namens -`restaurant`, indem du `cargo new --lib restaurant` ausführst; gib dann den +`restaurant`, indem du `cargo new --lib restaurant` ausführst. Gib dann den Code in Codeblock 7-1 in *src/lib.rs* ein, um einige Module und Funktionssignaturen zu definieren. Hier ist der vordere Teil des Hauses: @@ -196,9 +193,9 @@ crate Codeblock 7-2: Modulbaum für den Code in Codeblock 7-1 -Dieser Baum zeigt, wie einige der Module ineinander verschachtelt sind; z.B. -ist `hosting` innerhalb von `front_of_house`. Der Baum zeigt auch, dass einige -Module *Geschwister* voneinander sind, was bedeutet, dass sie im selben Modul +Dieser Baum zeigt, wie einige Module in anderen Modulen verschachtelt sind; +z.B. ist `hosting` innerhalb von `front_of_house`. Der Baum zeigt auch, dass +einige Module *Geschwister* sind, was bedeutet, dass sie im selben Modul definiert sind; `hosting` und `serving` sind Geschwister, die innerhalb von `front_of_house` definiert sind. Wenn Modul A innerhalb von Modul B enthalten ist, sagen wir, dass Modul A das *Kind* (child) von Modul B ist und dass Modul diff --git a/src/ch07-03-paths-for-referring-to-an-item-in-the-module-tree.md b/src/ch07-03-paths-for-referring-to-an-item-in-the-module-tree.md index 5a7199d0..8da01a41 100644 --- a/src/ch07-03-paths-for-referring-to-an-item-in-the-module-tree.md +++ b/src/ch07-03-paths-for-referring-to-an-item-in-the-module-tree.md @@ -86,7 +86,7 @@ wahrscheinlicher ist, dass Codedefinitionen und Elementaufrufe unabhängig voneinander verschoben werden. Lass uns versuchen, Codeblock 7-3 zu kompilieren, und herausfinden, warum er -sich noch nicht kompilieren lässt! Der Fehler, den wir erhalten, ist in +sich noch nicht kompilieren lässt! Die Fehler, die wir erhalten, sind in Codeblock 7-4 zu sehen. ```console @@ -181,7 +181,7 @@ pub fn eat_at_restaurant() { Codeblock 7-5: Deklarieren des Moduls `hosting` als `pub`, um es von `eat_at_restaurant` aus zu benutzen -Leider führt der Code in Codeblock 7-5 immer noch zu einem Fehler, wie +Leider führt der Code in Codeblock 7-5 immer noch zu Kompilierfehlern, wie Codeblock 7-6 zeigt. ```console @@ -259,7 +259,7 @@ pub fn eat_at_restaurant() { `eat_at_restaurant` aufrufen Jetzt kompiliert der Code! Um zu sehen, warum das Hinzufügen des Schlüsselworts -`pub` uns erlaubt, diese Pfade in `add_to_waitlist` im Hinblick auf die +`pub` uns erlaubt, diese Pfade in `eat_at_restaurant` im Hinblick auf die Datenschutzregeln zu verwenden, sehen wir uns die absoluten und relativen Pfade an. diff --git a/src/ch07-04-bringing-paths-into-scope-with-the-use-keyword.md b/src/ch07-04-bringing-paths-into-scope-with-the-use-keyword.md index f619a932..7a096ef7 100644 --- a/src/ch07-04-bringing-paths-into-scope-with-the-use-keyword.md +++ b/src/ch07-04-bringing-paths-into-scope-with-the-use-keyword.md @@ -45,7 +45,7 @@ Beachte, dass `use` nur die Verknüpfung für den jeweiligen Gültigkeitsbereich erstellt, in dem `use` vorkommt. Codeblock 7-12 verschiebt die Funktion `eat_at_restaurant` in ein neues untergeordnetes Modul namens `customer`, das dann einen anderen Gültigkeitsbereich als die `use`-Anweisung hat, sodass der -Funktionsrumpf nicht kompiliert werden kann: +Funktionsrumpf nicht kompiliert werden kann. Dateiname: src/lib.rs @@ -261,10 +261,11 @@ pub fn eat_at_restaurant() { Code zum Verwenden in einem neuen Gültigkeitsbereich mit `pub use` Vor dieser Änderung musste externer Code die Funktion `add_to_waitlist` mit dem -Pfad `restaurant::front_of_house::hosting::add_to_waitlist()` aufrufen. Nun, da -`pub use` das Modul `hosting` aus dem Wurzel-Modul re-exportiert hat, kann -externer Code nun stattdessen den Pfad `restaurant::hosting::add_to_waitlist()` -verwenden. +Pfad `restaurant::front_of_house::hosting::add_to_waitlist()` aufrufen, was +zudem erfordert hätte, dass das Modul `front_of_house` als `pub` gekennzeichnet +ist. Da aber `pub use` das Modul `hosting` aus dem Wurzel-Modul re-exportiert +hat, kann externer Code nun stattdessen den Pfad +`restaurant::hosting::add_to_waitlist()` verwenden. Der Rück-Export ist nützlich, wenn sich die interne Struktur deines Codes von dem unterscheidet, wie Programmierer, die deinen Code diff --git a/src/ch07-05-separating-modules-into-different-files.md b/src/ch07-05-separating-modules-into-different-files.md index 42933adc..39183a91 100644 --- a/src/ch07-05-separating-modules-into-different-files.md +++ b/src/ch07-05-separating-modules-into-different-files.md @@ -64,7 +64,7 @@ Als Nächstes extrahieren wir das Modul `hosting` in seine eigene Datei. Der Prozess ist ein bisschen anders, weil `hosting` ein untergeordnetes Modul von `front_of_house` ist, nicht vom Stammmodul. Wir legen die Datei für `hosting` in einem neuen Verzeichnis ab, das nach seinen Vorgängern im Modulbaum benannt -wird, in diesem Fall *src/front_of_house/*. +wird, in diesem Fall *src/front_of_house*. Um mit dem Verschieben von `hosting` zu beginnen, ändern wir *src/front_of_house.rs* so, dass es nur die Deklaration des `hosting`-Moduls From dab5c71e75f37d050f2ab1670c3714e548241de7 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sat, 11 May 2024 19:05:59 +0200 Subject: [PATCH 09/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch08-01-vectors.md | 14 ++++----- src/ch08-02-strings.md | 15 +++++----- src/ch08-03-hash-maps.md | 65 +++++++++++++++++++++------------------- 3 files changed, 49 insertions(+), 45 deletions(-) diff --git a/src/ch08-01-vectors.md b/src/ch08-01-vectors.md index 3ec97257..3e493f51 100644 --- a/src/ch08-01-vectors.md +++ b/src/ch08-01-vectors.md @@ -103,12 +103,12 @@ werden. Mit `&` und `[]` erhalten wir eine Referenz auf das Element mit dem Indexwert. Wenn wir die Methode `get` mit dem Index als Argument verwenden, erhalten wir eine `Option<&T>`, die wir mit `match` verwenden können. -Der Grund, warum Rust diese beiden Möglichkeiten, auf ein Element zu -referenzieren, bietet ist, dass du wählen kannst, wie sich das Programm -verhält, wenn du versuchst, einen Indexwert außerhalb des Bereichs der -vorhandenen Elemente zu verwenden. Als Beispiel wollen wir sehen, was ein -Programm tut, wenn wir bei einem Vektor mit fünf Elementen versuchen, auf ein -Element mit Index 100 zuzugreifen, wie in Codeblock 8-5 zu sehen ist. +Rust bietet diese beide Möglichkeiten, um auf ein Element zu referenzieren. Du +kannst nun ausprobieren, wie sich das Programm verhält, wenn du einen Indexwert +außerhalb des Bereichs der vorhandenen Elemente zu verwendest. Als Beispiel +wollen wir sehen, was passiert, wenn wir bei einem Vektor mit fünf Elementen +versuchen, auf ein Element mit Index 100 zuzugreifen, wie in Codeblock 8-5 zu +sehen ist. ```rust,should_panic,panics let v = vec![1, 2, 3, 4, 5]; @@ -145,7 +145,7 @@ veränderbaren und unveränderbaren Referenzen im gleichen Gültigkeitsbereich haben kannst. Diese Regel trifft in Codeblock 8-6 zu, wo wir eine unveränderbare Referenz auf das erste Element in einem Vektor halten und versuchen, am Ende ein Element hinzuzufügen. Das wird nicht funktionieren, wenn -wir später in der Funktion versuchen auch auf dieses Element zuzugreifen: +wir später in der Funktion versuchen auch auf dieses Element zuzugreifen. ```rust,does_not_compile let mut v = vec![1, 2, 3, 4, 5]; diff --git a/src/ch08-02-strings.md b/src/ch08-02-strings.md index f88a7ec2..f1dd2b3e 100644 --- a/src/ch08-02-strings.md +++ b/src/ch08-02-strings.md @@ -239,8 +239,9 @@ let s = s1 + "-" + &s2 + "-" + &s3; ``` An diesem Punkt wird `s` den Wert `tic-tac-toe` haben. Bei all den Zeichen `+` -und `"` ist es schwer zu erkennen, was vor sich geht. Für kompliziertere -String-Kombinationen können wir stattdessen das Makro `format!` verwenden: +und `"` ist es schwer zu erkennen, was vor sich geht. Um Zeichenketten auf +kompliziertere Weise zu kombinieren, können wir stattdessen das Makro `format!` +verwenden: ```rust let s1 = String::from("tic"); @@ -413,9 +414,9 @@ let hello = "Здравствуйте"; let s = &hello[0..4]; ``` -Hier wird `s` ein `&str` sein, das die ersten 4 Bytes der Zeichenkette enthält. -Vorhin haben wir bereits erwähnt, dass jedes dieser Zeichen 2 Bytes lang ist, -was bedeutet, dass `s` gleich `Зд` ist. +Hier wird `s` ein `&str` sein, das die ersten vier Bytes der Zeichenkette +enthält. Vorhin haben wir bereits erwähnt, dass jedes dieser Zeichen zwei Bytes +lang ist, was bedeutet, dass `s` gleich `Зд` ist. Wenn wir versuchen würden, nur einen Teil der Bytes eines Zeichens mit etwas wie `&hello[0..1]` zu zerschneiden, würde Rust das Programm zur Laufzeit @@ -475,8 +476,8 @@ Dieser Code gibt die vier Bytes aus, aus denen diese Zeichenkette besteht: 180 ``` -Aber denke daran, dass gültige Unicode-Skalarwerte aus mehr als 1 Byte bestehen -können. +Aber denke daran, dass gültige Unicode-Skalarwerte aus mehr als ein Byte +bestehen können. Die Ermittlung von Graphemgruppen aus Zeichenketten wie bei der Devanagari-Schrift ist komplex, sodass diese Funktionalität nicht von der diff --git a/src/ch08-03-hash-maps.md b/src/ch08-03-hash-maps.md index b2e27d58..4afe7663 100644 --- a/src/ch08-03-hash-maps.md +++ b/src/ch08-03-hash-maps.md @@ -5,9 +5,9 @@ Der Typ `HashMap` speichert eine Zuordnung von Schlüsseln vom Typ `K` zu Werten vom Typ `V` mittels einer *Hashfunktion* (hash function), die bestimmt, wie er diese Schlüssel und Werte im Speicher ablegt. Viele Programmiersprachen unterstützen diese Art Datenstruktur, aber sie verwenden oft einen anderen -Namen, z.B. Hash, Abbildung (map), Objekt, Hashtabelle (hash table), Wörterbuch -(dictionary) oder assoziatives Array (associative array), um nur einige zu -nennen. +Namen wie *Hash*, *Abbildung* (map), *Objekt*, *Hashtabelle* (hash table), +*Wörterbuch* (dictionary) oder *assoziatives Array* (associative array), um nur +einige zu nennen. Hashtabellen sind nützlich, wenn du Daten nicht wie bei Vektoren über einen Index nachschlagen willst, sondern über einen Schlüssel, der ein beliebiger Typ @@ -50,7 +50,7 @@ gibt zum Beispiel kein eingebautes Makro, um sie zu erzeugen. Genau wie Vektoren speichern Hashtabellen ihre Daten im Haldenspeicher. Obige `HashMap` hat Schlüssel vom Typ `String` und Werte vom Typ `i32`. -Hashtabellen sind wie Vektoren homogen: Alle Schlüssel müssen denselben Typ +Hashtabellen sind homogen wie Vektoren: Alle Schlüssel müssen denselben Typ haben und alle Werte müssen denselben Typ haben. ### Zugreifen auf Werte in einer Hashtabelle @@ -140,7 +140,7 @@ Lebensdauern“][validating-references-with-lifetimes] in Kapitel 10 sprechen. Obwohl die Anzahl der Schlüssel- und Wertepaare vergrößerbar ist, kann jedem eindeutigen Schlüssel jeweils nur ein Wert zugeordnet werden (aber nicht umgekehrt: Zum Beispiel könnten sowohl das blaue Team als auch das gelbe Team -den Wert 10 in der Hashtabelle `scores` gespeichert haben). +den Wert `10` in der Hashtabelle `scores` gespeichert haben). Wenn du die Daten in einer Hashtabelle ändern willst, musst du entscheiden, wie der Fall zu behandeln ist, wenn einem Schlüssel bereits ein Wert zugewiesen @@ -189,8 +189,9 @@ Hashtabellen haben dafür eine spezielle Programmierschnittstelle (API) namens Rückgabewert der Methode `entry` ist eine Aufzählung (enum) namens `Entry`, die einen Wert repräsentiert, der existieren könnte oder auch nicht. Nehmen wir an, wir wollen prüfen, ob der Schlüssel für das Team Gelb einen Wert hat. Wenn das -nicht der Fall ist, wollen wir den Wert 50 einfügen, und dasselbe gilt für das -Team Blau. Bei Verwendung von `entry` sieht der Code wie Codeblock 8-24 aus. +nicht der Fall ist, wollen wir den Wert `50` einfügen, und dasselbe gilt für +das Team Blau. Bei Verwendung von `entry` sieht der Code wie Codeblock 8-24 +aus. ```rust use std::collections::HashMap; @@ -215,9 +216,10 @@ auf den neuen Wert zurück. Diese Technik ist viel sauberer, als die Logik selbst zu schreiben, und sie harmoniert besser mit dem Ausleihenprüfer. Der Code in Codeblock 8-24 gibt `{"Gelb": 50, "Blau": 10}` aus. Beim ersten -Aufruf von `entry` wird der Schlüssel von Team Gelb mit dem Wert 50 eingefügt, -da das Team Gelb noch keinen Wert hat. Der zweite Aufruf von `entry` wird die -Hashtabelle nicht verändern, da das Team Blau bereits den Wert 10 hat. +Aufruf von `entry` wird der Schlüssel von Team Gelb mit dem Wert `50` +eingefügt, da das Team Gelb noch keinen Wert hat. Der zweite Aufruf von `entry` +wird die Hashtabelle nicht verändern, da das Team Blau bereits den Wert `10` +hat. #### Aktualisieren eines Wertes auf Basis des alten Wertes @@ -227,7 +229,7 @@ aktualisieren. Beispielsweise zeigt Codeblock 8-25 einen Code, der zählt, wie oft jedes Wort in einem Text vorkommt. Wir verwenden eine Hashtabelle mit den Wörtern als Schlüssel und inkrementieren den Wert, um nachzuvollziehen, wie oft wir dieses Wort schon gesehen haben. Wenn es das erste Mal ist, dass wir ein -Wort sehen, fügen wir zuerst den Wert 0 ein. +Wort sehen, fügen wir zuerst den Wert `0` ein. ```rust use std::collections::HashMap; @@ -272,9 +274,9 @@ Wert. Wenn du eine Performanzanalyse deines Codes machst und feststellst, dass die Standard-Hash-Funktion für deine Zwecke zu langsam ist, kannst du zu einer anderen Funktion wechseln, indem du eine andere Hash-Funktion angibst. Eine *Hash-Funktion* ist ein Typ, der das Merkmal `BuildHasher` implementiert. Wir -werden in Kapitel 10 über Merkmale und ihre Implementierung sprechen. Du musst -nicht unbedingt deine eigene Hash-Funktion von Grund auf implementieren; -[crates.io](https://crates.io/) verfügt über Bibliotheken, die von anderen +werden in [Kapitel 10][traits] über Merkmale und ihre Implementierung sprechen. +Du musst nicht unbedingt deine eigene Hash-Funktion von Grund auf +implementieren; [crates.io][crates] verfügt über Bibliotheken, die von anderen Rust-Nutzern bereitgestellt werden und viele gängige Hash-Funktionen implementieren. @@ -287,21 +289,21 @@ Funktionalität, die in Programmen benötigt wird, wenn du Daten speichern, darauf zugreifen und sie verändern willst. Hier sind einige Übungen, für deren Lösung du jetzt gerüstet sein solltest: -* Verwende bei einer Liste von ganzen Zahlen einen Vektor und gib den - Median (wenn sortiert, den Wert in der Mitte) und den Modus (den Wert, - der am häufigsten vorkommt; eine Hashtabelle ist hier hilfreich) der Liste - zurück. -* Wandle Zeichenketten in Schweinelatein (pig latin) um. Der erste Konsonant - jedes Wortes wird an das Ende des Wortes verschoben und „ay“ angehängt, - sodass „zuerst“ zu „uerst-zay“ wird. Bei Wörtern, die mit einem Vokal - beginnen, wird stattdessen „hay“ an das Ende angefügt („ansehen“ wird zu - „ansehen-hay“). Beachte die Details zur UTF-8-Kodierung! -* Erstelle mit Hilfe einer Hashtabelle und Vektoren eine Textschnittstelle, die - es einem Benutzer ermöglicht, Mitarbeiternamen zu einer Abteilung in einem - Unternehmen hinzuzufügen. Zum Beispiel „Sally zur Technik hinzufügen“ oder - „Amir zum Vertrieb hinzufügen“. Lass den Benutzer dann eine alphabetisch - sortierte Liste aller Personen in einer Abteilung oder aller Personen in der - Firma nach Abteilung ausgeben. +1. Verwende bei einer Liste von ganzen Zahlen einen Vektor und gib den + Median (wenn sortiert, den Wert in der Mitte) und den Modus (den Wert, + der am häufigsten vorkommt; eine Hashtabelle ist hier hilfreich) der Liste + zurück. +2. Wandle Zeichenketten in Schweinelatein (pig latin) um. Der erste Konsonant + jedes Wortes wird an das Ende des Wortes verschoben und „ay“ angehängt, + sodass „zuerst“ zu „uerst-zay“ wird. Bei Wörtern, die mit einem Vokal + beginnen, wird stattdessen „hay“ an das Ende angefügt („ansehen“ wird zu + „ansehen-hay“). Beachte die Details zur UTF-8-Kodierung! +3. Erstelle mit Hilfe einer Hashtabelle und Vektoren eine Textschnittstelle, die + es einem Benutzer ermöglicht, Mitarbeiternamen zu einer Abteilung in einem + Unternehmen hinzuzufügen. Zum Beispiel „Sally zur Technik hinzufügen“ oder + „Amir zum Vertrieb hinzufügen“. Lass den Benutzer dann eine alphabetisch + sortierte Liste aller Personen in einer Abteilung oder aller Personen in der + Firma nach Abteilung ausgeben. Die API-Dokumentation der Standard-Bibliothek beschreibt Methoden für Vektoren, Zeichenketten und Hashtabellen, die für diese Übungen hilfreich sind! @@ -311,5 +313,6 @@ können, daher ist es ein perfekter Zeitpunkt, auf die Fehlerbehandlung einzugehen. Das werden wir als nächstes tun! [access]: #zugreifen-auf-werte-in-einer-hashtabelle -[validating-references-with-lifetimes]: -ch10-03-lifetime-syntax.html +[crates]: https://crates.io/ +[validating-references-with-lifetimes]: ch10-03-lifetime-syntax.html +[traits]: ch10-02-traits.html From 11090779755f2a9fad06d18d03fd7b94700e7f73 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sat, 11 May 2024 22:59:54 +0200 Subject: [PATCH 10/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch09-02-recoverable-errors-with-result.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch09-02-recoverable-errors-with-result.md b/src/ch09-02-recoverable-errors-with-result.md index 8c426794..411b7883 100644 --- a/src/ch09-02-recoverable-errors-with-result.md +++ b/src/ch09-02-recoverable-errors-with-result.md @@ -192,10 +192,10 @@ Fehler, außer dem Fehler der fehlenden Datei, abbricht. > let greeting_file = File::open("hallo.txt").unwrap_or_else(|error| { > if error.kind() == ErrorKind::NotFound { > File::create("hallo.txt").unwrap_or_else(|error| { -> panic!("Problem beim Erstellen der Datei: {:?}", error); +> panic!("Problem beim Erstellen der Datei: {error:?}"); > }) > } else { -> panic!("Problem beim Öffnen der Datei: {:?}", error); +> panic!("Problem beim Öffnen der Datei: {error:?}"); > } > }); > } From cf22f0bf94325150eee5be3958edbbdafdcbfeab Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 09:09:23 +0200 Subject: [PATCH 11/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch11-01-writing-tests.md | 20 +++++++++----------- src/ch11-03-test-organization.md | 6 +++--- 2 files changed, 12 insertions(+), 14 deletions(-) diff --git a/src/ch11-01-writing-tests.md b/src/ch11-01-writing-tests.md index fcb49be5..fd6e0977 100644 --- a/src/ch11-01-writing-tests.md +++ b/src/ch11-01-writing-tests.md @@ -69,13 +69,12 @@ mod tests { Codeblock 11-1: Das Testmodul und die Funktion, die automatisch von `cargo new` generiert werden -Ignorieren wir vorerst die beiden oberen Zeilen und konzentrieren uns auf die -Funktion. Beachte die Annotation `#[test]`: Dieses Attribut zeigt an, dass es -sich um eine Testfunktion handelt, sodass die Testausführung weiß, dass es -diese Funktion als einen Test behandeln soll. Wir könnten auch -Nicht-Test-Funktionen im Modul `tests` haben, um gängige Szenarien aufzusetzen -oder gängige Operationen durchzuführen, daher müssen wir immer angeben, welche -Funktionen Tests sind. +Konzentrieren wir uns zunächst nur auf die Funktion `it_works()`. Beachte die +Annotation `#[test]`: Dieses Attribut zeigt an, dass es sich um eine +Testfunktion handelt, sodass die Testausführung weiß, dass es diese Funktion +als einen Test behandeln soll. Wir könnten auch Nicht-Test-Funktionen im Modul +`tests` haben, um gängige Szenarien aufzusetzen oder gängige Operationen +durchzuführen, daher müssen wir immer angeben, welche Funktionen Tests sind. Der Beispiel-Funktionsrumpf verwendet das Makro `assert_eq!`, um sicherzustellen, dass 2 + 2 gleich 4 ist. Diese Prüfung dient als Beispiel für @@ -1097,10 +1096,9 @@ error: test failed, to rerun pass `--lib` Die Fehlermeldung zeigt an, dass dieser Test tatsächlich wie erwartet das Programm abgebrochen hat, aber die Abbruchsmeldung enthielt nicht die erwartete -Zeichenfolge `'Schätzwert muss kleiner oder gleich 100 sein'`. Die -Abbruchsmeldung, die wir in diesem Fall erhielten, lautete: `Schätzwert muss -größer oder gleich 1 sein, ist 200.` Jetzt können wir anfangen herauszufinden, -wo unser Fehler liegt! +Zeichenfolge `"kleiner oder gleich 100"`. Die Abbruchsmeldung, die wir in +diesem Fall erhielten, lautete: `Schätzwert muss größer oder gleich 1 sein, ist +200.` Jetzt können wir anfangen herauszufinden, wo unser Fehler liegt! ### Verwenden von `Result` in Tests diff --git a/src/ch11-03-test-organization.md b/src/ch11-03-test-organization.md index 3cb71a88..b3329e5f 100644 --- a/src/ch11-03-test-organization.md +++ b/src/ch11-03-test-organization.md @@ -98,7 +98,7 @@ sind einfach nur Rust-Code, und das Modul `tests` ist nur ein weiteres Modul. Wie im Abschnitt [„Mit Pfaden auf ein Element im Modulbaum verweisen“][paths] beschrieben, können Elemente in Kind-Modulen die Elemente ihrer Eltern-Module verwenden. In diesem Test bringen wir alle Elemente des Eltern-Moduls von -`test` mit `use super::*` in den Gültigkeitsbereich, und dann kann der Test +`tests` mit `use super::*` in den Gültigkeitsbereich, und dann kann der Test `internal_adder` aufrufen. Wenn du der Meinung bist, dass private Funktionen nicht getestet werden sollten, gibt es in Rust nichts, was dich dazu zwingen würde. @@ -156,8 +156,8 @@ Kiste `adder` Jede Datei im Verzeichnis `tests` ist eine separate Kiste, also müssen wir unsere Bibliothek in den Gültigkeitsbereich jeder Test-Kiste bringen. Aus -diesem Grund fügen wir `use adder` am Anfang des Codes hinzu, was wir in den -Modultests nicht brauchten. +diesem Grund fügen wir `use adder::add_two` am Anfang des Codes hinzu, was wir +in den Modultests nicht brauchten. Wir brauchen den Code in *tests/integration_test.rs* nicht mit `#[cfg(test)]` zu annotieren. Cargo behandelt das Verzeichnis `tests` speziell und kompiliert From 46486eeae90575e40eb8c49d54f97af6010f7acb Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 09:12:33 +0200 Subject: [PATCH 12/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...-improving-error-handling-and-modularity.md | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/ch12-03-improving-error-handling-and-modularity.md b/src/ch12-03-improving-error-handling-and-modularity.md index da766913..8f44733b 100644 --- a/src/ch12-03-improving-error-handling-and-modularity.md +++ b/src/ch12-03-improving-error-handling-and-modularity.md @@ -29,15 +29,15 @@ wir haben keine Berechtigung, sie zu öffnen. Im Moment würden wir unabhängig von der Situation die Fehlermeldung „Etwas ging beim Lesen der Datei schief“ ausgeben, die dem Benutzer keinerlei Informationen geben würde! -Viertens verwenden wir `expect` erneut, um verschiedene Fehler zu behandeln, -und wenn der Benutzer unser Programm ausführt, ohne genügend Argumente -anzugeben, erhält er einen `Index out of bounds`-Fehler von Rust, der das -Problem nicht eindeutig erklärt. Am besten wäre es, wenn sich der gesamte -Fehlerbehandlungscode an einer Stelle befände, sodass zukünftige Betreuer nur -eine Stelle im Code konsultieren bräuchten, falls sich die -Fehlerbehandlungslogik ändern sollte. Wenn sich der gesamte -Fehlerbehandlungscode an einer Stelle befindet, wird auch sichergestellt, dass -wir Meldungen ausgeben, die für unsere Endbenutzer aussagekräftig sind. +Viertens verwenden wir `expect` erneut, um einen Fehler zu behandeln, und wenn +der Benutzer unser Programm ausführt, ohne genügend Argumente anzugeben, erhält +er einen `Index out of bounds`-Fehler von Rust, der das Problem nicht eindeutig +erklärt. Am besten wäre es, wenn sich der gesamte Fehlerbehandlungscode an +einer Stelle befände, sodass zukünftige Betreuer nur eine Stelle im Code +konsultieren bräuchten, falls sich die Fehlerbehandlungslogik ändern sollte. +Wenn sich der gesamte Fehlerbehandlungscode an einer Stelle befindet, wird auch +sichergestellt, dass wir Meldungen ausgeben, die für unsere Endbenutzer +aussagekräftig sind. Lass uns diese vier Probleme angehen, indem wir unser Projekt refaktorieren. From 955c0bdd82bf51636a43ef3e4a6edaf044481390 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 09:23:54 +0200 Subject: [PATCH 13/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch13-01-closures.md | 32 ++++++++++++------------- src/ch13-03-improving-our-io-project.md | 4 ++-- 2 files changed, 18 insertions(+), 18 deletions(-) diff --git a/src/ch13-01-closures.md b/src/ch13-01-closures.md index 091b620e..33351d51 100644 --- a/src/ch13-01-closures.md +++ b/src/ch13-01-closures.md @@ -513,8 +513,8 @@ keine Argumente annimmt und ein `T` zurückgeben muss. Die Verwendung von `unwrap_or_else` können wir sehen, dass, wenn die `Option` `Some` ist, `f` nicht aufgerufen wird. Wenn die `Option` `None` ist, wird `f` einmal aufgerufen. Da alle Funktionsabschlüsse `FnOnce` implementieren, akzeptiert -`unwrap_or_else` die unterschiedlichsten Arten von Funktionsabschlüssen und ist -so flexibel wie nur möglich. +`unwrap_or_else` alle drei Arten von Funktionsabschlüssen und ist so flexibel +wie nur möglich. > Anmerkung: Funktionen können auch alle drei `Fn`-Merkmale implementieren. > Wenn das, was wir tun wollen, keine Erfassung eines Wertes aus der Umgebung @@ -623,20 +623,20 @@ fn main() { Listing 13-8: Versuch, einen `FnOnce`-Funktionsabschluss mit `sort_by_key` zu verwenden -Dies ist ein ausgeklügelter, verworrener Weg (der nicht funktioniert), um zu -versuchen, die Anzahl der Aufrufe von `sort_by_key` beim Sortieren von `list` -zu zählen. Dieser Code versucht, diese Zählung durchzuführen, indem er `value`, -einen `String` aus der Umgebung des Funktionsabschlusses, in den -`sort_operations`-Vektor schiebt. Der Funktionsabschluss erfasst `value` und -verschiebt dann `value` aus dem Funktionsabschluss heraus, indem er die -Eigentümerschaft von `value` an den Vektor `sort_operations` überträgt. Dieser -Funktionsabschluss kann einmal aufgerufen werden; ein zweiter Aufruf würde nicht -funktionieren, da `value` nicht mehr in der Umgebung wäre, um erneut in -`sort_operations` verschoben zu werden! Daher implementiert dieser -Funktionsabschluss nur `FnOnce`. Wenn wir versuchen, diesen Code zu -kompilieren, erhalten wir die Fehlermeldung, dass `value` nicht aus dem -Funktionsabschluss verschoben werden kann, weil der Funktionsabschluss `FnMut` -implementieren muss: +Dies ist ein ausgeklügelter, verworrener Weg (der nicht funktioniert), der +versucht die Anzahl der Aufrufe des Funktionsabschlusses durch `sort_by_key` +beim Sortieren von `list` zu zählen. Dieser Code versucht diese Zählung +durchzuführen, indem er den `String` `value` aus der Umgebung des +Funktionsabschlusses in den Vektor `sort_operations` verschiebt. Der +Funktionsabschluss erfasst `value` und verschiebt dann `value` aus dem +Funktionsabschluss heraus, indem er die Eigentümerschaft von `value` an den +Vektor `sort_operations` überträgt. Dieser Funktionsabschluss kann einmal +aufgerufen werden; ein zweiter Aufruf würde nicht funktionieren, da `value` +nicht mehr in der Umgebung wäre, um erneut in `sort_operations` verschoben zu +werden! Daher implementiert dieser Funktionsabschluss nur `FnOnce`. Wenn wir +versuchen, diesen Code zu kompilieren, erhalten wir die Fehlermeldung, dass +`value` nicht aus dem Funktionsabschluss verschoben werden kann, weil der +Funktionsabschluss `FnMut` implementieren muss: ```console $ cargo run diff --git a/src/ch13-03-improving-our-io-project.md b/src/ch13-03-improving-our-io-project.md index bf3a9b10..b1d2aaa5 100644 --- a/src/ch13-03-improving-our-io-project.md +++ b/src/ch13-03-improving-our-io-project.md @@ -344,8 +344,8 @@ Parameter `args` einen generischen Typ mit den Merkmalsabgrenzungen `impl Iterator` anstelle von `&[String]` hat. Diese Verwendung der Syntax `impl Trait`, die wir im Abschnitt [„Merkmale als Parameter“][impl-trait] in Kapitel 10 besprochen haben, bedeutet, dass `args` -jeder Typ sein kann, der den Typ `Iterator` implementiert und `String`-Elemente -zurückgibt. +jeder Typ sein kann, der das Merkmal `Iterator` implementiert und +`String`-Elemente zurückgibt. Da wir die Eigentümerschaft von `args` übernehmen und `args` beim Iterieren verändern werden, können wir das Schlüsselwort `mut` in die Spezifikation des From 352359320f559530b200279df0ba4956dd62aa6d Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 09:29:45 +0200 Subject: [PATCH 14/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch14-02-publishing-to-crates-io.md | 3 ++- src/ch14-03-cargo-workspaces.md | 10 +++++++--- 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/src/ch14-02-publishing-to-crates-io.md b/src/ch14-02-publishing-to-crates-io.md index 0a4d181a..49350364 100644 --- a/src/ch14-02-publishing-to-crates-io.md +++ b/src/ch14-02-publishing-to-crates-io.md @@ -410,7 +410,8 @@ API-Schlüssel. Rufe anschließend das Kommando `cargo login` mit deinem API-Schlüssel auf: ```console -$ cargo login abcdefghijklmnopqrstuvwxyz012345 +$ cargo login +abcdefghijklmnopqrstuvwxyz012345 ``` Diese Kommando informiert Cargo über dein API-Token und speichert es lokal in diff --git a/src/ch14-03-cargo-workspaces.md b/src/ch14-03-cargo-workspaces.md index 1b8d2161..fb8cbfbb 100644 --- a/src/ch14-03-cargo-workspaces.md +++ b/src/ch14-03-cargo-workspaces.md @@ -254,10 +254,14 @@ Um dies zu beheben, bearbeiten wir die Datei *Cargo.toml* für das Paket `adder` und geben an, dass `rand` auch eine Abhängigkeit davon ist. Durch das Erstellen des Pakets `adder` wird `rand` zur Liste der Abhängigkeiten für `adder` in *Cargo.lock* hinzugefügt, es werden jedoch keine zusätzlichen Kopien von `rand` -heruntergeladen. Cargo hat dafür gesorgt, dass jede Kiste in jedem Paket im +heruntergeladen. Cargo stellt sicher, dass jede Kiste in jedem Paket im Arbeitsbereich, das das `rand`-Paket verwendet, die gleiche Version verwendet, -was uns Platz spart und sicherstellt, dass die Kisten im Arbeitsbereich -miteinander kompatibel sind. +solange sie kompatible Versionen von `rand` angeben, was uns Platz spart und +sicherstellt, dass die Kisten im Arbeitsbereich miteinander kompatibel sind. + +Wenn Kisten im Arbeitsbereich inkompatible Versionen der gleichen Abhängigkeit +angeben, löst Cargo jede von ihnen auf, versucht aber trotzdem, so wenige +Versionen wie möglich aufzulösen. #### Hinzufügen eines Tests zu einem Arbeitsbereich From 058c248571043d65da916a70dbb4d06cd527f159 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 09:33:39 +0200 Subject: [PATCH 15/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch15-05-interior-mutability.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch15-05-interior-mutability.md b/src/ch15-05-interior-mutability.md index 171c43f6..f4559048 100644 --- a/src/ch15-05-interior-mutability.md +++ b/src/ch15-05-interior-mutability.md @@ -354,7 +354,7 @@ For more information about this error, try `rustc --explain E0596`. error: could not compile `limit-tracker` (lib test) due to 1 previous error ``` -Wir können den `MockMessenger` nicht ändern, um die Nachrichten zu verfolgen, da +Wir können `MockMessenger` nicht so ändern, um die Nachrichten zu verfolgen, da die `send`-Methode eine unveränderbare Referenz auf `self` verwendet. Wir können auch nicht den Vorschlag aus dem Fehlertext übernehmen, stattdessen `&mut self` zu verwenden, da die Signatur von `send` nicht mit der Signatur in From fa485854f29205338edf2157fc4e4e3b0bb1d8cc Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 09:35:43 +0200 Subject: [PATCH 16/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch16-03-shared-state.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch16-03-shared-state.md b/src/ch16-03-shared-state.md index e1d6c6ec..446910ed 100644 --- a/src/ch16-03-shared-state.md +++ b/src/ch16-03-shared-state.md @@ -191,8 +191,8 @@ error: could not compile `shared-state` (bin "shared-state") due to 1 previous e ``` Die Fehlermeldung besagt, dass der Wert `counter` in der vorherigen Iteration -der Schleife verschoben wurde. Rust sagt uns, dass wir die Eigentümerschaft der -Sperre `counter` nicht in mehrere Stränge verschieben können. Lass uns den +der Schleife verschoben wurde. Rust sagt uns, dass wir die Eigentümerschaft von +`counter` nicht in mehrere Stränge verschieben können. Lass uns den Kompilierfehler mit einer Mehrfacheigentums-Methode beheben, die wir in Kapitel 15 besprochen haben. From 384e7c59f1dc8d58e3379eee0244821c1f3adb46 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 09:39:01 +0200 Subject: [PATCH 17/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch17-01-what-is-oo.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/ch17-01-what-is-oo.md b/src/ch17-01-what-is-oo.md index c39163df..386f1f53 100644 --- a/src/ch17-01-what-is-oo.md +++ b/src/ch17-01-what-is-oo.md @@ -128,11 +128,11 @@ haben, können wir Aspekte, z.B. die Datenstruktur, in Zukunft leicht ändern. Zum Beispiel könnten wir ein `HashSet` anstelle eines `Vec` für das `list`-Feld verwenden. Solange die Signaturen der öffentlichen Methoden `add`, `remove` und `average` gleich bleiben, würde Code, der `AveragedCollection` -verwendet, nicht geändert werden müssen. Wenn wir stattdessen `list` öffentlich -machen würden, wäre dies nicht unbedingt der Fall: `HashSet` und -`Vec` haben unterschiedliche Methoden zum Hinzufügen und Entfernen von -Elementen, sodass externer Code wahrscheinlich geändert werden müsste, wenn er -`list` direkt modifizieren würde. +verwendet, nicht geändert werden müssen damit er kompiliert. Wenn wir +stattdessen `list` öffentlich machen würden, wäre dies nicht unbedingt der +Fall: `HashSet` und `Vec` haben unterschiedliche Methoden zum +Hinzufügen und Entfernen von Elementen, sodass externer Code wahrscheinlich +geändert werden müsste, wenn er `list` direkt modifizieren würde. Wenn die Kapselung ein erforderlicher Aspekt ist, damit eine Sprache als objektorientiert betrachtet werden kann, dann erfüllt Rust diese Anforderung. From a62a116640e57c1ebd53adbc95ff5be32aeba4e3 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 09:46:24 +0200 Subject: [PATCH 18/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch18-02-refutability.md | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/ch18-02-refutability.md b/src/ch18-02-refutability.md index 24e3c048..69a377c1 100644 --- a/src/ch18-02-refutability.md +++ b/src/ch18-02-refutability.md @@ -91,15 +91,14 @@ Codeblock 18-8 zu korrigieren ist. Codeblock 18-9: Verwenden von `if let` und eines Blocks mit abweisbaren Mustern anstelle von `let` -Wir haben den Code repariert! Dieser Code ist vollkommen gültig, obwohl er -bedeutet, dass wir kein unabweisbares Muster verwenden können, ohne einen -Fehler zu erhalten. Wenn wir `if let` ein Muster geben, das immer passen wird, -z.B. `x`, wie in Codeblock 18-10 gezeigt, gibt der Compiler eine Warnung aus. +Wir haben den Code repariert! Dieser Code ist jetzt vollkommen gültig. Wenn wir +`if let` allerdings ein unabweisbares Muster geben, das immer passt, z.B. `x`, +wie in Codeblock 18-10 gezeigt, gibt der Compiler eine Warnung aus. ```rust # fn main() { if let x = 5 { - println!("{}", x); + println!("{x}"); }; # } ``` From e871045ea18464ca21e6afa26b1c5d70ef0fa156 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 09:48:53 +0200 Subject: [PATCH 19/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch19-06-macros.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch19-06-macros.md b/src/ch19-06-macros.md index b2cef6b0..d5e94715 100644 --- a/src/ch19-06-macros.md +++ b/src/ch19-06-macros.md @@ -638,5 +638,5 @@ die Praxis umsetzen und ein weiteres Projekt durchführen! [quote-crates]: https://crates.io/crates/quote [quote-docs]: https://docs.rs/quote [syn-crates]: https://crates.io/crates/syn -[syn-docs]: https://docs.rs/syn/1.0/syn/struct.DeriveInput.html +[syn-docs]: https://docs.rs/syn/2.0/syn/struct.DeriveInput.html [tlborm]: https://veykril.github.io/tlborm/ From de844528568bf3671bf898ed9fb90937aa14614a Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 09:52:22 +0200 Subject: [PATCH 20/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch20-01-single-threaded.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch20-01-single-threaded.md b/src/ch20-01-single-threaded.md index 277cab10..c0b96ba1 100644 --- a/src/ch20-01-single-threaded.md +++ b/src/ch20-01-single-threaded.md @@ -711,7 +711,7 @@ einfacher, den Unterschied zwischen den beiden Fällen zu erkennen, und es bedeutet, dass wir nur einen Ort haben, an dem wir den Code aktualisieren müssen, wenn wir ändern wollen, wie das Lesen der Datei und das Schreiben der Antwort funktionieren. Das Verhalten des Codes in Codeblock 20-9 ist dasselbe -wie in Codeblock 20-8. +wie in Codeblock 20-7. Fantastisch! Wir haben jetzt einen einfachen Webserver mit etwa 40 Zeilen Rust-Code, der auf eine Anfrage mit einer Inhaltsseite antwortet und auf alle From af2c73d4eab4ad259c3304abbe85cb70148c5374 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 09:52:30 +0200 Subject: [PATCH 21/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index f22f0ee2..bdef3b48 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ Das Buch „Die Programmiersprache Rust“ ist eine deutsche Gemeinschafts-Übersetzung des [offiziellen Rust-Buchs][rustbook-en]. -Es enthält alle Änderungen des englischen Originals bis einschließlich zum **19.02.2024**. +Es enthält alle Änderungen des englischen Originals bis einschließlich zum **11.05.2024**. ## [📖 > Hier online lesen < 📖][rustbook-de] From 52f8e54f7ba95d87171cbb01d520c1186cc2e3b9 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 10:18:47 +0200 Subject: [PATCH 22/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch01-03-hello-cargo.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/ch01-03-hello-cargo.md b/src/ch01-03-hello-cargo.md index 974f48b3..a097df57 100644 --- a/src/ch01-03-hello-cargo.md +++ b/src/ch01-03-hello-cargo.md @@ -72,8 +72,7 @@ name = "hello_cargo" version = "0.1.0" edition = "2021" -# Weitere Schlüssel und ihre Definitionen findest du unter -# https://doc.rust-lang.org/cargo/reference/manifest.html +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] ``` From c1cbc46810c9bc8063770d7e9dca44102dbeeccd Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 10:30:30 +0200 Subject: [PATCH 23/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch04-01-what-is-ownership.md | 39 +++++++++---------- src/ch04-02-references-and-borrowing.md | 52 ++++++++++++------------- src/ch04-03-slices.md | 16 ++++++-- 3 files changed, 58 insertions(+), 49 deletions(-) diff --git a/src/ch04-01-what-is-ownership.md b/src/ch04-01-what-is-ownership.md index ea1cfb62..36ae8b23 100644 --- a/src/ch04-01-what-is-ownership.md +++ b/src/ch04-01-what-is-ownership.md @@ -210,7 +210,7 @@ let mut s = String::from("Hallo"); s.push_str(" Welt!"); // push_str() hängt ein Literal an eine Zeichenfolge an -println!("{}", s); // Gibt `Hallo Welt!` aus +println!("{s}"); // Gibt `Hallo Welt!` aus ``` Was ist hier nun der Unterschied? Warum kann `String` verändert werden, @@ -388,34 +388,33 @@ wird nicht funktionieren: let s1 = String::from("Hallo"); let s2 = s1; -println!("{} Welt!", s1); +println!("{s1} Welt!"); ``` Du erhältst eine Fehlermeldung wie diese, wodurch Rust dich daran hindert, die ungültige Referenz zu verwenden: ```console -$ cargo run - Compiling ownership v0.1.0 (file:///projects/ownership) + Compiling playground v0.0.1 (/playground) error[E0382]: borrow of moved value: `s1` - --> src/main.rs:5:28 + --> src/main.rs:6:11 | -2 | let s1 = String::from("Hallo"); - | -- move occurs because `s1` has type `String`, which does not implement the `Copy` trait -3 | let s2 = s1; - | -- value moved here -4 | -5 | println!("{} Welt!", s1); - | ^^ value borrowed here after move +3 | let s1 = String::from("Hallo"); + | -- move occurs because `s1` has type `String`, which does not implement the `Copy` trait +4 | let s2 = s1; + | -- value moved here +5 | +6 | println!("{s1} Welt!"); + | ^^^^ value borrowed here after move | = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info) help: consider cloning the value if the performance cost is acceptable | -3 | let s2 = s1.clone(); - | ++++++++ +4 | let s2 = s1.clone(); + | ++++++++ For more information about this error, try `rustc --explain E0382`. -error: could not compile `ownership` (bin "ownership") due to 1 previous error +error: could not compile `playground` (bin "playground") due to 1 previous error ``` Wenn du beim Arbeiten mit anderen Sprachen schon mal die Begriffe *flache @@ -461,7 +460,7 @@ Hier ist ein Beispiel für die Methode `clone`: let s1 = String::from("Hallo"); let s2 = s1.clone(); -println!("s1 = {}, s2 = {}", s1, s2); +println!("s1 = {s1}, s2 = {s2}"); ``` Das funktioniert sehr gut und erzeugt explizit das in Abbildung 4-3 gezeigte @@ -481,7 +480,7 @@ funktioniert und ist gültig: let x = 5; let y = x; -println!("x = {}, y = {}", x, y); +println!("x = {x}, y = {y}"); ``` Aber dieser Code scheint dem zu widersprechen, was wir gerade gelernt haben: @@ -554,12 +553,12 @@ fn main() { fn takes_ownership(some_string: String) { // some_string kommt in den // Gültigkeitsbereich - println!("{}", some_string); + println!("{some_string}"); } // Hier verlässt some_string den Gültigkeitsbereich und `drop` wird aufgerufen. // Der zugehörige Speicherplatz wird freigegeben. fn makes_copy(some_integer: i32) { // some_integer kommt in den Gültigkeitsbereich - println!("{}", some_integer); + println!("{some_integer}"); } // Hier verlässt some_integer den Gültigkeitsbereich. // Es passiert nichts Besonderes. ``` @@ -643,7 +642,7 @@ fn main() { let (s2, len) = calculate_length(s1); - println!("Die Länge von '{}' ist {}.", s2, len); + println!("Die Länge von '{s2}' ist {len}."); } fn calculate_length(s: String) -> (String, usize) { diff --git a/src/ch04-02-references-and-borrowing.md b/src/ch04-02-references-and-borrowing.md index 740b3cc6..6ed45f16 100644 --- a/src/ch04-02-references-and-borrowing.md +++ b/src/ch04-02-references-and-borrowing.md @@ -22,7 +22,7 @@ fn main() { let len = calculate_length(&s1); - println!("Die Länge von '{}' ist {}.", s1, len); + println!("Die Länge von '{s1}' ist {len}."); } fn calculate_length(s: &String) -> usize { @@ -185,27 +185,27 @@ let mut s = String::from("Hallo"); let r1 = &mut s; let r2 = &mut s; -println!("{}, {}", r1, r2); +println!("{r1}, {r2}"); ``` Hier ist die Fehlermeldung: ```console $ cargo run - Compiling ownership v0.1.0 (file:///projects/ownership) + Compiling playground v0.0.1 (/playground) error[E0499]: cannot borrow `s` as mutable more than once at a time - --> src/main.rs:5:14 + --> src/main.rs:6:10 | -4 | let r1 = &mut s; - | ------ first mutable borrow occurs here -5 | let r2 = &mut s; - | ^^^^^^ second mutable borrow occurs here -6 | -7 | println!("{}, {}", r1, r2); - | -- first borrow later used here +5 | let r1 = &mut s; + | ------ first mutable borrow occurs here +6 | let r2 = &mut s; + | ^^^^^^ second mutable borrow occurs here +7 | +8 | println!("{r1}, {r2}"); + | ---- first borrow later used here For more information about this error, try `rustc --explain E0499`. -error: could not compile `ownership` (bin "ownership") due to 1 previous error +error: could not compile `playground` (bin "playground") due to 1 previous error ``` Dieser Fehler besagt, dass dieser Code ungültig ist, weil wir `s` nicht mehr @@ -258,28 +258,28 @@ let r1 = &s; // kein Problem let r2 = &s; // kein Problem let r3 = &mut s; // GROSSES PROBLEM -println!("{}, {} und {}", r1, r2, r3); +println!("{r1}, {r2} und {r3}"); ``` Hier ist die Fehlermeldung: ```console $ cargo run - Compiling ownership v0.1.0 (file:///projects/ownership) + Compiling playground v0.0.1 (/playground) error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable - --> src/main.rs:6:14 + --> src/main.rs:7:10 | -4 | let r1 = &s; // kein Problem - | -- immutable borrow occurs here -5 | let r2 = &s; // kein Problem -6 | let r3 = &mut s; // GROSSES PROBLEM - | ^^^^^^ mutable borrow occurs here -7 | -8 | println!("{}, {} und {}", r1, r2, r3); - | -- immutable borrow later used here +5 | let r1 = &s; // kein Problem + | -- immutable borrow occurs here +6 | let r2 = &s; // kein Problem +7 | let r3 = &mut s; // GROSSES PROBLEM + | ^^^^^^ mutable borrow occurs here +8 | +9 | println!("{r1}, {r2} und {r3}"); + | ---- immutable borrow later used here For more information about this error, try `rustc --explain E0502`. -error: could not compile `ownership` (bin "ownership") due to 1 previous error +error: could not compile `playground` (bin "playground") due to 1 previous error ``` Puh! Wir können auch keine veränderbaren Referenzen verwenden, solange wir eine @@ -301,11 +301,11 @@ let mut s = String::from("Hallo"); let r1 = &s; // kein Problem let r2 = &s; // kein Problem -println!("{} und {}", r1, r2); +println!("{r1} und {r2}"); // r1 und r2 werden nach dieser Stelle nicht mehr verwendet let r3 = &mut s; // kein Problem -println!("{}", r3); +println!("{r3}"); ``` Die Gültigkeitsbereiche der unveränderbaren Referenzen `r1` und `r2` enden diff --git a/src/ch04-03-slices.md b/src/ch04-03-slices.md index 36816de3..0c01e8a6 100644 --- a/src/ch04-03-slices.md +++ b/src/ch04-03-slices.md @@ -39,6 +39,8 @@ fn first_word(s: &String) -> usize { s.len() } +# +# fn main() {} ``` Codeblock 4-7: Die Funktion `first_word`, die einen @@ -60,6 +62,8 @@ Wert ein Leerzeichen ist, wandeln wir unseren `String` mit der Methode # # s.len() # } +# +# fn main() {} ``` Als nächstes erstellen wir einen Iterator über das Byte-Array, indem wir die @@ -77,6 +81,8 @@ Methode `iter` verwenden: # # s.len() # } +# +# fn main() {} ``` Auf Iteratoren werden wir in [Kapitel 13][ch13-2] näher eingehen. Fürs Erste @@ -111,6 +117,8 @@ Länge der Zeichenkette zurück, indem wir `s.len()` verwenden. s.len() # } +# +# fn main() {} ``` Wir haben jetzt eine Möglichkeit, den Index des ersten Wortendes in der @@ -274,6 +282,8 @@ fn first_word(s: &String) -> &str { &s[..] } +# +# fn main() {} ``` Den Index für das Wortende erhalten wir auf die gleiche Weise wie in Codeblock @@ -328,7 +338,7 @@ fn main() { s.clear(); // Fehler! - println!("Das erste Wort ist: {}", word); + println!("Das erste Wort ist: {word}"); } ``` @@ -346,8 +356,8 @@ error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immuta 18 | s.clear(); // Fehler! | ^^^^^^^^^ mutable borrow occurs here 19 | -20 | println!("Das erste Wort ist: {}", word); - | ---- immutable borrow later used here +20 | println!("Das erste Wort ist: {word}"); + | ------ immutable borrow later used here For more information about this error, try `rustc --explain E0502`. error: could not compile `ownership` (bin "ownership") due to 1 previous error From 19bd6b487d3583681fe525a54c2cfc6aa1c04137 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 10:52:04 +0200 Subject: [PATCH 24/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch05-01-defining-structs.md | 4 ++++ src/ch05-02-example-structs.md | 6 +++--- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/src/ch05-01-defining-structs.md b/src/ch05-01-defining-structs.md index 2580eb6c..c3ca91ec 100644 --- a/src/ch05-01-defining-structs.md +++ b/src/ch05-01-defining-structs.md @@ -23,6 +23,8 @@ struct User { email: String, sign_in_count: u64, } +# +# fn main() {} ``` Codeblock 5-1: Definition der Struktur `User` @@ -207,6 +209,7 @@ verwenden aber ansonsten die gleichen Werte von `user1`, die wir in Codeblock # fn main() { // --abschneiden-- +# # let user1 = User { # email: String::from("jemand@example.com"), # username: String::from("benutzername123"), @@ -243,6 +246,7 @@ Wert haben sollen wie die Felder in der gegebenen Instanz. # fn main() { // --abschneiden-- +# # let user1 = User { # email: String::from("jemand@example.com"), # username: String::from("benutzername123"), diff --git a/src/ch05-02-example-structs.md b/src/ch05-02-example-structs.md index f0e2bc35..b9726998 100644 --- a/src/ch05-02-example-structs.md +++ b/src/ch05-02-example-structs.md @@ -186,7 +186,7 @@ fn main() { height: 50, }; - println!("rect1 ist {}", rect1); + println!("rect1 ist {rect1}"); } ``` @@ -221,7 +221,7 @@ finden: ``` Lass es uns versuchen! Der Makroaufruf `println!` wird geändert in -`println!("rect1 ist {:?}", rect1);`. Wenn wir das Symbol `:?` innerhalb der +`println!("rect1 ist {rect1:?}");`. Wenn wir den Bezeichner `:?` innerhalb der geschweiften Klammern angeben, teilen wir `println!` mit, dass wir das Ausgabeformat `Debug` verwenden wollen. Das Merkmal `Debug` ermöglicht es, die Struktur so auszugeben, dass Entwickler ihren Wert erkennen können, während sie @@ -261,7 +261,7 @@ fn main() { height: 50, }; - println!("rect1 ist {:?}", rect1); + println!("rect1 ist {rect1:?}"); } ``` From 1bb258af3355ae49012f2bf3bc1f8d667d1add7d Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 10:53:19 +0200 Subject: [PATCH 25/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch06-01-defining-an-enum.md | 4 +++ src/ch06-02-match.md | 43 +++++++++++++++++++++++++++++---- src/ch06-03-if-let.md | 8 +++--- 3 files changed, 46 insertions(+), 9 deletions(-) diff --git a/src/ch06-01-defining-an-enum.md b/src/ch06-01-defining-an-enum.md index 033ade3a..55301dbd 100644 --- a/src/ch06-01-defining-an-enum.md +++ b/src/ch06-01-defining-an-enum.md @@ -242,6 +242,8 @@ enum Message { Write(String), ChangeColor(i32, i32, i32), } +# +# fn main() {} ``` Codeblock 6-2: Eine Aufzählung `Message`, deren Varianten @@ -268,6 +270,8 @@ struct MoveMessage { } struct WriteMessage(String); // Tupelstruktur struct ChangeColorMessage(i32, i32, i32); // Tupelstruktur +# +# fn main() {} ``` Aber wenn wir die verschiedenen Strukturen verwenden würden, die jeweils ein diff --git a/src/ch06-02-match.md b/src/ch06-02-match.md index f2b1c890..3fdd8418 100644 --- a/src/ch06-02-match.md +++ b/src/ch06-02-match.md @@ -37,6 +37,8 @@ fn value_in_cents(coin: Coin) -> u8 { Coin::Quarter => 25, } } +# +# fn main() {} ``` Codeblock 6-3: Eine Aufzählung und ein `match`-Ausdruck, @@ -95,6 +97,8 @@ fn value_in_cents(coin: Coin) -> u8 { Coin::Quarter => 25, } } +# +# fn main() {} ``` ### Muster, die Werte binden @@ -124,6 +128,8 @@ enum Coin { Dime, Quarter(UsState), } +# +# fn main() {} ``` Codeblock 6-4: Aufzählung `Coin`, bei der die Variante @@ -139,7 +145,7 @@ passt, wird die Variable `state` an den Wert der Eigenschaft der 25-Cent-Münze gebunden. Dann können wir `state` im Code für diesen Zweig etwa so verwenden: ```rust -# #[derive(Debug)] // um den Staat mit println! ausgeben zu können +# #[derive(Debug)] # enum UsState { # Alabama, # Alaska, @@ -159,7 +165,7 @@ fn value_in_cents(coin: Coin) -> u8 { Coin::Nickel => 5, Coin::Dime => 10, Coin::Quarter(state) => { - println!("25-Cent-Münze aus {:?}!", state); + println!("25-Cent-Münze aus {state:?}!"); 25 } } @@ -216,14 +222,32 @@ Lass uns die erste Ausführung von `plus_one` näher betrachten. Wenn wir Wert `Some(5)` haben. Dann vergleichen wir das mit jedem `match`-Zweig: ```rust,ignore -None => None, +# fn plus_one(x: Option) -> Option { +# match x { + None => None, +# Some(i) => Some(i + 1), +# } +# } +# +# let five = Some(5); +# let six = plus_one(five); +# let none = plus_one(None); ``` Der Wert `Some(5)` passt nicht zum Muster `None`, also fahren wir mit dem nächsten Zweig fort: ```rust,ignore -Some(i) => Some(i + 1), +# fn plus_one(x: Option) -> Option { +# match x { +# None => None, + Some(i) => Some(i + 1), +# } +# } +# +# let five = Some(5); +# let six = plus_one(five); +# let none = plus_one(None); ``` Passt `Some(5)` zu `Some(i)`? Das tut es! Wir haben die gleiche Variante. `i` @@ -236,7 +260,16 @@ den Wert `None` hat. Wir betreten den `match`-Block und vergleichen mit dem ersten Zweig: ```rust,ignore -None => None, +# fn plus_one(x: Option) -> Option { +# match x { + None => None, +# Some(i) => Some(i + 1), +# } +# } +# +# let five = Some(5); +# let six = plus_one(five); +# let none = plus_one(None); ``` Er passt! Es gibt keinen Wert zum Hinzufügen, also stoppt das Programm und gibt diff --git a/src/ch06-03-if-let.md b/src/ch06-03-if-let.md index 3790c297..52d2ea50 100644 --- a/src/ch06-03-if-let.md +++ b/src/ch06-03-if-let.md @@ -9,7 +9,7 @@ Code ausführen soll, wenn der Wert die `Some`-Variante ist. ```rust let config_max = Some(3u8); match config_max { - Some(max) => println!("Das Maximum ist mit {} konfiguriert", max), + Some(max) => println!("Das Maximum ist mit {max} konfiguriert"), _ => (), } ``` @@ -30,7 +30,7 @@ Codeblock 6-6: ```rust let config_max = Some(3u8); if let Some(max) = config_max { - println!("Das Maximum ist mit {} konfiguriert", max); + println!("Das Maximum ist mit {max} konfiguriert"); } ``` @@ -79,7 +79,7 @@ diesem tun: # let coin = Coin::Penny; let mut count = 0; match coin { - Coin::Quarter(state) => println!("25-Cent-Münze aus {:?}!", state), + Coin::Quarter(state) => println!("25-Cent-Münze aus {state:?}!"), _ => count += 1, } # } @@ -106,7 +106,7 @@ Oder wir könnten einen Ausdruck mit `if let` und `else` wie diesen verwenden: # let coin = Coin::Penny; let mut count = 0; if let Coin::Quarter(state) = coin { - println!("25-Cent-Münze aus {:?}!", state); + println!("25-Cent-Münze aus {state:?}!"); } else { count += 1; } From 5218b3cec50136cf169700da9c20e24ad446f1e2 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 10:58:26 +0200 Subject: [PATCH 26/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch07-02-defining-modules-to-control-scope-and-privacy.md | 2 +- src/ch07-04-bringing-paths-into-scope-with-the-use-keyword.md | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/ch07-02-defining-modules-to-control-scope-and-privacy.md b/src/ch07-02-defining-modules-to-control-scope-and-privacy.md index 3b0703fe..18a9ea3d 100644 --- a/src/ch07-02-defining-modules-to-control-scope-and-privacy.md +++ b/src/ch07-02-defining-modules-to-control-scope-and-privacy.md @@ -81,7 +81,7 @@ pub mod garden; fn main() { let plant = Asparagus {}; - println!("Ich baue {:?} an!", plant); + println!("Ich baue {plant:?} an!"); } ``` diff --git a/src/ch07-04-bringing-paths-into-scope-with-the-use-keyword.md b/src/ch07-04-bringing-paths-into-scope-with-the-use-keyword.md index 7a096ef7..1de00589 100644 --- a/src/ch07-04-bringing-paths-into-scope-with-the-use-keyword.md +++ b/src/ch07-04-bringing-paths-into-scope-with-the-use-keyword.md @@ -312,7 +312,7 @@ fn main() { # let secret_number = rand::thread_rng().gen_range(1..=100); # -# println!("Die geheime Zahl ist: {}", secret_number); +# println!("Die geheime Zahl ist: {secret_number}"); # # println!("Bitte gib deine Vermutung ein."); # @@ -322,7 +322,7 @@ fn main() { # .read_line(&mut guess) # .expect("Fehler beim Lesen einer Zeile"); # -# println!("Du hast geraten: {}", guess); +# println!("Du hast geraten: {guess}"); } ``` From 72f2e24dcf4d04dfbf9bc87225366d2c119e695a Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 11:04:23 +0200 Subject: [PATCH 27/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch08-03-hash-maps.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/ch08-03-hash-maps.md b/src/ch08-03-hash-maps.md index 4afe7663..da1381a2 100644 --- a/src/ch08-03-hash-maps.md +++ b/src/ch08-03-hash-maps.md @@ -167,7 +167,7 @@ let mut scores = HashMap::new(); scores.insert(String::from("Blau"), 10); scores.insert(String::from("Blau"), 25); -println!("{:?}", scores); +println!("{scores:?}"); ``` Codeblock 8-23: Ersetzen eines gespeicherten Wertes für @@ -202,7 +202,7 @@ scores.insert(String::from("Blau"), 10); scores.entry(String::from("Gelb")).or_insert(50); scores.entry(String::from("Blau")).or_insert(50); -println!("{:?}", scores); +println!("{scores:?}"); ``` Codeblock 8-24: Verwenden der Methode `entry` zum @@ -243,7 +243,7 @@ for word in text.split_whitespace() { *count += 1; } -println!("{:?}", map); +println!("{map:?}"); ``` Codeblock 8-25: Zählen des Vorkommens von Wörtern mit From 195a6bd2fb19ad62ae5c791109101c580d384683 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 11:12:46 +0200 Subject: [PATCH 28/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch09-02-recoverable-errors-with-result.md | 6 +++--- src/ch09-03-to-panic-or-not-to-panic.md | 3 +-- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/src/ch09-02-recoverable-errors-with-result.md b/src/ch09-02-recoverable-errors-with-result.md index 411b7883..7ba722c4 100644 --- a/src/ch09-02-recoverable-errors-with-result.md +++ b/src/ch09-02-recoverable-errors-with-result.md @@ -77,7 +77,7 @@ fn main() { let greeting_file = match greeting_file_result { Ok(file) => file, - Err(error) => panic!("Problem beim Öffnen der Datei: {:?}", error), + Err(error) => panic!("Problem beim Öffnen der Datei: {error:?}"), }; } ``` @@ -139,10 +139,10 @@ fn main() { Err(error) => match error.kind() { ErrorKind::NotFound => match File::create("hallo.txt") { Ok(fc) => fc, - Err(e) => panic!("Problem beim Erstellen der Datei: {:?}", e), + Err(e) => panic!("Problem beim Erstellen der Datei: {e:?}"), }, other_error => { - panic!("Problem beim Öffnen der Datei: {:?}", other_error) + panic!("Problem beim Öffnen der Datei: {other_error:?}") } }, }; diff --git a/src/ch09-03-to-panic-or-not-to-panic.md b/src/ch09-03-to-panic-or-not-to-panic.md index 8e25073e..234a9311 100644 --- a/src/ch09-03-to-panic-or-not-to-panic.md +++ b/src/ch09-03-to-panic-or-not-to-panic.md @@ -238,8 +238,7 @@ pub struct Guess { impl Guess { pub fn new(value: i32) -> Guess { if value < 1 || value > 100 { - panic!("Der Schätzwert muss zwischen 1 und 100 liegen, ist jedoch {}.", - value); + panic!("Der Schätzwert muss zwischen 1 und 100 liegen, ist jedoch {value}."); } Guess { value } From cc9634bab0e7c856f33bc7d52e68f53273733db5 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 11:52:55 +0200 Subject: [PATCH 29/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch10-00-generics.md | 34 ++++++------- src/ch10-01-syntax.md | 24 ++++----- src/ch10-02-traits.md | 92 ++++++++++++++++++++++++++++++---- src/ch10-03-lifetime-syntax.md | 42 ++++++++-------- 4 files changed, 132 insertions(+), 60 deletions(-) diff --git a/src/ch10-00-generics.md b/src/ch10-00-generics.md index fa92cc34..a471e68a 100644 --- a/src/ch10-00-generics.md +++ b/src/ch10-00-generics.md @@ -58,16 +58,16 @@ einer Liste findet. fn main() { let number_list = vec![34, 50, 25, 100, 65]; - let mut largest = number_list[0]; + let mut largest = &number_list[0]; - for number in number_list { + for number in &number_list { if number > largest { largest = number; } } - println!("Die größte Zahl ist {}", largest); -# assert_eq!(largest, 100); + println!("Die größte Zahl ist {largest}"); +# assert_eq!(*largest, 100); } ``` @@ -94,27 +94,27 @@ verwenden, wie in Codeblock 10-2 gezeigt. fn main() { let number_list = vec![34, 50, 25, 100, 65]; - let mut largest = number_list[0]; + let mut largest = &number_list[0]; - for number in number_list { + for number in &number_list { if number > largest { largest = number; } } - println!("Die größte Zahl ist {}", largest); + println!("Die größte Zahl ist {largest}"); let number_list = vec![102, 34, 6000, 89, 54, 2, 43, 8]; - let mut largest = number_list[0]; + let mut largest = &number_list[0]; - for number in number_list { + for number in &number_list { if number > largest { largest = number; } } - println!("Die größte Zahl ist {}", largest); + println!("Die größte Zahl ist {largest}"); } ``` @@ -140,10 +140,10 @@ könnten. Dateiname: src/main.rs ```rust -fn largest(list: &[i32]) -> i32 { - let mut largest = list[0]; +fn largest(list: &[i32]) -> &i32 { + let mut largest = &list[0]; - for &item in list { + for item in list { if item > largest { largest = item; } @@ -156,14 +156,14 @@ fn main() { let number_list = vec![34, 50, 25, 100, 65]; let result = largest(&number_list); - println!("Die größte Zahl ist {}", result); -# assert_eq!(result, 100); + println!("Die größte Zahl ist {result}"); +# assert_eq!(*result, 100); let number_list = vec![102, 34, 6000, 89, 54, 2, 43, 8]; let result = largest(&number_list); - println!("Die größte Zahl ist {}", result); -# assert_eq!(result, 6000); + println!("Die größte Zahl ist {result}"); +# assert_eq!(*result, 6000); } ``` diff --git a/src/ch10-01-syntax.md b/src/ch10-01-syntax.md index 75cf06b7..b1e76ac6 100644 --- a/src/ch10-01-syntax.md +++ b/src/ch10-01-syntax.md @@ -24,10 +24,10 @@ verwendet. Dateiname: src/main.rs ```rust -fn largest_i32(list: &[i32]) -> i32 { - let mut largest = list[0]; +fn largest_i32(list: &[i32]) -> &i32 { + let mut largest = &list[0]; - for &item in list { + for item in list { if item > largest { largest = item; } @@ -36,10 +36,10 @@ fn largest_i32(list: &[i32]) -> i32 { largest } -fn largest_char(list: &[char]) -> char { - let mut largest = list[0]; +fn largest_char(list: &[char]) -> &char { + let mut largest = &list[0]; - for &item in list { + for item in list { if item > largest { largest = item; } @@ -52,14 +52,14 @@ fn main() { let number_list = vec![34, 50, 25, 100, 65]; let result = largest_i32(&number_list); - println!("Die größte Zahl ist {}", result); -# assert_eq!(result, 100); + println!("Die größte Zahl ist {result}"); +# assert_eq!(*result, 100); let char_list = vec!['y', 'm', 'a', 'q']; let result = largest_char(&char_list); - println!("Das größte Zeichen ist {}", result); -# assert_eq!(result, 'y'); + println!("Das größte Zeichen ist {result}"); +# assert_eq!(*result, 'y'); } ``` @@ -124,12 +124,12 @@ fn main() { let number_list = vec![34, 50, 25, 100, 65]; let result = largest(&number_list); - println!("Die größte Zahl ist {}", result); + println!("Die größte Zahl ist {result}"); let char_list = vec!['y', 'm', 'a', 'q']; let result = largest(&char_list); - println!("Das größte Zeichen ist {}", result); + println!("Das größte Zeichen ist {result}"); } ``` diff --git a/src/ch10-02-traits.md b/src/ch10-02-traits.md index 91774071..0f9e6271 100644 --- a/src/ch10-02-traits.md +++ b/src/ch10-02-traits.md @@ -130,20 +130,18 @@ die zusätzlichen Merkmals-Methoden zu erhalten. Hier ist ein Beispiel dafür, wie eine binäre Kiste unsere `aggregator`-Bibliothekskiste verwenden könnte: ```rust,ignore -# use aggregator::{self, Summary, Tweet}; -# -# fn main() { +use aggregator::{self, Summary, Tweet}; + +fn main() { let tweet = Tweet { username: String::from("horse_ebooks"), - content: String::from( - "natürlich, wie du wahrscheinlich schon weißt", - ), + content: String::from("natürlich, wie du wahrscheinlich schon weißt"), reply: false, retweet: false, }; println!("1 neue Kurznachricht: {}", tweet.summarize()); -# } +} ``` Dieser Code gibt `1 neue Kurznachricht: horse_ebooks: natürlich, wie du @@ -192,6 +190,28 @@ pub trait Summary { String::from("(Lies mehr ...)") } } +# +# pub struct NewsArticle { +# pub headline: String, +# pub location: String, +# pub author: String, +# pub content: String, +# } +# +# impl Summary for NewsArticle {} +# +# pub struct Tweet { +# pub username: String, +# pub content: String, +# pub reply: bool, +# pub retweet: bool, +# } +# +# impl Summary for Tweet { +# fn summarize(&self) -> String { +# format!("{}: {}", self.username, self.content) +# } +# } ``` Codeblock 10-14: Definieren eines Merkmals `Summary` mit @@ -249,6 +269,19 @@ pub trait Summary { format!("(Lies mehr von {}...)", self.summarize_author()) } } +# +# pub struct Tweet { +# pub username: String, +# pub content: String, +# pub reply: bool, +# pub retweet: bool, +# } +# +# impl Summary for Tweet { +# fn summarize_author(&self) -> String { +# format!("@{}", self.username) +# } +# } ``` Um diese Version von `Summary` zu verwenden, müssen wir `summarize_author` nur @@ -320,6 +353,32 @@ verwenden, etwa so: # fn summarize(&self) -> String; # } # +# pub struct NewsArticle { +# pub headline: String, +# pub location: String, +# pub author: String, +# pub content: String, +# } +# +# impl Summary for NewsArticle { +# fn summarize(&self) -> String { +# format!("{}, von {} ({})", self.headline, self.author, self.location) +# } +# } +# +# pub struct Tweet { +# pub username: String, +# pub content: String, +# pub reply: bool, +# pub retweet: bool, +# } +# +# impl Summary for Tweet { +# fn summarize(&self) -> String { +# format!("{}: {}", self.username, self.content) +# } +# } +# pub fn notify(item: &impl Summary) { println!("Eilmeldung! {}", item.summarize()); } @@ -422,6 +481,8 @@ where T: Display + Clone, U: Clone + Debug, { +# unimplemented!() +# } ``` Die Signatur dieser Funktion ist übersichtlicher: Der Funktionsname, die @@ -438,6 +499,19 @@ gezeigt: # fn summarize(&self) -> String; # } # +# pub struct NewsArticle { +# pub headline: String, +# pub location: String, +# pub author: String, +# pub content: String, +# } +# +# impl Summary for NewsArticle { +# fn summarize(&self) -> String { +# format!("{}, von {} ({})", self.headline, self.author, self.location) +# } +# } +# # pub struct Tweet { # pub username: String, # pub content: String, @@ -528,9 +602,7 @@ fn returns_summarizable(switch: bool) -> impl Summary { } else { Tweet { username: String::from("horse_ebooks"), - content: String::from( - "natürlich, wie du wahrscheinlich schon weißt", - ), + content: String::from("natürlich, wie du wahrscheinlich schon weißt"), reply: false, retweet: false, } diff --git a/src/ch10-03-lifetime-syntax.md b/src/ch10-03-lifetime-syntax.md index 0db80cff..b2f688aa 100644 --- a/src/ch10-03-lifetime-syntax.md +++ b/src/ch10-03-lifetime-syntax.md @@ -41,7 +41,7 @@ fn main() { r = &x; } - println!("r: {}", r); + println!("r: {r}"); } ``` @@ -76,8 +76,8 @@ error[E0597]: `x` does not live long enough 7 | } | - `x` dropped here while still borrowed 8 | -9 | println!("r: {}", r); - | - borrow later used here +9 | println!("r: {r}"); + | --- borrow later used here For more information about this error, try `rustc --explain E0597`. error: could not compile `chapter10` (bin "chapter10") due to 1 previous error @@ -109,7 +109,7 @@ fn main() { r = &x; // | | } // -+ | // | - println!("r: {}", r); // | + println!("r: {r}"); // | } // ---------+ ``` @@ -133,7 +133,7 @@ fn main() { // | let r = &x; // --+-- 'a | // | | - println!("r: {}", r); // | | + println!("r: {r}"); // | | // --+ | } // ----------+ ``` @@ -167,7 +167,7 @@ fn main() { let string2 = "xyz"; let result = longest(string1.as_str(), string2); - println!("Die längere Zeichenkette ist {}", result); + println!("Die längere Zeichenkette ist {result}"); } ``` @@ -194,7 +194,7 @@ implementieren, wird sie sich nicht kompilieren lassen. # let string2 = "xyz"; # # let result = longest(string1.as_str(), string2); -# println!("Die längere Zeichenkette ist {}", result); +# println!("Die längere Zeichenkette ist {result}"); # } # fn longest(x: &str, y: &str) -> &str { @@ -304,7 +304,7 @@ Referenz hinzu, wie in Codeblock 10-21 gezeigt. # let string2 = "xyz"; # # let result = longest(string1.as_str(), string2); -# println!("Die längere Zeichenkette ist {}", result); +# println!("Die längere Zeichenkette ist {result}"); # } # fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { @@ -375,7 +375,7 @@ fn main() { { let string2 = String::from("xyz"); let result = longest(string1.as_str(), string2.as_str()); - println!("Die längere Zeichenkette ist {}", result); + println!("Die längere Zeichenkette ist {result}"); } } # @@ -417,7 +417,7 @@ fn main() { let string2 = String::from("xyz"); result = longest(string1.as_str(), string2.as_str()); } - println!("Die längere Zeichenkette ist {}", result); + println!("Die längere Zeichenkette ist {result}"); } # # fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { @@ -446,8 +446,8 @@ error[E0597]: `string2` does not live long enough | ^^^^^^^ borrowed value does not live long enough 7 | } | - `string2` dropped here while still borrowed -8 | println!("Die längere Zeichenkette ist {}", result); - | ------ borrow later used here +8 | println!("Die längere Zeichenkette ist {result}"); + | -------- borrow later used here For more information about this error, try `rustc --explain E0597`. error: could not compile `chapter10` (bin "chapter10") due to 1 previous error @@ -491,7 +491,7 @@ kompilieren: # let string2 = "efghijklmnopqrstuvwxyz"; # # let result = longest(string1.as_str(), string2); -# println!("Die längere Zeichenkette ist {}", result); +# println!("Die längere Zeichenkette ist {result}"); # } # fn longest<'a>(x: &'a str, y: &str) -> &'a str { @@ -520,7 +520,7 @@ Implementierung der Funktion `longest`, die sich nicht kompilieren lässt: # let string2 = "xyz"; # # let result = longest(string1.as_str(), string2); -# println!("Die längere Zeichenkette ist {}", result); +# println!("Die längere Zeichenkette ist {result}"); # } # fn longest<'a>(x: &str, y: &str) -> &'a str { @@ -812,7 +812,7 @@ impl<'a> ImportantExcerpt<'a> { # # impl<'a> ImportantExcerpt<'a> { # fn announce_and_return_part(&self, announcement: &str) -> &str { -# println!("Bitte um Aufmerksamkeit: {}", announcement); +# println!("Bitte um Aufmerksamkeit: {announcement}"); # self.part # } # } @@ -845,7 +845,7 @@ Hier ist ein Beispiel, bei dem die dritte Lebensdauer-Elisionsregel gilt: # impl<'a> ImportantExcerpt<'a> { fn announce_and_return_part(&self, announcement: &str) -> &str { - println!("Bitte um Aufmerksamkeit: {}", announcement); + println!("Bitte um Aufmerksamkeit: {announcement}"); self.part } } @@ -905,7 +905,7 @@ Merkmalsabgrenzungen und Lebensdauern in einer Funktion an! # string2, # "Heute hat jemand Geburtstag!", # ); -# println!("Die längere Zeichenkette ist {}", result); +# println!("Die längere Zeichenkette ist {result}"); # } # use std::fmt::Display; @@ -918,7 +918,7 @@ fn longest_with_an_announcement<'a, T>( where T: Display, { - println!("Bekanntmachung! {}", ann); + println!("Bekanntmachung! {ann}"); if x.len() > y.len() { x } else { @@ -931,9 +931,9 @@ Dies ist die Funktion `longest` aus Codeblock 10-21, die die längere von zwei Zeichenkettenanteilstypen zurückgibt. Aber jetzt hat sie einen zusätzlichen Parameter namens `ann` vom generischen Typ `T`, der jeder beliebige Typ sein kann, der das Merkmal `Display` implementiert, wie in der `where`-Klausel -spezifiziert ist. Dieser zusätzliche Parameter wird unter Verwendung von `{}` -ausgegeben, weshalb die Merkmalsabgrenzung `Display` erforderlich ist. Da die -Lebensdauer ein generischer Typ ist, stehen die Deklarationen des +spezifiziert ist. Dieser zusätzliche Parameter wird unter Verwendung von +`{ann}` ausgegeben, weshalb die Merkmalsabgrenzung `Display` erforderlich ist. +Da die Lebensdauer ein generischer Typ ist, stehen die Deklarationen des Lebensdauer-Parameters `'a` und des generischen Typ-Parameters `T` in der gleichen Liste innerhalb spitzer Klammern hinter dem Funktionsnamen. From 332f101dd848d9f7f26d7898ee4051ae88b4e0e1 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 12:24:34 +0200 Subject: [PATCH 30/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch11-01-writing-tests.md | 35 ++++++++++++++++++++------------ src/ch11-02-running-tests.md | 2 -- src/ch11-03-test-organization.md | 16 ++++++++++----- 3 files changed, 33 insertions(+), 20 deletions(-) diff --git a/src/ch11-01-writing-tests.md b/src/ch11-01-writing-tests.md index fd6e0977..db428aab 100644 --- a/src/ch11-01-writing-tests.md +++ b/src/ch11-01-writing-tests.md @@ -145,11 +145,18 @@ zunächst den Namen der Funktion `it_works` in einen anderen Namen, z.B. Dateiname: src/lib.rs ```rust,noplayground +pub fn add(left: usize, right: usize) -> usize { + left + right +} + #[cfg(test)] mod tests { + use super::*; + #[test] fn exploration() { - assert_eq!(2 + 2, 4); + let result = add(2, 2); + assert_eq!(result, 4); } } ``` @@ -187,11 +194,16 @@ Makros `panic!`. Erstelle einen neuen Test `another`, sodass deine Datei Dateiname: src/lib.rs ```rust,panics,noplayground +pub fn add(left: usize, right: usize) -> usize { + left + right +} + #[cfg(test)] mod tests { #[test] fn exploration() { - assert_eq!(2 + 2, 4); + let result = add(2, 2); + assert_eq!(result, 4); } #[test] @@ -711,7 +723,7 @@ in der Ausgabe auftaucht: ```rust,noplayground pub fn greeting(name: &str) -> String { - format!("Hallo {}!", name) + format!("Hallo {name}!") } #[cfg(test)] @@ -802,8 +814,7 @@ gefüllt ist: let result = greeting("Carol"); assert!( result.contains("Carol"), - "Begrüßung enthielt nicht den Namen, Wert war `{}`", - result + "Begrüßung enthielt nicht den Namen, Wert war `{result}`" ); } # } @@ -869,7 +880,7 @@ pub struct Guess { impl Guess { pub fn new(value: i32) -> Guess { if value < 1 || value > 100 { - panic!("Schätzwert muss zwischen 1 und 100 liegen, ist {}.", value); + panic!("Schätzwert muss zwischen 1 und 100 liegen, ist {value}."); } Guess { value } @@ -926,7 +937,7 @@ der Wert größer als 100 ist: impl Guess { pub fn new(value: i32) -> Guess { if value < 1 { - panic!("Schätzwert muss zwischen 1 und 100 liegen, ist {}.", value); + panic!("Schätzwert muss zwischen 1 und 100 liegen, ist {value}."); } Guess { value } @@ -995,9 +1006,9 @@ nachdem, ob der Wert zu klein oder zu groß ist. impl Guess { pub fn new(value: i32) -> Guess { if value < 1 { - panic!("Schätzwert muss größer oder gleich 1 sein, ist {}.", value); + panic!("Schätzwert muss größer oder gleich 1 sein, ist {value}."); } else if value > 100 { - panic!("Schätzwert muss kleiner oder gleich 100 sein, ist {}.", value); + panic!("Schätzwert muss kleiner oder gleich 100 sein, ist {value}."); } Guess { value } @@ -1042,11 +1053,9 @@ vertauschen: # impl Guess { # pub fn new(value: i32) -> Guess { if value < 1 { - panic!("Schätzwert muss kleiner oder gleich 100 sein, ist {}.", - value); + panic!("Schätzwert muss kleiner oder gleich 100 sein, ist {value}."); } else if value > 100 { - panic!("Schätzwert muss größer oder gleich 1 sein, ist {}.", - value); + panic!("Schätzwert muss größer oder gleich 1 sein, ist {value}."); } # # Guess { value } diff --git a/src/ch11-02-running-tests.md b/src/ch11-02-running-tests.md index 4ca3ba4e..ec7ff3da 100644 --- a/src/ch11-02-running-tests.md +++ b/src/ch11-02-running-tests.md @@ -70,8 +70,6 @@ einen Test, der fehlschlägt. Dateiname: src/lib.rs ```rust,panics,noplayground -# fn main() {} -# fn prints_and_returns_10(a: i32) -> i32 { println!("Ich habe den Wert {} erhalten.", a); 10 diff --git a/src/ch11-03-test-organization.md b/src/ch11-03-test-organization.md index b3329e5f..480bdff9 100644 --- a/src/ch11-03-test-organization.md +++ b/src/ch11-03-test-organization.md @@ -40,12 +40,18 @@ neue Projekt `adder` im ersten Abschnitt dieses Kapitels erstellt haben: Dateiname: src/lib.rs -```rust,noplayground +```rust +pub fn add(left: usize, right: usize) -> usize { + left + right +} + #[cfg(test)] mod tests { + use super::*; + #[test] fn it_works() { - let result = 2 + 2; + let result = add(2, 2); assert_eq!(result, 4); } } @@ -71,7 +77,7 @@ Funktion `internal_adder`. Dateiname: src/lib.rs -```rust,noplayground +```rust pub fn add_two(a: i32) -> i32 { internal_adder(a, 2) } @@ -143,11 +149,11 @@ Gib den Code in Codeblock 11-13 in die Datei *tests/integration_test.rs* ein: Dateiname: tests/integration_test.rs ```rust,ignore -use adder; +use adder::add_two; #[test] fn it_adds_two() { - assert_eq!(4, adder::add_two(2)); + assert_eq!(4, add_two(2)); } ``` From 137e3a63f0e224e26d9a6eec47a1fe2ee43f8093 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 12:39:42 +0200 Subject: [PATCH 31/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch12-01-accepting-command-line-arguments.md | 2 +- src/ch12-02-reading-a-file.md | 6 +++--- src/ch12-03-improving-error-handling-and-modularity.md | 8 ++++---- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/ch12-01-accepting-command-line-arguments.md b/src/ch12-01-accepting-command-line-arguments.md index 88a10ee2..ad159cb7 100644 --- a/src/ch12-01-accepting-command-line-arguments.md +++ b/src/ch12-01-accepting-command-line-arguments.md @@ -131,7 +131,7 @@ können. Das tun wir in Codeblock 12-2. Dateiname: src/main.rs -```rust,should_panic +```rust,noplayground use std::env; fn main() { diff --git a/src/ch12-02-reading-a-file.md b/src/ch12-02-reading-a-file.md index 325b05eb..c9ff2c2d 100644 --- a/src/ch12-02-reading-a-file.md +++ b/src/ch12-02-reading-a-file.md @@ -31,7 +31,7 @@ Datei hinzu, wie in Codeblock 12-4 gezeigt. Dateiname: src/main.rs -```rust,should_panic +```rust,noplayground use std::env; use std::fs; @@ -42,8 +42,8 @@ fn main() { # let query = &args[1]; # let file_path = &args[2]; # -# println!("Suche nach {}", query); - println!("In Datei {}", file_path); +# println!("Suche nach {query}"); + println!("In Datei {file_path}"); let contents = fs::read_to_string(file_path) .expect("Etwas ging beim Lesen der Datei schief"); diff --git a/src/ch12-03-improving-error-handling-and-modularity.md b/src/ch12-03-improving-error-handling-and-modularity.md index 8f44733b..4a156f60 100644 --- a/src/ch12-03-improving-error-handling-and-modularity.md +++ b/src/ch12-03-improving-error-handling-and-modularity.md @@ -83,7 +83,7 @@ wir vorerst in *src/main.rs* definieren werden. Dateiname: src/main.rs -```rust +```rust,noplayground # use std::env; # use std::fs; # @@ -94,8 +94,8 @@ fn main() { // --abschneiden-- # -# println!("Suche nach {}", query); -# println!("In Datei {}", file_path); +# println!("Suche nach {query}"); +# println!("In Datei {file_path}"); # # let contents = fs::read_to_string(file_path) # .expect("Etwas ging beim Lesen der Datei schief"); @@ -879,7 +879,7 @@ Codeblock 12-14 modifiziert haben. Dateiname: src/lib.rs -```rust,ignore +```rust,ignore,does_not_compile use std::error::Error; use std::fs; From 72a3236bbd99225f51692145f052cb2c522ea64a Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 12:49:22 +0200 Subject: [PATCH 32/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch13-01-closures.md | 34 ++++++++++++++-------------------- src/ch13-02-iterators.md | 2 +- 2 files changed, 15 insertions(+), 21 deletions(-) diff --git a/src/ch13-01-closures.md b/src/ch13-01-closures.md index 33351d51..1a2379c6 100644 --- a/src/ch13-01-closures.md +++ b/src/ch13-01-closures.md @@ -33,7 +33,7 @@ zurück, die die Person erhalten wird. Dies wird in Codeblock 13-1 gezeigt: Dateiname: src/main.rs -```rust,noplayground +```rust #[derive(Debug, PartialEq, Copy, Clone)] enum ShirtColor { Red, @@ -74,17 +74,11 @@ fn main() { let user_pref1 = Some(ShirtColor::Red); let giveaway1 = store.giveaway(user_pref1); - println!( - "Der Benutzer mit Präferenz {:?} erhält {:?}", - user_pref1, giveaway1 - ); + println!("Der Benutzer mit Präferenz {user_pref1:?} erhält {giveaway1:?}"); let user_pref2 = None; let giveaway2 = store.giveaway(user_pref2); - println!( - "Der Benutzer mit Präferenz {:?} erhält {:?}", - user_pref2, giveaway2 - ); + println!("Der Benutzer mit Präferenz {user_pref2:?} erhält {giveaway2:?}"); } ``` Codeblock 13-1: Werbegeschenk der Shirtfirma @@ -310,13 +304,13 @@ nur eine unveränderbare Referenz benötigt, um den Wert auszugeben: ```rust fn main() { let list = vec![1, 2, 3]; - println!("Vor der Funktionsabschlussdefinition: {:?}", list); + println!("Vor der Funktionsabschlussdefinition: {list:?}"); - let only_borrows = || println!("Im Funktionsabschluss: {:?}", list); + let only_borrows = || println!("Im Funktionsabschluss: {list:?}"); - println!("Vor dem Funktionsabschluss-Aufruf: {:?}", list); + println!("Vor dem Funktionsabschluss-Aufruf: {list:?}"); only_borrows(); - println!("Nach dem Funktionsabschluss-Aufruf: {:?}", list); + println!("Nach dem Funktionsabschluss-Aufruf: {list:?}"); } ``` @@ -354,12 +348,12 @@ nun eine veränderbare Referenz: ```rust fn main() { let mut list = vec![1, 2, 3]; - println!("Vor der Funktionsabschlussdefinition: {:?}", list); + println!("Vor der Funktionsabschlussdefinition: {list:?}"); let mut borrows_mutably = || list.push(7); borrows_mutably(); - println!("Nach dem Funktionsabschluss-Aufruf: {:?}", list); + println!("Nach dem Funktionsabschluss-Aufruf: {list:?}"); } ``` @@ -410,9 +404,9 @@ use std::thread; fn main() { let list = vec![1, 2, 3]; - println!("Vor der Funktionsabschlussdefinition: {:?}", list); + println!("Vor der Funktionsabschlussdefinition: {list:?}"); - thread::spawn(move || println!("Im Strang: {:?}", list)) + thread::spawn(move || println!("Im Strang: {list:?}")) .join() .unwrap(); } @@ -552,7 +546,7 @@ fn main() { ]; list.sort_by_key(|r| r.width); - println!("{:#?}", list); + println!("{list:#?}"); } ``` @@ -616,7 +610,7 @@ fn main() { sort_operations.push(value); r.width }); - println!("{:#?}", list); + println!("{list:#?}"); } ``` @@ -687,7 +681,7 @@ fn main() { num_sort_operations += 1; r.width }); - println!("{:#?}, sortiert in {num_sort_operations} Operationen", list); + println!("{list:#?}, sortiert in {num_sort_operations} Operationen"); } ``` diff --git a/src/ch13-02-iterators.md b/src/ch13-02-iterators.md index 7e0ee1f9..8b7c9cf4 100644 --- a/src/ch13-02-iterators.md +++ b/src/ch13-02-iterators.md @@ -39,7 +39,7 @@ let v1 = vec![1, 2, 3]; let v1_iter = v1.iter(); for val in v1_iter { - println!("Erhalten: {}", val); + println!("Erhalten: {val}"); } ``` Codeblock 13-11: Verwendung eines Iterators in einer From 8ff9e0f68d7e4ddadcca7acb4cd9baedf0a22804 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 13:06:13 +0200 Subject: [PATCH 33/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch15-01-box.md | 6 +++++- src/ch15-02-deref.md | 4 ++++ src/ch15-05-interior-mutability.md | 6 +++--- 3 files changed, 12 insertions(+), 4 deletions(-) diff --git a/src/ch15-01-box.md b/src/ch15-01-box.md index 17e77347..ad4ab647 100644 --- a/src/ch15-01-box.md +++ b/src/ch15-01-box.md @@ -48,7 +48,7 @@ Haldenspeicher speichert: ```rust fn main() { let b = Box::new(5); - println!("b = {}", b); + println!("b = {b}"); } ``` @@ -132,6 +132,8 @@ enum List { Cons(i32, List), Nil, } +# +# fn main() {} ``` Codeblock 15-2: Der erste Versuch eine Aufzählung zu @@ -215,6 +217,8 @@ enum Message { Write(String), ChangeColor(i32, i32, i32), } +# +# fn main() {} ``` Um zu bestimmen, wie viel Speicherplatz für einen `Message`-Wert zugewiesen werden soll, durchläuft Rust jede der Varianten, um festzustellen, welche diff --git a/src/ch15-02-deref.md b/src/ch15-02-deref.md index 00c26413..18a57a97 100644 --- a/src/ch15-02-deref.md +++ b/src/ch15-02-deref.md @@ -142,6 +142,8 @@ impl MyBox { MyBox(x) } } +# +# fn main() {} ``` Codeblock 15-8: Einen `MyBox`-Typ definieren @@ -319,6 +321,8 @@ Funktion mit einen Zeichenketten-Anteilstyp (string slice) Parameter: fn hello(name: &str) { println!("Hallo {name}!"); } +# +# fn main() {} ``` Codeblock 15-11: Eine `hello`-Funktion mit dem Parameter diff --git a/src/ch15-05-interior-mutability.md b/src/ch15-05-interior-mutability.md index f4559048..18d54dd8 100644 --- a/src/ch15-05-interior-mutability.md +++ b/src/ch15-05-interior-mutability.md @@ -665,9 +665,9 @@ fn main() { *value.borrow_mut() += 10; - println!("a nachher = {:?}", a); - println!("b nachher = {:?}", b); - println!("c nachher = {:?}", c); + println!("a nachher = {a:?}"); + println!("b nachher = {b:?}"); + println!("c nachher = {c:?}"); } ``` From b47883b2b42ef4a952cab2633bbbe78228da167c Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 13:17:20 +0200 Subject: [PATCH 34/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch16-01-threads.md | 30 +++++++++++++++--------------- src/ch16-02-message-passing.md | 14 +++++++------- src/ch16-03-shared-state.md | 2 +- 3 files changed, 23 insertions(+), 23 deletions(-) diff --git a/src/ch16-01-threads.md b/src/ch16-01-threads.md index 4a77e86f..7088505d 100644 --- a/src/ch16-01-threads.md +++ b/src/ch16-01-threads.md @@ -50,13 +50,13 @@ use std::time::Duration; fn main() { thread::spawn(|| { for i in 1..10 { - println!("Hallo Zahl {} aus dem erzeugten Strang!", i); + println!("Hallo Zahl {i} aus dem erzeugten Strang!"); thread::sleep(Duration::from_millis(1)); } }); for i in 1..5 { - println!("Hallo Zahl {} aus dem Hauptstrang!", i); + println!("Hallo Zahl {i} aus dem Hauptstrang!"); thread::sleep(Duration::from_millis(1)); } } @@ -121,13 +121,13 @@ use std::time::Duration; fn main() { let handle = thread::spawn(|| { for i in 1..10 { - println!("Hallo Zahl {} aus dem erzeugten Strang!", i); + println!("Hallo Zahl {i} aus dem erzeugten Strang!"); thread::sleep(Duration::from_millis(1)); } }); for i in 1..5 { - println!("Hallo Zahl {} aus dem Hauptstrang!", i); + println!("Hallo Zahl {i} aus dem Hauptstrang!"); thread::sleep(Duration::from_millis(1)); } @@ -178,7 +178,7 @@ use std::time::Duration; fn main() { let handle = thread::spawn(|| { for i in 1..10 { - println!("Hallo Zahl {} aus dem erzeugten Strang!", i); + println!("Hallo Zahl {i} aus dem erzeugten Strang!"); thread::sleep(Duration::from_millis(1)); } }); @@ -186,7 +186,7 @@ fn main() { handle.join().unwrap(); for i in 1..5 { - println!("Hallo Zahl {} aus dem Hauptstrang!", i); + println!("Hallo Zahl {i} aus dem Hauptstrang!"); thread::sleep(Duration::from_millis(1)); } } @@ -244,7 +244,7 @@ fn main() { let v = vec![1, 2, 3]; let handle = thread::spawn(|| { - println!("Hier ist ein Vektor: {:?}", v); + println!("Hier ist ein Vektor: {v:?}"); }); handle.join().unwrap(); @@ -268,15 +268,15 @@ error[E0373]: closure may outlive the current function, but it borrows `v`, whic | 6 | let handle = thread::spawn(|| { | ^^ may outlive borrowed value `v` -7 | println!("Hier ist ein Vektor: {:?}", v); - | - `v` is borrowed here +7 | println!("Hier ist ein Vektor: {v:?}"); + | - `v` is borrowed here | note: function requires argument type to outlive `'static` --> src/main.rs:6:18 | 6 | let handle = thread::spawn(|| { | __________________^ -7 | | println!("Hier ist ein Vektor: {:?}", v); +7 | | println!("Hier ist ein Vektor: {v:?}"); 8 | | }); | |______^ help: to force the closure to take ownership of `v` (and any other referenced variables), use the `move` keyword @@ -285,7 +285,7 @@ help: to force the closure to take ownership of `v` (and any other referenced va | ++++ For more information about this error, try `rustc --explain E0373`. -error: could not compile `threads` (bin "threads") due to 1 previous error +error: could not compile `playground` (bin "playground") due to 1 previous error ``` Rust *folgert*, wie man `v` erfasst, und weil `println!` nur eine Referenz auf @@ -305,7 +305,7 @@ fn main() { let v = vec![1, 2, 3]; let handle = thread::spawn(|| { - println!("Hier ist ein Vektor: {:?}", v); + println!("Hier ist ein Vektor: {v:?}"); }); drop(v); // Oh nein! @@ -351,7 +351,7 @@ fn main() { let v = vec![1, 2, 3]; let handle = thread::spawn(move || { - println!("Hier ist ein Vektor: {:?}", v); + println!("Hier ist ein Vektor: {v:?}"); }); handle.join().unwrap(); @@ -382,8 +382,8 @@ error[E0382]: use of moved value: `v` 5 | 6 | let handle = thread::spawn(move || { | ------- value moved into closure here -7 | println!("Hier ist ein Vektor: {:?}", v); - | - variable moved due to use in closure +7 | println!("Hier ist ein Vektor: {v:?}"); + | - variable moved due to use in closure ... 10 | drop(v); // Oh nein! | ^ value used here after move diff --git a/src/ch16-02-message-passing.md b/src/ch16-02-message-passing.md index 3510ddfb..73fbcc48 100644 --- a/src/ch16-02-message-passing.md +++ b/src/ch16-02-message-passing.md @@ -128,7 +128,7 @@ fn main() { }); let received = rx.recv().unwrap(); - println!("Erhalten: {}", received); + println!("Erhalten: {received}"); } ``` @@ -188,11 +188,11 @@ fn main() { thread::spawn(move || { let val = String::from("hallo"); tx.send(val).unwrap(); - println!("val ist {}", val); + println!("val ist {val}"); }); let received = rx.recv().unwrap(); - println!("Erhalten: {}", received); + println!("Erhalten: {received}"); } ``` @@ -217,8 +217,8 @@ error[E0382]: borrow of moved value: `val` | --- move occurs because `val` has type `String`, which does not implement the `Copy` trait 9 | tx.send(val).unwrap(); | --- value moved here -10 | println!("val ist {}", val); - | ^^^ value borrowed here after move +10 | println!("val ist {val}"); + | ^^^^^ value borrowed here after move | = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info) help: consider cloning the value if the performance cost is acceptable @@ -270,7 +270,7 @@ fn main() { }); for received in rx { - println!("Erhalten: {}", received); + println!("Erhalten: {received}"); } } ``` @@ -351,7 +351,7 @@ Codeblock 16-11 gezeigt: }); for received in rx { - println!("Erhalten: {}", received); + println!("Erhalten: {received}"); } // --abschneiden-- diff --git a/src/ch16-03-shared-state.md b/src/ch16-03-shared-state.md index 446910ed..1c744479 100644 --- a/src/ch16-03-shared-state.md +++ b/src/ch16-03-shared-state.md @@ -74,7 +74,7 @@ fn main() { *num = 6; } - println!("m = {:?}", m); + println!("m = {m:?}"); } ``` From 5a85de8e16eb2ab381dc16515aac5228ec85771a Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 15:20:23 +0200 Subject: [PATCH 35/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch17-02-trait-objects.md | 2 ++ src/ch17-03-oo-design-patterns.md | 6 +++--- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/src/ch17-02-trait-objects.md b/src/ch17-02-trait-objects.md index d98cff54..93586e83 100644 --- a/src/ch17-02-trait-objects.md +++ b/src/ch17-02-trait-objects.md @@ -261,6 +261,8 @@ impl Draw for SelectBox { // Code zum tatsächlichen Zeichnen eines Auswahlfeldes } } +# +# fn main() {} ``` Codeblock 17-8: Eine weitere Kiste, die `gui` verwendet diff --git a/src/ch17-03-oo-design-patterns.md b/src/ch17-03-oo-design-patterns.md index 86106105..8f1bc034 100644 --- a/src/ch17-03-oo-design-patterns.md +++ b/src/ch17-03-oo-design-patterns.md @@ -164,7 +164,7 @@ hinzufügen: Dateiname: src/lib.rs -```rust,noplayground +```rust # pub struct Post { # state: Option>, # content: String, @@ -218,7 +218,7 @@ Codeblock 17-14 zeigt diese Platzhalter-Implementierung: Dateiname: src/lib.rs -```rust,noplayground +```rust # pub struct Post { # state: Option>, # content: String, @@ -264,7 +264,7 @@ eines Beitrags zu beantragen, die seinen Zustand von `Draft` in `PendingReview` Dateiname: src/lib.rs -```rust,noplayground +```rust # pub struct Post { # state: Option>, # content: String, From 28265fd5238ce34668eedb3c0b73d5ed80b9f081 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 15:31:43 +0200 Subject: [PATCH 36/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch18-01-all-the-places-for-patterns.md | 6 ++-- src/ch18-02-refutability.md | 2 +- src/ch18-03-pattern-syntax.md | 36 +++++++++++----------- 3 files changed, 22 insertions(+), 22 deletions(-) diff --git a/src/ch18-01-all-the-places-for-patterns.md b/src/ch18-01-all-the-places-for-patterns.md index 20a89eeb..39741b8d 100644 --- a/src/ch18-01-all-the-places-for-patterns.md +++ b/src/ch18-01-all-the-places-for-patterns.md @@ -134,7 +134,7 @@ Reihenfolge ausgibt, in der sie auf den Stapel gelegt wurden. stack.push(3); while let Some(top) = stack.pop() { - println!("{}", top); + println!("{top}"); } ``` @@ -159,7 +159,7 @@ ein Tupel als Teil der `for`-Schleife zu destrukturieren oder zu zerlegen. let v = vec!['a', 'b', 'c']; for (index, value) in v.iter().enumerate() { - println!("{} ist beim Index {}", value, index); + println!("{value} ist beim Index {index}"); } ``` @@ -294,7 +294,7 @@ Werte in einem Tupel auf, wenn wir es an eine Funktion übergeben. ```rust fn print_coordinates(&(x, y): &(i32, i32)) { - println!("Aktuelle Position: ({}, {})", x, y); + println!("Aktuelle Position: ({x}, {y})"); } fn main() { diff --git a/src/ch18-02-refutability.md b/src/ch18-02-refutability.md index 69a377c1..9b2ba49d 100644 --- a/src/ch18-02-refutability.md +++ b/src/ch18-02-refutability.md @@ -83,7 +83,7 @@ Codeblock 18-8 zu korrigieren ist. # fn main() { # let some_option_value: Option = None; if let Some(x) = some_option_value { - println!("{}", x); + println!("{x}"); } # } ``` diff --git a/src/ch18-03-pattern-syntax.md b/src/ch18-03-pattern-syntax.md index 586f1fa6..3d4ffd14 100644 --- a/src/ch18-03-pattern-syntax.md +++ b/src/ch18-03-pattern-syntax.md @@ -47,10 +47,10 @@ wird, bevor du diesen Code ausführst oder weiterliest. match x { Some(50) => println!("Habe 50 erhalten"), Some(y) => println!("Passt, y = {y}"), - _ => println!("Standardfall, x = {:?}", x), + _ => println!("Standardfall, x = {x:?}"), } - println!("Am Ende: x = {:?}, y = {y}", x); + println!("Am Ende: x = {x:?}, y = {y}"); ``` Codeblock 18-11: Ein `match`-Ausdruck mit einem Zweig, @@ -237,9 +237,9 @@ fn main() { let p = Point { x: 0, y: 7 }; match p { - Point { x, y: 0 } => println!("Auf der x-Achse bei {}", x), - Point { x: 0, y } => println!("Auf der y-Achse bei {}", y), - Point { x, y } => println!("Auf keiner Achse: ({}, {})", x, y), + Point { x, y: 0 } => println!("Auf der x-Achse bei {x}"), + Point { x: 0, y } => println!("Auf der y-Achse bei {y}"), + Point { x, y } => println!("Auf keiner Achse: ({x}, {y})"), } } ``` @@ -295,7 +295,7 @@ fn main() { Message::Move { x, y } => { println!("Bewege in x-Richtung {x} und in y-Richtung {y}"); } - Message::Write(text) => println!("Textnachricht: {}", text), + Message::Write(text) => println!("Textnachricht: {text}"), Message::ChangeColor(r, g, b) => println!( "Ändere die Farbe in rot {r}, grün {g} und blau {b}" ), @@ -422,7 +422,7 @@ verwenden, einschließlich Funktionsparameter, wie in Codeblock 18-17 gezeigt. ```rust fn foo(_: i32, y: i32) { - println!("Dieser Code verwendet nur den Parameter y: {}", y); + println!("Dieser Code verwendet nur den Parameter y: {y}"); } fn main() { @@ -470,7 +470,7 @@ einen Wert zuweisen kann, wenn sie derzeit nicht gesetzt ist. } } - println!("Einstellung ist {:?}", setting_value); + println!("Einstellung ist {setting_value:?}"); ``` Codeblock 18-18: Das Verwenden eines Unterstrichs @@ -551,7 +551,7 @@ wird uns Codeblock 18-21 einen Fehler liefern. println!("Zeichenkette gefunden"); } - println!("{:?}", s); + println!("{s:?}"); ``` Codeblock 18-21: Eine unbenutzte Variable, die mit einem @@ -570,7 +570,7 @@ ohne Fehler kompilieren, weil `s` nicht in `_` verschoben wird. println!("Zeichenkette gefunden"); } - println!("{:?}", s); + println!("{s:?}"); ``` Codeblock 18-22: Das Verwenden eines Unterstrichs bindet @@ -600,7 +600,7 @@ wollen wir nur mit der Koordinate `x` operieren und die Werte in den Feldern let origin = Point { x: 0, y: 0, z: 0 }; match origin { - Point { x, .. } => println!("x ist {}", x), + Point { x, .. } => println!("x ist {x}"), } ``` @@ -646,7 +646,7 @@ Verwendung von `..`, sodass es sich nicht kompilieren lässt. match numbers { (.., second, ..) => { - println!("Einige Zahlen: {}", second) + println!("Einige Zahlen: {second}") }, } # } @@ -697,8 +697,8 @@ ist) hat. let num = Some(4); match num { - Some(x) if x % 2 == 0 => println!("Die Zahl {} ist gerade", x), - Some(x) => println!("Die Zahl {} ist ungerade", x), + Some(x) if x % 2 == 0 => println!("Die Zahl {x} ist gerade"), + Some(x) => println!("Die Zahl {x} ist ungerade"), None => (), } ``` @@ -740,10 +740,10 @@ Abgleichsbedingung verwenden können, um dieses Problem zu beheben. match x { Some(50) => println!("Habe 50 erhalten"), Some(n) if n == y => println!("Passt, n = {n}"), - _ => println!("Standardfall, x = {:?}", x), + _ => println!("Standardfall, x = {x:?}"), } - println!("Am Ende: x = {:?}, y = {y}", x); + println!("Am Ende: x = {x:?}, y = {y}"); ``` Codeblock 18-27: Verwenden einer Abgleichsbedingung zum @@ -828,11 +828,11 @@ einen anderen Namen verwenden. match msg { Message::Hello { id: id_variable @ 3..=7, - } => println!("id im Bereich gefunden: {}", id_variable), + } => println!("id im Bereich gefunden: {id_variable}"), Message::Hello { id: 10..=12 } => { println!("id in einem anderen Bereich gefunden") } - Message::Hello { id } => println!("Eine andere id gefunden: {}", id), + Message::Hello { id } => println!("Eine andere id gefunden: {id}"), } ``` From 09a308d32c77c5b10d4528090d0e5db4de31185e Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 15:47:10 +0200 Subject: [PATCH 37/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch19-01-unsafe-rust.md | 4 ++-- src/ch19-03-advanced-traits.md | 12 ++++++++---- src/ch19-04-advanced-types.md | 4 ++-- src/ch19-05-advanced-functions-and-closures.md | 2 +- src/ch19-06-macros.md | 4 ++-- 5 files changed, 15 insertions(+), 11 deletions(-) diff --git a/src/ch19-01-unsafe-rust.md b/src/ch19-01-unsafe-rust.md index ac20a43d..18172008 100644 --- a/src/ch19-01-unsafe-rust.md +++ b/src/ch19-01-unsafe-rust.md @@ -514,7 +514,7 @@ statischen Variablen mit einem Zeichenkettenanteilstyp als Wert. static HELLO_WORLD: &str = "Hallo Welt!"; fn main() { - println!("Name ist: {}", HELLO_WORLD); + println!("Name ist: {HELLO_WORLD}"); } ``` @@ -555,7 +555,7 @@ fn main() { add_to_count(3); unsafe { - println!("COUNTER: {}", COUNTER); + println!("COUNTER: {COUNTER}"); } } ``` diff --git a/src/ch19-03-advanced-traits.md b/src/ch19-03-advanced-traits.md index 33af62bd..853d1c08 100644 --- a/src/ch19-03-advanced-traits.md +++ b/src/ch19-03-advanced-traits.md @@ -296,6 +296,8 @@ impl Human { println!("*Wütend mit den Armen wedeln*"); } } +# +# fn main() {} ``` Codeblock 19-16: Zwei Merkmale sind so definiert, dass @@ -652,11 +654,13 @@ trait OutlinePrint: fmt::Display { let len = output.len(); println!("{}", "*".repeat(len + 4)); println!("*{}*", " ".repeat(len + 2)); - println!("* {} *", output); + println!("* {output} *"); println!("*{}*", " ".repeat(len + 2)); println!("{}", "*".repeat(len + 4)); } } +# +# fn main() {} ``` Codeblock 19-22: Implementieren des Merkmals @@ -685,7 +689,7 @@ zu implementieren, der `Display` nicht implementiert, z.B. die Struktur # let len = output.len(); # println!("{}", "*".repeat(len + 4)); # println!("*{}*", " ".repeat(len + 2)); -# println!("* {} *", output); +# println!("* {output} *"); # println!("*{}*", " ".repeat(len + 2)); # println!("{}", "*".repeat(len + 4)); # } @@ -740,7 +744,7 @@ Bedingung, die `OutlinePrint` erfordert, in etwa so: # let len = output.len(); # println!("{}", "*".repeat(len + 4)); # println!("*{}*", " ".repeat(len + 2)); -# println!("* {} *", output); +# println!("* {output} *"); # println!("*{}*", " ".repeat(len + 2)); # println!("{}", "*".repeat(len + 4)); # } @@ -811,7 +815,7 @@ impl fmt::Display for Wrapper { fn main() { let w = Wrapper(vec![String::from("Hallo"), String::from("Welt")]); - println!("w = {}", w); + println!("w = {w}"); } ``` diff --git a/src/ch19-04-advanced-types.md b/src/ch19-04-advanced-types.md index b8b28548..a67b6b09 100644 --- a/src/ch19-04-advanced-types.md +++ b/src/ch19-04-advanced-types.md @@ -230,7 +230,7 @@ Teil davon hier in Codeblock 19-26 wiedergegeben. # # let secret_number = rand::thread_rng().gen_range(1, 101); # -# println!("Die Geheimzahl ist: {}", secret_number); +# println!("Die Geheimzahl ist: {secret_number}"); # # loop { # println!("Bitte gib deine Schätzung ein."); @@ -248,7 +248,7 @@ Teil davon hier in Codeblock 19-26 wiedergegeben. Err(_) => continue, }; # -# println!("Du hast geschätzt: {}", guess); +# println!("Du hast geschätzt: {guess}"); # # // --abschneiden-- # diff --git a/src/ch19-05-advanced-functions-and-closures.md b/src/ch19-05-advanced-functions-and-closures.md index 65992287..4ed64cd5 100644 --- a/src/ch19-05-advanced-functions-and-closures.md +++ b/src/ch19-05-advanced-functions-and-closures.md @@ -40,7 +40,7 @@ fn do_twice(f: fn(i32) -> i32, arg: i32) -> i32 { fn main() { let answer = do_twice(add_one, 5); - println!("Die Antwort ist: {}", answer); + println!("Die Antwort ist: {answer}"); } ``` diff --git a/src/ch19-06-macros.md b/src/ch19-06-macros.md index d5e94715..29498564 100644 --- a/src/ch19-06-macros.md +++ b/src/ch19-06-macros.md @@ -155,7 +155,7 @@ Codes: `temp_vec.push()` innerhalb von `$()*` wird für jeden Teil erzeugt, der keinmal oder mehrmals mit `$()` im Muster übereinstimmt, je nachdem, wie oft das Muster passt. Das `$x` wird durch jeden passenden Ausdruck ersetzt. Wenn wir dieses Makro mit `vec![1, 2, 3];` aufrufen, wird durch diesen Aufruf -folgender Code generierte: +folgender Code generiert: ```rust,ignore { @@ -336,7 +336,7 @@ Füge das Folgende zur Datei *Cargo.toml* für `hello_macro_derive` hinzu: proc-macro = true [dependencies] -syn = "1.0" +syn = "2.0" quote = "1.0" ``` From 969bbaedbfd4a362ae6642b2ae1747333aa35fff Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 16:07:30 +0200 Subject: [PATCH 38/39] =?UTF-8?q?=C3=84nderungen=20im=20Originalbuch=20bis?= =?UTF-8?q?=20zum=2011.05.2024=20nachziehen?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch20-01-single-threaded.md | 2 +- src/ch20-02-multithreaded.md | 37 ++++------ src/ch20-03-graceful-shutdown-and-cleanup.md | 74 ++++++++------------ 3 files changed, 46 insertions(+), 67 deletions(-) diff --git a/src/ch20-01-single-threaded.md b/src/ch20-01-single-threaded.md index c0b96ba1..ea52042e 100644 --- a/src/ch20-01-single-threaded.md +++ b/src/ch20-01-single-threaded.md @@ -178,7 +178,7 @@ fn handle_connection(mut stream: TcpStream) { .take_while(|line| !line.is_empty()) .collect(); - println!("Request: {:#?}", http_request); + println!("Request: {http_request:#?}"); } ``` diff --git a/src/ch20-02-multithreaded.md b/src/ch20-02-multithreaded.md index e86c1773..aa929a45 100644 --- a/src/ch20-02-multithreaded.md +++ b/src/ch20-02-multithreaded.md @@ -353,32 +353,25 @@ use hello::ThreadPool; # } # # fn handle_connection(mut stream: TcpStream) { -# let mut buffer = [0; 1024]; -# stream.read(&mut buffer).unwrap(); -# -# let get = b"GET / HTTP/1.1\r\n"; -# let sleep = b"GET /sleep HTTP/1.1\r\n"; -# -# let (status_line, filename) = if buffer.starts_with(get) { -# ("HTTP/1.1 200 OK", "hello.html") -# } else if buffer.starts_with(sleep) { -# thread::sleep(Duration::from_secs(5)); -# ("HTTP/1.1 200 OK", "hello.html") -# } else { -# ("HTTP/1.1 404 NOT FOUND", "404.html") +# let buf_reader = BufReader::new(&mut stream); +# let request_line = buf_reader.lines().next().unwrap().unwrap(); +# +# let (status_line, filename) = match &request_line[..] { +# "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"), +# "GET /sleep HTTP/1.1" => { +# thread::sleep(Duration::from_secs(5)); +# ("HTTP/1.1 200 OK", "hello.html") +# } +# _ => ("HTTP/1.1 404 NOT FOUND", "404.html"), # }; # # let contents = fs::read_to_string(filename).unwrap(); +# let length = contents.len(); # -# let response = format!( -# "{}\r\nContent-Length: {}\r\n\r\n{}", -# status_line, -# contents.len(), -# contents -# ); +# let response = +# format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}"); # -# stream.write(response.as_bytes()).unwrap(); -# stream.flush().unwrap(); +# stream.write_all(response.as_bytes()).unwrap(); # } ``` @@ -406,7 +399,7 @@ implementieren, die diese Eigenschaften haben wird: Dateiname: src/lib.rs -```rust,noplayground +```rust pub struct ThreadPool; impl ThreadPool { diff --git a/src/ch20-03-graceful-shutdown-and-cleanup.md b/src/ch20-03-graceful-shutdown-and-cleanup.md index 611fba34..23e9618a 100644 --- a/src/ch20-03-graceful-shutdown-and-cleanup.md +++ b/src/ch20-03-graceful-shutdown-and-cleanup.md @@ -703,32 +703,25 @@ fn main() { } # # fn handle_connection(mut stream: TcpStream) { -# let mut buffer = [0; 1024]; -# stream.read(&mut buffer).unwrap(); -# -# let get = b"GET / HTTP/1.1\r\n"; -# let sleep = b"GET /sleep HTTP/1.1\r\n"; -# -# let (status_line, filename) = if buffer.starts_with(get) { -# ("HTTP/1.1 200 OK", "hello.html") -# } else if buffer.starts_with(sleep) { -# thread::sleep(Duration::from_secs(5)); -# ("HTTP/1.1 200 OK", "hello.html") -# } else { -# ("HTTP/1.1 404 NOT FOUND", "404.html") +# let buf_reader = BufReader::new(&mut stream); +# let request_line = buf_reader.lines().next().unwrap().unwrap(); +# +# let (status_line, filename) = match &request_line[..] { +# "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"), +# "GET /sleep HTTP/1.1" => { +# thread::sleep(Duration::from_secs(5)); +# ("HTTP/1.1 200 OK", "hello.html") +# } +# _ => ("HTTP/1.1 404 NOT FOUND", "404.html"), # }; # # let contents = fs::read_to_string(filename).unwrap(); +# let length = contents.len(); # -# let response = format!( -# "{}\r\nContent-Length: {}\r\n\r\n{}", -# status_line, -# contents.len(), -# contents -# ); +# let response = +# format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}"); # -# stream.write(response.as_bytes()).unwrap(); -# stream.flush().unwrap(); +# stream.write_all(response.as_bytes()).unwrap(); # } ``` @@ -821,32 +814,25 @@ fn main() { } fn handle_connection(mut stream: TcpStream) { - let mut buffer = [0; 1024]; - stream.read(&mut buffer).unwrap(); - - let get = b"GET / HTTP/1.1\r\n"; - let sleep = b"GET /sleep HTTP/1.1\r\n"; - - let (status_line, filename) = if buffer.starts_with(get) { - ("HTTP/1.1 200 OK", "hello.html") - } else if buffer.starts_with(sleep) { - thread::sleep(Duration::from_secs(5)); - ("HTTP/1.1 200 OK", "hello.html") - } else { - ("HTTP/1.1 404 NOT FOUND", "404.html") + let buf_reader = BufReader::new(&mut stream); + let request_line = buf_reader.lines().next().unwrap().unwrap(); + + let (status_line, filename) = match &request_line[..] { + "GET / HTTP/1.1" => ("HTTP/1.1 200 OK", "hello.html"), + "GET /sleep HTTP/1.1" => { + thread::sleep(Duration::from_secs(5)); + ("HTTP/1.1 200 OK", "hello.html") + } + _ => ("HTTP/1.1 404 NOT FOUND", "404.html"), }; let contents = fs::read_to_string(filename).unwrap(); + let length = contents.len(); - let response = format!( - "{}\r\nContent-Length: {}\r\n\r\n{}", - status_line, - contents.len(), - contents - ); + let response = + format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}"); - stream.write(response.as_bytes()).unwrap(); - stream.flush().unwrap(); + stream.write_all(response.as_bytes()).unwrap(); } ``` @@ -928,12 +914,12 @@ impl Worker { match message { Ok(job) => { - println!("Worker {} hat einen Auftrag erhalten; führe ihn aus.", id); + println!("Worker {id} hat einen Auftrag erhalten; führe ihn aus."); job(); } Err(_) => { - println!("Worker {} nicht mehr verbunden, wird beendet.", id); + println!("Worker {id} nicht mehr verbunden, wird beendet."); break; } } From 070b439917b9e423baea76f705665f000634d4a7 Mon Sep 17 00:00:00 2001 From: Herbert Reiter <46045854+damoasda@users.noreply.github.com> Date: Sun, 12 May 2024 16:13:41 +0200 Subject: [PATCH 39/39] mdBook 0.4.37 verwenden --- .github/workflows/pages-update.yml | 2 +- README.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/pages-update.yml b/.github/workflows/pages-update.yml index 008e732f..8f13d473 100644 --- a/.github/workflows/pages-update.yml +++ b/.github/workflows/pages-update.yml @@ -16,7 +16,7 @@ jobs: toolchain: stable - name: Install mdbook - run: cargo install mdbook --vers "^0.4.36" --no-default-features + run: cargo install mdbook --vers "^0.4.37" --no-default-features - name: Build Book run: mdbook build diff --git a/README.md b/README.md index bdef3b48..dbe99c94 100644 --- a/README.md +++ b/README.md @@ -14,7 +14,7 @@ Die deutsche Übersetzung gibt es auch als **Taschenbuch** und als **E-Book**: Schritte zum Bauen und Anschauen des Buchs: -1. mdBook installieren: `cargo install mdbook --vers "^0.4.36"` +1. mdBook installieren: `cargo install mdbook --vers "^0.4.37"` 2. Live-Vorschau-Server starten: `mdbook serve` 3. http://localhost:3000/ im Browser öffnen