Skip to content

Commit f24351e

Browse files
TrifanBogdan24TrifanBogdan24
authored
Merge branch 'master' into fixing
2 parents 0062e4b + 2737cfc commit f24351e

31 files changed

+2143
-226
lines changed

‎lessons/de/chapter_5.yaml

+224
Large diffs are not rendered by default.

‎lessons/de/chapter_6.yaml

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

‎lessons/en/chapter_1.yaml

+35-23
Original file line numberDiff line numberDiff line change
@@ -111,7 +111,7 @@
111111
out for this keyword.
112112
- title: Basic Types
113113
code: >-
114-
https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&code=fn+main%28%29+%7B%0A++++let+a+%3D+13u8%3B%0A++++let+b+%3D+7u32%3B%0A++++let+c+%3D+a+as+u32+%2B+b%3B%0A++++println%21%28%22%7B%7D%22%2C+c%29%3B%0A%0A++++let+t+%3D+true%3B%0A++++println%21%28%22%7B%7D%22%2C+t+as+u8%29%3B%0A%0A++++let+d%3A+u32+%3D+12%3B%0A++++%2F%2F+let+e%3A+u32+%3D+-12%3B++%2F%2F+unsinged+nubers+include+only+positive+numbers%0A++++let+e%3A+i32+%3D+12%3B%0A++++let+f%3A+i32+%3D+-12%3B%0A++++println%21%28%22%7B%7D+%7B%7D+%7B%7D+%7B%7D%22%2C+d%2C+-%28d+as+i32%29%2C+e%2C+f%29%3B%0A%7D%0A
114+
https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&code=fn+main%28%29+%7B%0A++++let+x+%3D+12%3B+%2F%2F+by+default+this+is+i32%0A++++let+a+%3D+12u8%3B%0A++++let+b+%3D+4.3%3B+%2F%2F+by+default+this+is+f64%0A++++let+c+%3D+4.3f32%3B%0A++++let+d+%3D+%27r%27%3B+%2F%2F+unicode+character%0A++++let+ferris+%3D+%27%F0%9F%A6%80%27%3B+%2F%2F+also+a+unicode+character%0A++++let+bv+%3D+true%3B%0A++++let+t+%3D+%2813%2C+false%29%3B%0A++++let+sentence+%3D+%22hello+world%21%22%3B%0A++++println%21%28%0A++++++++%22%7B%7D+%7B%7D+%7B%7D+%7B%7D+%7B%7D+%7B%7D+%7B%7D+%7B%7D+%7B%7D+%7B%7D%22%2C%0A++++++++x%2C+a%2C+b%2C+c%2C+d%2C+ferris%2C+bv%2C+t.0%2C+t.1%2C+sentence%0A++++%29%3B%0A%7D%0A
115115
content_markdown: >
116116
Basic data types:
117117
- bool
@@ -137,28 +137,40 @@
137137
138138
139139
Rust has a variety of familiar types:
140-
141-
- `booleans` - bool for representing true/false
142-
143-
- unsigned integers - `u8` `u16` `u32` `u64` `u128` for representing positive whole numbers
144-
145-
- signed integers - i8 i16 i32 i64 i128 for representing whole numbers
146-
pointer sized integers - usize isize for representing indexes and sizes of things in memory
147-
148-
- floating point - `f32` `f64`
149-
150-
- tuple - `(value, value, ...)` for passing fixed sequences of values on the stack
151-
152-
- arrays - `[value, value, ...]` a collection of similar elements with fixed length known at compile time
153-
154-
- slices - a collection of similar elements with length known at runtime
155-
156-
- `str` (string slice) - text with a length known at runtime
157-
158-
Text might be more complex than you are used to in other languages; since
159-
Rust is a system programming language, it cares about memory issues you
160-
might not be used to. We will be going into this in detail later.
161-
140+
141+
* booleans - `bool` for representing true/false
142+
143+
* unsigned integers - `u8` `u16` `u32` `u64` `u128` for representing
144+
nonnegative whole numbers
145+
146+
* signed integers - `i8` `i16` `i32` `i64` `i128` for representing whole numbers
147+
148+
* pointer sized integers - `usize` `isize` for representing indexes
149+
150+
and sizes of things in memory
151+
152+
* floating point - `f32` `f64`
153+
154+
* characters - `char` for representing a single Unicode character
155+
156+
* tuple - `(value, value, ...)` for passing fixed sequences of values on the
157+
stack
158+
159+
* arrays - `[value, value, ...]` a collection of similar elements with fixed
160+
length known at compile time
161+
162+
* slices - a collection of similar elements with length known at runtime
163+
164+
* `str`(string slice) - text with a length known at runtime
165+
166+
167+
Text might be more complex than you are used to in other languages;
168+
169+
since Rust is a system programming language, it cares about memory
170+
171+
issues you might not be used to. We will be going into this in detail later.
172+
173+
162174
Numeric types can be explicitly specified by appending the type to the end
163175
of the number (e.g. `13u32`, `2u8`).
164176

0 commit comments

Comments
 (0)