You've already forked comprehensive-rust
mirror of
https://github.com/google/comprehensive-rust.git
synced 2025-12-02 01:21:59 +02:00
de: Translation until chapter 9.1 (#980)
* reformated de.po * Apply suggestions from code review Co-authored-by: ronaldfw <wotzlaw@gmail.com> --------- Co-authored-by: ronaldfw <wotzlaw@gmail.com>
This commit is contained in:
Louis Stanko
GitHub
289
po/de.po
289
po/de.po
@@ -10,7 +10,7 @@ msgstr ""
|
||||
"Content-Type: text/plain; charset=UTF-8\n"
|
||||
"Content-Transfer-Encoding: 8bit\n"
|
||||
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
|
||||
"X-Generator: Poedit 3.3.1\n"
|
||||
"X-Generator: Poedit 3.3.2\n"
|
||||
|
||||
#: src/SUMMARY.md:3
|
||||
msgid "Welcome to Comprehensive Rust 🦀"
|
||||
@@ -1565,7 +1565,6 @@ msgstr ""
|
||||
"Java."
|
||||
|
||||
#: src/running-the-course/course-structure.md:22
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"You will need an [AOSP checkout][1]. Make a checkout of the [course\n"
|
||||
"repository][2] on the same machine and move the `src/android/` directory "
|
||||
@@ -1574,10 +1573,10 @@ msgid ""
|
||||
"system\n"
|
||||
"sees the `Android.bp` files in `src/android/`."
|
||||
msgstr ""
|
||||
"Für die Android-spezifischen Teile an Tag 4 benötigst du eine lokale \n"
|
||||
" Arbeitskopie von [AOSP][1]. Mache eine Arbeitskopie des [Kurses][2] \n"
|
||||
"Du wirst eine lokale Arbeitskopie von [AOSP][1] benötigen. \n"
|
||||
"Mache eine Arbeitskopie des [Kurses][2] \n"
|
||||
" auf deinem Laptop und verschiebe das Verzeichnis `src/android/` in \n"
|
||||
" das Stammverzeichnis Deiner AOSP Arbeitskopie . Dadurch wird \n"
|
||||
" das Stammverzeichnis Deiner AOSP Arbeitskopie. Dadurch wird \n"
|
||||
" sichergestellt, dass das Android-Buildsystem die \n"
|
||||
" `Android.bp`-Dateien in `src/android/` sehen kann."
|
||||
|
||||
@@ -3652,30 +3651,27 @@ msgstr ""
|
||||
"bereitstellen. Weitere Einzelheiten erfährst Du in einem späteren Abschnitt."
|
||||
|
||||
#: src/exercises/day-1/morning.md:1
|
||||
#, fuzzy
|
||||
msgid "# Day 1: Morning Exercises"
|
||||
msgstr "# Tag 1: Morgengymnastik"
|
||||
msgstr "# Tag 1: Übungen am Morgen"
|
||||
|
||||
#: src/exercises/day-1/morning.md:3
|
||||
#, fuzzy
|
||||
msgid "In these exercises, we will explore two parts of Rust:"
|
||||
msgstr "In diesen Übungen werden wir zwei Teile von Rust erkunden:"
|
||||
|
||||
#: src/exercises/day-1/morning.md:5
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"* Implicit conversions between types.\n"
|
||||
"\n"
|
||||
"* Arrays and `for` loops."
|
||||
msgstr "* Implizite Konvertierungen zwischen Typen."
|
||||
msgstr ""
|
||||
"* Implizite Konvertierungen zwischen Typen.\n"
|
||||
"* Arrays und `for`-Schleifen."
|
||||
|
||||
#: src/exercises/day-1/morning.md:11
|
||||
#, fuzzy
|
||||
msgid "A few things to consider while solving the exercises:"
|
||||
msgstr "Ein paar Dinge, die Sie beim Lösen der Aufgaben beachten sollten:"
|
||||
msgstr "Ein paar Dinge, die Du beim Lösen der Aufgaben beachten solltest:"
|
||||
|
||||
#: src/exercises/day-1/morning.md:13
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"* Use a local Rust installation, if possible. This way you can get\n"
|
||||
" auto-completion in your editor. See the page about [Using Cargo] for "
|
||||
@@ -3684,22 +3680,22 @@ msgid ""
|
||||
"\n"
|
||||
"* Alternatively, use the Rust Playground."
|
||||
msgstr ""
|
||||
"* Verwenden Sie nach Möglichkeit eine lokale Rust-Installation. Auf diese "
|
||||
"Weise können Sie erhalten\n"
|
||||
" Autovervollständigung in Ihrem Editor. Weitere Informationen finden Sie "
|
||||
"auf der Seite über [Fracht verwenden].\n"
|
||||
" bei der Installation von Rust."
|
||||
"* Verwende nach Möglichkeit eine lokale Rust-Installation. Auf diese Weise "
|
||||
"kannst Du\n"
|
||||
" Autovervollständigung in Deinem Editor erhalten. Weitere Informationen "
|
||||
"findest Du auf der Seite: [Cargo verwenden].\n"
|
||||
"\n"
|
||||
"* Alternativ kannst du den Rust Spielplatz verwenden."
|
||||
|
||||
#: src/exercises/day-1/morning.md:19
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"The code snippets are not editable on purpose: the inline code snippets "
|
||||
"lose\n"
|
||||
"their state if you navigate away from the page."
|
||||
msgstr ""
|
||||
"Die Code-Snippets sind absichtlich nicht editierbar: die Inline-Code-"
|
||||
"Snippets gehen verloren\n"
|
||||
"ihren Zustand, wenn Sie von der Seite wegnavigieren."
|
||||
"Snippets verlieren\n"
|
||||
"Deine Änderungen, sobald Du die Seite verlässt."
|
||||
|
||||
#: src/exercises/day-1/morning.md:22 src/exercises/day-1/afternoon.md:11
|
||||
#: src/exercises/day-2/morning.md:11 src/exercises/day-2/afternoon.md:7
|
||||
@@ -3707,20 +3703,17 @@ msgstr ""
|
||||
#: src/exercises/bare-metal/afternoon.md:7
|
||||
#: src/exercises/concurrency/morning.md:12
|
||||
#: src/exercises/concurrency/afternoon.md:13
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"After looking at the exercises, you can look at the [solutions] provided."
|
||||
msgstr ""
|
||||
"Nachdem Sie sich die Übungen angesehen haben, können Sie sich die "
|
||||
"Nachdem Du Dir die Übungen angesehen hast, kannst Du Dir die "
|
||||
"bereitgestellten [Lösungen] ansehen."
|
||||
|
||||
#: src/exercises/day-1/implicit-conversions.md:1
|
||||
#, fuzzy
|
||||
msgid "# Implicit Conversions"
|
||||
msgstr "# Implizite Konvertierungen"
|
||||
msgstr "# Implizite Konvertierungen (implicit conversions)"
|
||||
|
||||
#: src/exercises/day-1/implicit-conversions.md:3
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"Rust will not automatically apply _implicit conversions_ between types "
|
||||
"([unlike\n"
|
||||
@@ -3728,7 +3721,7 @@ msgid ""
|
||||
msgstr ""
|
||||
"Rust wendet nicht automatisch _implizite Konvertierungen_ zwischen Typen an "
|
||||
"([anders als\n"
|
||||
"C++[3]). Sie können dies in einem Programm wie diesem sehen:"
|
||||
"C++[3]). Das kannst Du an einem Programm wie diesem sehen:"
|
||||
|
||||
#: src/exercises/day-1/implicit-conversions.md:6
|
||||
msgid ""
|
||||
@@ -3747,7 +3740,6 @@ msgid ""
|
||||
msgstr ""
|
||||
|
||||
#: src/exercises/day-1/implicit-conversions.md:19
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"The Rust integer types all implement the [`From<T>`][1] and [`Into<T>`][2]\n"
|
||||
"traits to let us convert between them. The `From<T>` trait has a single "
|
||||
@@ -3757,18 +3749,16 @@ msgid ""
|
||||
"into\n"
|
||||
"another type."
|
||||
msgstr ""
|
||||
"Die Rust-Integer-Typen implementieren alle [`From<T>`][1] und [`Into<T>`]"
|
||||
"[2]\n"
|
||||
"Eigenschaften, um uns zwischen ihnen umwandeln zu lassen. Das `From<T>`-"
|
||||
"Merkmal hat ein einzelnes `from()`\n"
|
||||
"-Methode und ähnlich hat das `Into<T>`-Merkmal eine einzige `into()`-"
|
||||
"Methode.\n"
|
||||
"Durch die Implementierung dieser Merkmale drückt ein Typ aus, in was er "
|
||||
"umgewandelt werden kann\n"
|
||||
"ein anderer Typ."
|
||||
"Alle Rust-Integer-Typen implementieren die [`From<T>`][1]- und [`Into<T>`]"
|
||||
"[2]-Merkmale (traits), \n"
|
||||
"um zwischen ihnen umzuwandeln. Das `From<T>`-Merkmal (trait) hat eine "
|
||||
"einzige `from()`\n"
|
||||
"-Methode und ähnlicherweise hat das `Into<T>`-Merkmal auch nur eine einzige "
|
||||
"`into()`-Methode.\n"
|
||||
"Durch die Implementierung dieser Merkmale (traits) drückt ein Typ aus, zu "
|
||||
"welchen anderen Typen dieser umgewandelt werden kann."
|
||||
|
||||
#: src/exercises/day-1/implicit-conversions.md:25
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"The standard library has an implementation of `From<i8> for i16`, which "
|
||||
"means\n"
|
||||
@@ -3776,29 +3766,27 @@ msgid ""
|
||||
"`i16::from(x)`. Or, simpler, with `x.into()`, because `From<i8> for i16`\n"
|
||||
"implementation automatically create an implementation of `Into<i16> for i8`."
|
||||
msgstr ""
|
||||
"Die Standardbibliothek hat eine Implementierung von `From<i8> for i16`, was "
|
||||
"bedeutet\n"
|
||||
"dass wir eine Variable `x` vom Typ `i8` per Aufruf in ein `i16` umwandeln "
|
||||
"können\n"
|
||||
"`i16::von(x)`. Oder einfacher mit `x.into()`, denn `From<i8> for i16`\n"
|
||||
"implementierung automatisch eine Implementierung von `Into<i16> for i8` "
|
||||
"erstellen."
|
||||
"Die Standardbibliothek enthält eine Implementierung von `From<i8> for i16`, "
|
||||
"was bedeutet\n"
|
||||
"dass wir eine Variable `x` vom Typ `i8` in ein `i16` durch `i16::from(x)` "
|
||||
"umwandeln können. \n"
|
||||
"Alternativ geht dies mit `x.into()`, denn die `From<i8> for i16`-"
|
||||
"Implementierung \n"
|
||||
"erstellt automatisch eine `Into<i16> for i8`-Implementierung."
|
||||
|
||||
#: src/exercises/day-1/implicit-conversions.md:30
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"The same applies for your own `From` implementations for your own types, so "
|
||||
"it is\n"
|
||||
"sufficient to only implement `From` to get a respective `Into` "
|
||||
"implementation automatically."
|
||||
msgstr ""
|
||||
"Dasselbe gilt für Ihre eigenen `From`-Implementierungen für Ihre eigenen "
|
||||
"Typen, so ist es\n"
|
||||
"Es reicht aus, nur `From` zu implementieren, um automatisch eine "
|
||||
"Dasselbe gilt für `From`-Implementierungen für Deine eigenen "
|
||||
"Typen.\n"
|
||||
"Es reicht also aus, nur `From` zu implementieren, um automatisch eine "
|
||||
"entsprechende `Into`-Implementierung zu erhalten."
|
||||
|
||||
#: src/exercises/day-1/implicit-conversions.md:33
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"1. Execute the above program and look at the compiler error.\n"
|
||||
"\n"
|
||||
@@ -3811,21 +3799,22 @@ msgid ""
|
||||
"for\n"
|
||||
" the pairs you check."
|
||||
msgstr ""
|
||||
"3. Ändern Sie die Typen von `x` und `y` in andere Dinge (wie `f32`, `bool`,\n"
|
||||
" `i128`), um zu sehen, welche Typen Sie in welche anderen Typen "
|
||||
"konvertieren können. Versuchen\n"
|
||||
" Umwandlung kleiner Typen in große Typen und umgekehrt. Überprüf den\n"
|
||||
" [Dokumentation der Standardbibliothek][1], um zu sehen, ob \"From<T>\" "
|
||||
"für implementiert ist\n"
|
||||
" die Paare, die Sie überprüfen."
|
||||
"1. Führe das obige Programm aus und schau Dir den Compiler-Fehler an.\n"
|
||||
"\n"
|
||||
"2. Aktualisiere den obigen Code, um `into()` für die Konvertierung zu "
|
||||
"verwenden.\n"
|
||||
"\n"
|
||||
"3. Ändere die Typen von `x` und `y` in andere Typen (z. B. `f32`, `bool`, "
|
||||
"`i128`), um zu sehen, welche Typen Du in welche anderen Typen konvertieren "
|
||||
"kannst. Versuche, kleine Typen in große Typen umzuwandeln und umgekehrt. "
|
||||
"Schau in der [Standardbibliotheksdokumentation][1] nach, ob `From<T>` für "
|
||||
"die von Dir überprüften Paare implementiert sind."
|
||||
|
||||
#: src/exercises/day-1/for-loops.md:1
|
||||
#, fuzzy
|
||||
msgid "# Arrays and `for` Loops"
|
||||
msgstr "# Arrays und `for`-Schleifen"
|
||||
|
||||
#: src/exercises/day-1/for-loops.md:3
|
||||
#, fuzzy
|
||||
msgid "We saw that an array can be declared like this:"
|
||||
msgstr "Wir haben gesehen, dass ein Array wie folgt deklariert werden kann:"
|
||||
|
||||
@@ -3837,13 +3826,12 @@ msgid ""
|
||||
msgstr ""
|
||||
|
||||
#: src/exercises/day-1/for-loops.md:9
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"You can print such an array by asking for its debug representation with `{:?}"
|
||||
"`:"
|
||||
msgstr ""
|
||||
"Sie können ein solches Array drucken, indem Sie mit `{:?}` nach seiner Debug-"
|
||||
"Darstellung fragen:"
|
||||
"Du kannst ein solches Array drucken (print), indem Du mit `{:?}` nach der "
|
||||
"Debug-Darstellung fragst:"
|
||||
|
||||
#: src/exercises/day-1/for-loops.md:11
|
||||
msgid ""
|
||||
@@ -3856,14 +3844,12 @@ msgid ""
|
||||
msgstr ""
|
||||
|
||||
#: src/exercises/day-1/for-loops.md:18
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"Rust lets you iterate over things like arrays and ranges using the `for`\n"
|
||||
"keyword:"
|
||||
msgstr ""
|
||||
"Mit Rust können Sie über Dinge wie Arrays und Ranges iterieren, indem Sie "
|
||||
"das `for` verwenden\n"
|
||||
"Stichwort:"
|
||||
"Mit Rust kannst Du über Dinge wie Arrays und Ranges iterieren, indem Du "
|
||||
"`for` verwendest:"
|
||||
|
||||
#: src/exercises/day-1/for-loops.md:21
|
||||
msgid ""
|
||||
@@ -3886,17 +3872,16 @@ msgid ""
|
||||
msgstr ""
|
||||
|
||||
#: src/exercises/day-1/for-loops.md:38
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"Use the above to write a function `pretty_print` which pretty-print a matrix "
|
||||
"and\n"
|
||||
"a function `transpose` which will transpose a matrix (turn rows into "
|
||||
"columns):"
|
||||
msgstr ""
|
||||
"Verwenden Sie das Obige, um eine Funktion \"pretty_print\" zu schreiben, die "
|
||||
"eine Matrix hübsch druckt und\n"
|
||||
"eine Funktion \"transpose\", die eine Matrix transponiert (Zeilen in Spalten "
|
||||
"umwandelt):"
|
||||
"Verwende den obigen Code, um eine Funktion `pretty_print` zu schreiben, die "
|
||||
"eine Matrix formatiert druckt und\n"
|
||||
"schreibe eine Funktion `transpose`, die eine Matrix transponiert (Zeilen in "
|
||||
"Spalten umwandelt):"
|
||||
|
||||
#: src/exercises/day-1/for-loops.md:41
|
||||
msgid ""
|
||||
@@ -3908,18 +3893,16 @@ msgid ""
|
||||
msgstr ""
|
||||
|
||||
#: src/exercises/day-1/for-loops.md:47
|
||||
#, fuzzy
|
||||
msgid "Hard-code both functions to operate on 3 × 3 matrices."
|
||||
msgstr "Kodieren Sie beide Funktionen fest, um mit 3 × 3-Matrizen zu arbeiten."
|
||||
msgstr "Beide Funktionen müssen dabei nur mit 3 × 3-Matrizen arbeiten."
|
||||
|
||||
#: src/exercises/day-1/for-loops.md:49
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"Copy the code below to <https://play.rust-lang.org/> and implement the\n"
|
||||
"functions:"
|
||||
msgstr ""
|
||||
"Kopieren Sie den folgenden Code nach <https://play.rust-lang.org/> und "
|
||||
"implementieren Sie die\n"
|
||||
"Kopiere den folgenden Code nach <https://play.rust-lang.org/> und "
|
||||
"implementiere die\n"
|
||||
"Funktionen:"
|
||||
|
||||
#: src/exercises/day-1/for-loops.md:52
|
||||
@@ -3954,58 +3937,51 @@ msgid ""
|
||||
msgstr ""
|
||||
|
||||
#: src/exercises/day-1/for-loops.md:80
|
||||
#, fuzzy
|
||||
msgid "## Bonus Question"
|
||||
msgstr "## Bonus-Frage"
|
||||
|
||||
#: src/exercises/day-1/for-loops.md:82
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"Could you use `&[i32]` slices instead of hard-coded 3 × 3 matrices for your\n"
|
||||
"argument and return types? Something like `&[&[i32]]` for a two-dimensional\n"
|
||||
"slice-of-slices. Why or why not?"
|
||||
msgstr ""
|
||||
"Könnten Sie `&[i32]`-Slices anstelle von fest codierten 3 × 3-Matrizen für "
|
||||
"Ihre verwenden\n"
|
||||
"Argument- und Rückgabetypen? Etwas wie `&[&[i32]]` für ein "
|
||||
"zweidimensionales\n"
|
||||
"Scheibe-von-Scheiben. Warum oder warum nicht?"
|
||||
"Könntest Du den `&[i32]`-Anteilstyp anstelle von fest codierten 3 × 3-Matrizen als\n"
|
||||
"Argument- und Rückgabetypen verwenden? Oder etwas wie `&[&[i32]]` für einen "
|
||||
"zweidimensionalen Anteilstyp? \n"
|
||||
"Warum oder warum nicht?"
|
||||
|
||||
#: src/exercises/day-1/for-loops.md:87
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"See the [`ndarray` crate](https://docs.rs/ndarray/) for a production "
|
||||
"quality\n"
|
||||
"implementation."
|
||||
msgstr ""
|
||||
"Siehe die [`ndarray`-Kiste](https://docs.rs/ndarray/) für eine "
|
||||
"Produktionsqualität\n"
|
||||
"Teste die [`ndarray`-Kiste](https://docs.rs/ndarray/) für eine "
|
||||
"produktionsfertige\n"
|
||||
"Implementierung."
|
||||
|
||||
#: src/exercises/day-1/for-loops.md:92
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"The solution and the answer to the bonus section are available in the \n"
|
||||
"[Solution](solutions-morning.md#arrays-and-for-loops) section."
|
||||
msgstr ""
|
||||
"Die Lösung und die Antwort zum Bonusteil finden Sie im\n"
|
||||
"Abschnitt [Solution](solutions-morning.md#arrays-and-for-loops)."
|
||||
"Die Lösung und die Antwort zum Bonusteil findest Du im\n"
|
||||
"Abschnitt [Lösung](solutions-morning.md#arrays-and-for-loops)."
|
||||
|
||||
#: src/basic-syntax/variables.md:1
|
||||
#, fuzzy
|
||||
msgid "# Variables"
|
||||
msgstr "# Variablen"
|
||||
|
||||
#: src/basic-syntax/variables.md:3
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"Rust provides type safety via static typing. Variable bindings are immutable "
|
||||
"by\n"
|
||||
"default:"
|
||||
msgstr ""
|
||||
"Rust bietet Typsicherheit durch statische Typisierung. Variable Bindungen "
|
||||
"sind unveränderlich durch\n"
|
||||
"Standard:"
|
||||
"Rust bietet Typsicherheit (type safety) durch statische Typisierung (static "
|
||||
"typing). Bindungen an Variablen (variable bindings) sind standardmäßig "
|
||||
"unveränderlich (immutable):"
|
||||
|
||||
#: src/basic-syntax/variables.md:6
|
||||
msgid ""
|
||||
@@ -4020,29 +3996,27 @@ msgid ""
|
||||
msgstr ""
|
||||
|
||||
#: src/basic-syntax/variables.md:17
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"* Due to type inference the `i32` is optional. We will gradually show the "
|
||||
"types less and less as the course progresses.\n"
|
||||
"* Note that since `println!` is a macro, `x` is not moved, even using the "
|
||||
"function like syntax of `println!(\"x: {}\", x)`"
|
||||
msgstr ""
|
||||
"* Aufgrund von Typrückschlüssen ist `i32` optional. Wir werden die Typen "
|
||||
"nach und nach immer weniger zeigen, je weiter der Typ fortschreitet.\n"
|
||||
"* Beachten Sie, dass, da `println!` ein Makro ist, `x` nicht verschoben "
|
||||
"* Aufgrund von Typ-Inferenz (type inference) ist `i32` optional. Wir werden "
|
||||
"die Typen nach und nach immer öfter weglassen, je weiter der Kurs "
|
||||
"fortschreitet.\n"
|
||||
"* Beachte, dass, da `println!` ein Makro ist, `x` nicht verschoben (moved) "
|
||||
"wird, selbst wenn die funktionsähnliche Syntax von `println!(\"x: {}\", x)` "
|
||||
"verwendet wird"
|
||||
"verwendet wird."
|
||||
|
||||
#: src/basic-syntax/type-inference.md:1
|
||||
#, fuzzy
|
||||
msgid "# Type Inference"
|
||||
msgstr "# Geben Sie Inferenz ein"
|
||||
msgstr "# Typ-Inferenz (type inference)"
|
||||
|
||||
#: src/basic-syntax/type-inference.md:3
|
||||
#, fuzzy
|
||||
msgid "Rust will look at how the variable is _used_ to determine the type:"
|
||||
msgstr ""
|
||||
"Rust wird sich ansehen, wie die Variable _verwendet_ wird, um den Typ zu "
|
||||
"Rust wird sich ansehen, wie die Variable _benutzt_ wird, um den Typ zu "
|
||||
"bestimmen:"
|
||||
|
||||
#: src/basic-syntax/type-inference.md:5
|
||||
@@ -4068,16 +4042,14 @@ msgid ""
|
||||
msgstr ""
|
||||
|
||||
#: src/basic-syntax/type-inference.md:26
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"This slide demonstrates how the Rust compiler infers types based on "
|
||||
"constraints given by variable declarations and usages."
|
||||
msgstr ""
|
||||
"Diese Folie zeigt, wie der Rust-Compiler Typen basierend auf Einschränkungen "
|
||||
"ableitet, die durch Variablendeklarationen und Verwendungen gegeben sind.\n"
|
||||
"ableitet, die durch Variablendeklarationen und Verwendungen gegeben sind."
|
||||
|
||||
#: src/basic-syntax/type-inference.md:28
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"It is very important to emphasize that variables declared like this are not "
|
||||
"of some sort of dynamic \"any type\" that can\n"
|
||||
@@ -4086,22 +4058,21 @@ msgid ""
|
||||
"The compiler does the job for us and helps us write more concise code."
|
||||
msgstr ""
|
||||
"Es ist sehr wichtig zu betonen, dass auf diese Weise deklarierte Variablen "
|
||||
"nicht von einer Art dynamischem \"beliebigen Typ\" sind, der dies kann\n"
|
||||
"irgendwelche Daten halten. Der durch eine solche Deklaration erzeugte "
|
||||
"**nicht** von einem dynamischem \"beliebigen Typ\" sind, der\n"
|
||||
"beliebige Daten enthalten kann. Der durch eine solche Deklaration erzeugte "
|
||||
"Maschinencode ist identisch mit der expliziten Deklaration eines Typs.\n"
|
||||
"Der Compiler erledigt die Arbeit für uns und hilft uns, einen prägnanteren "
|
||||
"Code zu schreiben."
|
||||
"Der Compiler erledigt lediglich die Arbeit für uns und hilft uns "
|
||||
"prägnanteren Code zu schreiben."
|
||||
|
||||
#: src/basic-syntax/type-inference.md:32
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"The following code tells the compiler to copy into a certain generic "
|
||||
"container without the code ever explicitly specifying the contained type, "
|
||||
"using `_` as a placeholder:"
|
||||
msgstr ""
|
||||
"Der folgende Code weist den Compiler an, in einen bestimmten generischen "
|
||||
"Container zu kopieren, ohne dass der Code jemals explizit den enthaltenen "
|
||||
"Typ angibt, wobei `_` als Platzhalter verwendet wird:"
|
||||
"Container zu kopieren, ohne dass jemals der enthaltene Typ explizit "
|
||||
"angegeben wird. Der Unterstrich `_` wird dabei als Platzhalter verwendet:"
|
||||
|
||||
#: src/basic-syntax/type-inference.md:34
|
||||
msgid ""
|
||||
@@ -4119,36 +4090,32 @@ msgid ""
|
||||
msgstr ""
|
||||
|
||||
#: src/basic-syntax/type-inference.md:46
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"[`collect`](https://doc.rust-lang.org/stable/std/iter/trait.Iterator."
|
||||
"html#method.collect) relies on `FromIterator`, which [`HashSet`](https://doc."
|
||||
"rust-lang.org/std/iter/trait.FromIterator.html) implements."
|
||||
msgstr ""
|
||||
"[`collect`](https://doc.rust-lang.org/stable/std/iter/trait.Iterator."
|
||||
"html#method.collect) stützt sich auf `FromIterator`, das [`HashSet`]"
|
||||
"(https:/ /doc.rust-lang.org/std/iter/trait.FromIterator.html) implementiert."
|
||||
"html#method.collect) bezieht sich auf den `FromIterator`, den [`HashSet`]"
|
||||
"(https://doc.rust-lang.org/std/iter/trait.FromIterator.html) implementiert."
|
||||
|
||||
#: src/basic-syntax/static-and-const.md:1
|
||||
#, fuzzy
|
||||
msgid "# Static and Constant Variables"
|
||||
msgstr "# Statische und konstante Variablen"
|
||||
|
||||
#: src/basic-syntax/static-and-const.md:3
|
||||
#, fuzzy
|
||||
msgid "Global state is managed with static and constant variables."
|
||||
msgstr ""
|
||||
"Der globale Status wird mit statischen und konstanten Variablen verwaltet."
|
||||
"Der globale Status (global state) wird mit statischen und konstanten "
|
||||
"Variablen verwaltet."
|
||||
|
||||
#: src/basic-syntax/static-and-const.md:5
|
||||
#, fuzzy
|
||||
msgid "## `const`"
|
||||
msgstr "## `const`"
|
||||
|
||||
#: src/basic-syntax/static-and-const.md:7
|
||||
#, fuzzy
|
||||
msgid "You can declare compile-time constants:"
|
||||
msgstr "Sie können Kompilierzeitkonstanten deklarieren:"
|
||||
msgstr "Du kannst Kompilierzeitkonstanten deklarieren:"
|
||||
|
||||
#: src/basic-syntax/static-and-const.md:9
|
||||
msgid ""
|
||||
@@ -4173,18 +4140,16 @@ msgid ""
|
||||
msgstr ""
|
||||
|
||||
#: src/basic-syntax/static-and-const.md:27
|
||||
#, fuzzy
|
||||
msgid "According to the [Rust RFC Book][1] these are inlined upon use."
|
||||
msgstr ""
|
||||
"Gemäß dem [Rust RFC Book][1] werden diese bei der Verwendung eingefügt."
|
||||
"Gemäß dem [Rust RFC Book][1] werden diese bei der Verwendung eingefügt "
|
||||
"(inlined upon use)."
|
||||
|
||||
#: src/basic-syntax/static-and-const.md:29
|
||||
#, fuzzy
|
||||
msgid "## `static`"
|
||||
msgstr "## `statisch`"
|
||||
msgstr "## `static`"
|
||||
|
||||
#: src/basic-syntax/static-and-const.md:31
|
||||
#, fuzzy
|
||||
msgid "You can also declare static variables:"
|
||||
msgstr "Sie können auch statische Variablen deklarieren:"
|
||||
|
||||
@@ -4200,7 +4165,6 @@ msgid ""
|
||||
msgstr ""
|
||||
|
||||
#: src/basic-syntax/static-and-const.md:41
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"As noted in the [Rust RFC Book][1], these are not inlined upon use and have "
|
||||
"an actual associated memory location. This is useful for unsafe and "
|
||||
@@ -4209,20 +4173,18 @@ msgid ""
|
||||
msgstr ""
|
||||
"Wie im [Rust RFC Book][1] erwähnt, werden diese bei der Verwendung nicht "
|
||||
"inliniert und haben einen tatsächlich zugeordneten Speicherort. Dies ist "
|
||||
"nützlich für unsicheren und eingebetteten Code, und die Variable lebt "
|
||||
"während der gesamten Programmausführung."
|
||||
"nützlich für unsicheren (unsafe) und eingebetteten (embedded) Code. Die "
|
||||
"Variable existiert während der gesamten Programmausführung."
|
||||
|
||||
#: src/basic-syntax/static-and-const.md:44
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"We will look at mutating static data in the [chapter on Unsafe Rust](../"
|
||||
"unsafe.md)."
|
||||
msgstr ""
|
||||
"Wir werden uns im [Kapitel über Unsafe Rust](../unsafe.md) mit mutierenden "
|
||||
"statischen Daten befassen."
|
||||
"Wir werden uns im [Kapitel über unsicheres Rust](../unsafe.md) mit "
|
||||
"mutierenden statischen Daten befassen."
|
||||
|
||||
#: src/basic-syntax/static-and-const.md:48
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"* Mention that `const` behaves semantically similar to C++'s `constexpr`.\n"
|
||||
"* `static`, on the other hand, is much more similar to a `const` or mutable "
|
||||
@@ -4230,29 +4192,27 @@ msgid ""
|
||||
"* It isn't super common that one would need a runtime evaluated constant, "
|
||||
"but it is helpful and safer than using a static."
|
||||
msgstr ""
|
||||
"* Erwähnen Sie, dass sich `const` semantisch ähnlich wie `constexpr` von C++ "
|
||||
"* Erwähne, dass sich `const` semantisch ähnlich wie `constexpr` in C++ "
|
||||
"verhält.\n"
|
||||
"* „Static“ hingegen ist einer „const“ oder veränderlichen globalen Variable "
|
||||
"in C++ viel ähnlicher.\n"
|
||||
"* `static` hingegen ist einer `const` oder veränderlichen (mutable) globalen "
|
||||
"Variable in C++ viel ähnlicher.\n"
|
||||
"* Es kommt nicht sehr häufig vor, dass man eine zur Laufzeit ausgewertete "
|
||||
"Konstante benötigt, aber es ist hilfreich und sicherer als die Verwendung "
|
||||
"einer statischen."
|
||||
|
||||
#: src/basic-syntax/scopes-shadowing.md:1
|
||||
#, fuzzy
|
||||
msgid "# Scopes and Shadowing"
|
||||
msgstr "# Bereiche und Shadowing"
|
||||
msgstr "# Gültigkeitsbereiche (scopes) und Verschattungen (shadowing)"
|
||||
|
||||
#: src/basic-syntax/scopes-shadowing.md:3
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"You can shadow variables, both those from outer scopes and variables from "
|
||||
"the\n"
|
||||
"same scope:"
|
||||
msgstr ""
|
||||
"Sie können Variablen schattieren, sowohl solche aus äußeren "
|
||||
"Gültigkeitsbereichen als auch Variablen aus dem\n"
|
||||
"gleicher Umfang:"
|
||||
"Sie können Variablen verschatten (shadow), sowohl solche aus äußeren "
|
||||
"Gültigkeitsbereichen (outer scopes) als auch Variablen aus dem\n"
|
||||
"gleichen Gültigkeitsbereich:"
|
||||
|
||||
#: src/basic-syntax/scopes-shadowing.md:6
|
||||
msgid ""
|
||||
@@ -4275,7 +4235,6 @@ msgid ""
|
||||
msgstr ""
|
||||
|
||||
#: src/basic-syntax/scopes-shadowing.md:25
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"* Definition: Shadowing is different from mutation, because after shadowing "
|
||||
"both variable's memory locations exist at the same time. Both are available "
|
||||
@@ -4287,16 +4246,16 @@ msgid ""
|
||||
"locations when shadowing an immutable variable in a scope, even if the type "
|
||||
"does not change."
|
||||
msgstr ""
|
||||
"* Definition: Shadowing unterscheidet sich von Mutation, da nach dem "
|
||||
"Shadowing die Speicherplätze beider Variablen gleichzeitig existieren. Beide "
|
||||
"sind unter demselben Namen verfügbar, je nachdem, wo Sie ihn im Code "
|
||||
"verwenden.\n"
|
||||
"* Definition: Verschattung (shadowing) unterscheidet sich von Mutation, da "
|
||||
"nach der Verschattung die Speicherplätze beider Variablen gleichzeitig "
|
||||
"existieren. Beide Speicherplätze sind unter demselben Namen verfügbar, je nachdem, wo Sie "
|
||||
"die Variablen im Code verwenden.\n"
|
||||
"* Eine Shadowing-Variable kann einen anderen Typ haben.\n"
|
||||
"* Shadowing sieht zunächst obskur aus, ist aber praktisch, um Werte nach `."
|
||||
"unwrap()` festzuhalten.\n"
|
||||
"* Der folgende Code demonstriert, warum der Compiler Speicherorte nicht "
|
||||
"einfach wiederverwenden kann, wenn er eine unveränderliche Variable in einem "
|
||||
"Bereich schattiert, selbst wenn sich der Typ nicht ändert."
|
||||
"Bereich verschattet, selbst wenn sich der Typ nicht ändert."
|
||||
|
||||
#: src/basic-syntax/scopes-shadowing.md:30
|
||||
msgid ""
|
||||
@@ -4311,17 +4270,14 @@ msgid ""
|
||||
msgstr ""
|
||||
|
||||
#: src/memory-management.md:1
|
||||
#, fuzzy
|
||||
msgid "# Memory Management"
|
||||
msgstr "# Speicherverwaltung"
|
||||
|
||||
#: src/memory-management.md:3
|
||||
#, fuzzy
|
||||
msgid "Traditionally, languages have fallen into two broad categories:"
|
||||
msgstr "Traditionell fallen Sprachen in zwei große Kategorien:"
|
||||
msgstr "Traditionell fallen Sprachen in zwei grobe Kategorien:"
|
||||
|
||||
#: src/memory-management.md:5
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"* Full control via manual memory management: C, C++, Pascal, ...\n"
|
||||
"* Full safety via automatic memory management at runtime: Java, Python, Go, "
|
||||
@@ -4332,39 +4288,33 @@ msgstr ""
|
||||
"Python, Go, Haskell, ..."
|
||||
|
||||
#: src/memory-management.md:8
|
||||
#, fuzzy
|
||||
msgid "Rust offers a new mix:"
|
||||
msgstr "Rust bietet eine neue Mischung:"
|
||||
|
||||
#: src/memory-management.md:10
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"> Full control *and* safety via compile time enforcement of correct memory\n"
|
||||
"> management."
|
||||
msgstr ""
|
||||
"> Volle Kontrolle *und* Sicherheit durch Erzwingung des korrekten Speichers "
|
||||
"zur Kompilierzeit\n"
|
||||
"> Verwaltung."
|
||||
"zur Kompilierzeit."
|
||||
|
||||
#: src/memory-management.md:13
|
||||
#, fuzzy
|
||||
msgid "It does this with an explicit ownership concept."
|
||||
msgstr "Dies geschieht mit einem expliziten Eigentumskonzept."
|
||||
msgstr ""
|
||||
"Dies geschieht mit einem expliziten Eigentumskonzept (explicit ownership "
|
||||
"concept)."
|
||||
|
||||
#: src/memory-management.md:15
|
||||
#, fuzzy
|
||||
msgid "First, let's refresh how memory management works."
|
||||
msgstr ""
|
||||
"Lassen Sie uns zunächst die Funktionsweise der Speicherverwaltung "
|
||||
"auffrischen."
|
||||
"Lasst uns zunächst die Funktionsweise der Speicherverwaltung auffrischen."
|
||||
|
||||
#: src/memory-management/stack-vs-heap.md:1
|
||||
#, fuzzy
|
||||
msgid "# The Stack vs The Heap"
|
||||
msgstr "# Der Stapel gegen den Haufen"
|
||||
msgstr "# Stapel vs. Haufen"
|
||||
|
||||
#: src/memory-management/stack-vs-heap.md:3
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"* Stack: Continuous area of memory for local variables.\n"
|
||||
" * Values have fixed sizes known at compile time.\n"
|
||||
@@ -4379,9 +4329,14 @@ msgid ""
|
||||
msgstr ""
|
||||
"* Stack: Kontinuierlicher Speicherbereich für lokale Variablen.\n"
|
||||
" * Werte haben feste Größen, die zur Kompilierzeit bekannt sind.\n"
|
||||
" * Extrem schnell: Bewegen Sie einfach einen Stapelzeiger.\n"
|
||||
" * Extrem schnell: Durch Bewegen eines Stapelzeigers.\n"
|
||||
" * Einfach zu verwalten: folgt Funktionsaufrufen.\n"
|
||||
" * Große Gedächtnislokalität."
|
||||
" * Große Speicherlokalität (memory locality).\n"
|
||||
"\n"
|
||||
"* Heap: Speicherung von Werten außerhalb von Funktionsaufrufen.\n"
|
||||
" * Werte haben dynamische Größen, die zur Laufzeit bestimmt werden.\n"
|
||||
" * Etwas langsamer als der Stapel: Etwas Buchhaltung ist erforderlich.\n"
|
||||
" * Keine Garantie für Speicherlokalität."
|
||||
|
||||
#: src/memory-management/stack.md:1
|
||||
#, fuzzy
|
||||
|
||||
Reference in New Issue
Block a user