Rust weiter, SQL weiter, Massmatics begonnen

Rust.md

@@ -211,5 +211,173 @@ Im obigen Beispiel werden zwei boolesche Variablen namens `variable_true` und
 
 > Booleans sind die Bausteine für die Erstellung von Logik in den Programmen, die wir schreiben. Wir haben ein ganzes Kapitel über Logik und Bedingungen.
 
+## Veränderbare Variablen
+
+In Rust sind Variablen standardmäßig unveränderlich. Das bedeutet, dass man einen Wert, sobald er einer Variablen zugewiesen wurde, nicht mehr ändern kann. Man kann eine Variable jedoch veränderlich machen, indem man bei der Deklaration der Variablen das Schlüsselwort `mut` verwendet.
+
+Zum Beispiel:
+
+```rust
+let x = 5; // x ist unveränderlich
+let mut y = 10; // y ist veränderlich
+```
+
+In diesem Beispiel ist `x` unveränderlich, sodass Sie seinen Wert nach der Initialisierung nicht mehr ändern können. Andererseits ist `y` veränderlich, sodass Sie seinen Wert später im Code ändern können.
+
+```rust
+y = 20; // Dies ist erlaubt, da y veränderbar ist
+x = 15; // Dies wird einen Fehler verursachen, da 
+```
+
+### Challenge
+Deklariere eine veränderbare Variable namens `add` und weise ihr den Wert 13 zu.
+
+Ändere den Wert von 13 auf 16.
+### Lösung
+```rust
+#[allow(unused_assignments)]
+
+fn main() {
+// Variable add initialisieren
+let mut add = 13;
+
+// Wert von 13 auf 16 ändern
+add = 16;
+
+println!("add = {}", add);
+}
+```
+
+##  Typdeklaration
+
+Sobald eine Variable mit einem bestimmten Typ deklariert wurde, kann sie nur Werte dieses Typs enthalten. Beispielsweise kann eine `i32`-Variable nur Ganzzahlwerte enthalten, und eine `String`-Variable kann nur Text enthalten.
+
+Zum Beispiel:
+
+```rust
+let mut age: i32 = 25;  // Kann nur ganze Zahlen speichern
+let mut name: &str = "Alice";  // Kann nur Text speichern
+```
+
+Diese würden Fehler verursachen:
+
+```rust
+age = "Bob";  // Fehler: Text kann nicht in eine i32-Variable geschrieben werden
+name = 30;  // Fehler: Eine Zahl kann nicht in eine String-Variable geschrieben werden
+```
+
+Diese sind gültig:
+
+```rust
+age = 26;  // OK: Zuweisen einer neuen Ganzzahl
+name = "Jane";  // OK: Zuweisen einer neuen Textzeichenkette
+```
+
+### Challenge
+Deklariere die folgenden Variablen mit ihren entsprechenden Typen und Werten:
+
+- Eine `i32`-Variable namens `count` mit dem Wert `10`.
+- Eine `f64`-Variable namens `total` mit dem Wert `150.75`.
+- Eine `char`-Variable namens `grade` mit dem Wert `'A'`.
+- Eine `bool`-Variable namens `is_active` mit dem Wert `false`.
+- Eine `String`-Variable namens `user_name` mit dem Wert `"Bob123"`.
+
+Verwende nach der Deklaration dieser Variablen `println!()`, um die Werte der Variablen im folgenden Format auf der Konsole auszugeben:
+
+```rust
+Count: [value of count]
+Total: [value of total]
+Grade: [value of grade]
+Active: [value of is_active]
+User Name: [value of user_name]
+```
+
+### Lösung
+
+```rust
+fn main() {
+// Variablen hier deklarieren
+	let count: i32 = 10;
+	let total: f64 = 150.75;
+	let grade: char = 'A';
+	let is_active: bool = false;
+	let user_name: String = "Bob123".to_string();
+
+	println!("Count: {}", count);
+	println!("Total: {}", total);
+	println!("Grade: {}", grade);
+	println!("Active: {}", is_active);
+	println!("User Name: {}", user_name);
+}
+```
+
+## Namenskonventionen
+
+In Rust gibt es mehrere Benennungskonventionen, die Sie befolgen sollten, um Ihren Code lesbarer und wartbarer zu machen. Sie sind in der Rust-Community weitgehend akzeptiert.
+
+Hier sind einige gängige Namenskonventionen:
+
+- Variablen sollten mit `snake_case` benannt werden, was bedeutet, dass alle Buchstaben kleingeschrieben und Wörter durch Unterstriche getrennt werden. Zum Beispiel: `my_variable`, `calculate_total`.
+
+- Vermeiden Sie zu kurze oder kryptische Namen. Wählen Sie aussagekräftige Namen, die den Zweck der Variable klar angeben.
+
+- Namen können Buchstaben, Ziffern und Unterstriche enthalten.
+
+- Namen müssen mit einem Buchstaben oder einem Unterstrich `_` beginnen.
+
+- Einfache Zähler verwenden normalerweise einzelne Buchstaben wie `i`, `j`, obwohl es erwähnenswert ist, dass aussagekräftigere Namen besser sein könnten, wenn der Kontext komplexer ist.
+
+## Typinferenz
+
+In Rust ermöglicht die Typinferenz dem Compiler, den Typ einer Variablen basierend auf ihrem Wert und ihrer Verwendung automatisch abzuleiten. Das bedeutet, dass Sie den Typ beim Deklarieren einer Variablen oft nicht explizit angeben müssen, was Ihren Code prägnanter und leichter lesbar macht.
+
+Zum Beispiel:
+
+```rust
+let x = 5;// Rust leitet ab, dass x ein i32 ist
+let y = 3.14;// Rust leitet ab, dass y ein f64 ist
+let message = "Hello, world!";// Rust leitet ab, dass message ein &str (String) ist
+let is_true = true;// Rust leitet ab, dass is_true ein bool ist
+```
+
+In diesen Beispielen haben wir die Typen von `x`, `y`, `message` und `is_true` nicht angegeben. Der Rust-Compiler hat ihre Typen automatisch basierend auf den ihnen zugewiesenen Werten abgeleitet.
+
+Typinferenz ist nicht nur praktisch, sondern hilft auch dabei, Fehler zu vermeiden. Der Compiler prüft, wie die Variablen verwendet werden, und stellt sicher, dass die abgeleiteten Typen im gesamten Code konsistent sind. Wenn ein Konflikt auftritt, erzeugt der Compiler eine Fehlermeldung.
+### Challenge
+
+Schreibe ein Rust-Programm, das Typinferenz demonstriert. Deklariere und initialisiere die folgenden Variablen ohne explizite Typanmerkungen:
+
+- Eine Variable namens `quantity` mit dem Wert `10`.
+- Eine Variable namens `price` mit dem Wert `99.99`.
+- Eine Variable namens `message` mit dem Wert `"Coddy is awesome!"`.
+- Eine Variable namens `is_available` mit dem Wert `true`.
+
+Verwende nach der Deklaration dieser Variablen `println!()`, um ihre Werte auf der Konsole auszugeben. Beobachte, wie Rust die Typen dieser Variablen basierend auf ihren Werten ableitet.
+
+### Lösung
+
+```rust
+fn main() {
+// Variablen hier deklarieren
+let quantity = 10;
+let price = 99.99;
+let message = "Coddy is awesome!";
+let is_available = true;
+
+// Die Werte ausgeben
+println!("Quantity: {}", quantity);
+println!("Price: {}", price);
+println!("Message: {}", message);
+println!("Is available: {}", is_available);
+}
+```
 
 
+https://rust-lernen.de/blog/zeichenketten.html
+
+https://www.reddit.com/r/rust/comments/13wzjoq/media_difference_between_string_str_and_string/?tl=de#lightbox
+
+https://cheats.rs/#pointer-meta
+
+https://rust-lang-de.github.io/rustbook-de/title-page.html
+