Sven/Snippets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rust erweitert

Browse Source
This commit is contained in:
Sven
2026-09-17 08:12:04 +02:00
parent 815facc1cf
commit 9610638462
3 changed files with 180 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Regular Expressions Cheat Sheet.md
+24 -29
View File
@@ -12,38 +12,33 @@ https://serverdiscounter.com/blog/2026-01-26-regex-grundlagen
## Special Characters ## Special Characters
| | | | | | |
| ---------- | ------------------------------------------------------------------------------- | | :------: | :------------------------------------------------------------------------------ | :------------------------------------------------------------------------ |
| `\` | Escapet Sonderzeichen oder kennzeichnet eine spezielle Sequenz | | `\` | Escapet Sonderzeichen oder kennzeichnet eine spezielle Sequenz | |
| `.` | Entspricht einem beliebigen einzelnen Zeichen mit Ausnahme eines Zeilenumbruchs | | `.` | Entspricht einem beliebigen einzelnen Zeichen mit Ausnahme eines Zeilenumbruchs | |
| `^` | Matches the start of the string. | | `^` | Matches the start of the string. | |
| `$` | Matches the end of the string​ | | `$` | Matches the end of the string​ | |
| `*` | Greedily matches 0 or more repetitions of the preceding RE. | | `*` | Greedily matches 0 or more repetitions of the preceding RE. | |
| `*?` | Matches 0 or more repetitions of the preceding RE. | | `*?` | Matches 0 or more repetitions of the preceding RE. | |
| `+` | Greedily matches 1 or more repetitions of the preceding RE. | | `+` | Greedily matches 1 or more repetitions of the preceding RE. | |
| `+?` | Matches 1 or more repetitions of the preceding RE. | | `+?` | Matches 1 or more repetitions of the preceding RE. | |
| `?` | Greedily matches 0 or 1 repetitions of the preceding RE. | | `?` | Greedily matches 0 or 1 repetitions of the preceding RE. | |
| `??` | Matches 0 or 1 repetitions of the preceding RE. | | `??` | Matches 0 or 1 repetitions of the preceding RE. | |
| `A\|B` | Matches A, if A is unmatched then matches B, where A and B are arbitrary REs. | | `A\|B` | Matches A, if A is unmatched then matches B, where A and B are arbitrary REs. | |
| `{m}` | Matches exactly m many repetitions of the previous RE. | | `{m}` | Matches exactly m many repetitions of the previous RE. | |
| `{m,n}` | Greedily matches from m many to n many repetitions of the previous RE. | | `{m,n}` | Greedily matches from m many to n many repetitions of the previous RE. | |
| `{m,n}?` | Matches m many to n many repetitions of the previous RE. | | `{m,n}?` | Matches m many to n many repetitions of the previous RE. | |
| `[...]` | Indicates a set of characters to match. | | `[...]` | Indicates a set of characters to match. | |
| `[amk]` | Matches 'a', 'm', or 'k'. | | | `[amk]` | Matches 'a', 'm', or 'k'. |
| [a-z] | Matches 'a' through 'z'. | | | `[a-z]` | Matches 'a' through 'z'. |
| `[a-f0-7]` | Matches 'a' through 'f' or '0' through '7'. | | | `[a-f0-7]` | Matches 'a' through 'f' or '0' through '7'. |
| `[a\-z]` | Matches 'a', '-', or 'z'. | | | `[a\-z]` | Matches 'a', '-', or 'z'. |
| | `[a-]` | Matches 'a' or '-'. |
| | `[-a]` | Matches 'a' or '-'. |
| | `[(+*)]` | Matches '(', '+', '*', or ')'. `[]` matches special characters literally. |
​ ​
[a-] Matches 'a' or '-'.
[-a] Matches 'a' or '-'.
[(+*)] Matches '(', '+', '*', or ')'. [] matches special characters literally.
[\w] Matches the character class for '\w'. See character classes. [\w] Matches the character class for '\w'. See character classes.
[^5] Matches anything other than '5'. '^' forms the complementary set only as the first character in a set. [^5] Matches anything other than '5'. '^' forms the complementary set only as the first character in a set.
[]()] Matches ']', '(', and ')'. ']' is taken literally only as the first character in a set. []()] Matches ']', '(', and ')'. ']' is taken literally only as the first character in a set.
Rust.md
+75
View File
@@ -76,3 +76,78 @@ fn main() { // Hauptfunktion    
Wichtiger Hinweis: In Rust muss jede Anweisung mit einem Semikolon (`;`) enden. Das Semikolon ist obligatorisch und teilt Rust mit, dass du das Ende einer Anweisung erreicht hast. Wichtiger Hinweis: In Rust muss jede Anweisung mit einem Semikolon (`;`) enden. Das Semikolon ist obligatorisch und teilt Rust mit, dass du das Ende einer Anweisung erreicht hast.
Wenn du vergisst, ein Semikolon hinzuzufügen, führt dies zu einem Kompilierungsfehler. Beachte jedoch, dass Codeblöcke, die in geschweiften Klammern `{}` eingeschlossen sind (wie Funktionsdeklarationen), keine Semikolons benötigen. Wenn du vergisst, ein Semikolon hinzuzufügen, führt dies zu einem Kompilierungsfehler. Beachte jedoch, dass Codeblöcke, die in geschweiften Klammern `{}` eingeschlossen sind (wie Funktionsdeklarationen), keine Semikolons benötigen.
## Zahlen
**Variablen** sind Container, die Datenwerte enthalten. Sie werden verwendet, um Informationen innerhalb eines Programms zu speichern, zu manipulieren und anzuzeigen.
Kurz gesagt ist eine Variable wie eine Speichereinheit, auf die wir zugreifen können, indem wir den Namen der Variable eingeben. 
Jede Variable hat einen eindeutigen **Namen** und einen **Wert**, der von unterschiedlichem Typ sein kann. Rust verfügt über verschiedene integrierte Datentypen, die den Typ des Wertes definieren, den eine Variable enthalten kann.
Um eine Variable zu initialisieren, verwenden wir das folgende **Format**:
```rust
let variable_name: variable_type = value;
```
In Rust werden Zahlen normalerweise mit zwei Hauptdatentypen dargestellt: `i32` und `f64`.
`i32` wird verwendet, um ganze Zahlen ohne Dezimalpunkt zu speichern. Zum Beispiel:
```rust
let age: i32 = 30;
let temperature: i32 = -5;
let count: i32 = 100;
```
`f64` wird verwendet, um Zahlen mit einem Dezimalpunkt zu speichern. Zum Beispiel:
```rust
let price: f64 = 99.99;
let pi: f64 = 3.14159;
let fraction: f64 = 0.5;
```
Beim Deklarieren von Variablen in Rust müssen Sie den Typ der Variable nach dem Variablennamen angeben, gefolgt von einem Doppelpunkt. Dies wird als **Typdeklaration** bezeichnet. Sobald eine Variable mit einem bestimmten Typ deklariert wurde, kann sie nur Werte dieses Typs enthalten.
### Challenge
Schreiben Sie ein Rust-Programm, das die folgenden Variablen deklariert und initialisiert:
- Deklarieren Sie eine `i32`-Variable namens `quantity`und initialisieren Sie diese mit dem Wert `5`.
- Deklarieren Sie eine `f64`-Variable namens `item_price`und initialisieren Sie diese mit dem Wert `24.99`.
Nachdem Sie diese Variablen deklariert und initialisiert haben, verwenden Sie `println!()`, um die Werte der Variablen im folgenden Format auf der Konsole auszugeben:
```rust
Quantity: [value of quantity]
Price: [value of item_price]
```
#### Lösung:
```rust
fn main() {
// Variablen hier deklarieren und initialisieren
let quantity: i32 = 5;
let item_price: f64 = 24.99;
println!("Quantity: {}", quantity);
println!("Price: {}", item_price);
}
```
## Char
Ein **char** ist ein einzelnes Zeichen (Zum Beispiel: `1, 6, %, b, p, ., T`, etc.)
Der **char**-Typ ist ein spezieller Typ, der aus einem einzelnen Zeichen besteht.
Um einen char-Wert in einer Variablen zu initialisieren, schließen Sie ihn in **einfache Anführungszeichen** ein:
```rust
let c1: char = 'h';
```
Im obigen Beispiel wird eine char-Variable namens `c1`initialisiert.
SQL.md
+81 -22
View File
@@ -538,30 +538,30 @@ Der Rest bei der Division durch 7 ist immer kleiner als 7 und reicht von 0 bis 6
##################################################### #####################################################
Challenge zu modulo #### Challenge zu modulo
> Verfügbare Tabellen und Spalten: Verfügbare Tabellen und Spalten:
>
> - `**products**`**:** `**id**`**,** `**price**`, `quantity`
> - | products | | | |
> | -------- | --- | ----- | -------- |
> | | id | price | quantity |
> | 1 | 1 | 154 | 18 |
> | 2 | 2 | 98 | 3 |
> | 3 | 3 | 54 | 15 |
> | 4 | 4 | 142 | 14 |
> | 5 | 5 | 70 | 2 |
> | 6 | 6 | 189 | 7 |
> | 7 | 7 | 44 | 3 |
> | 8 | 8 | 62 | 16 |
> | 9 | 9 | 101 | 8 |
> | 10 | 10 | 192 | 9 |
> | 11 | 11 | 4 | 21 |
> | 12 | 12 | 208 | 3 |
> | 13 | 13 | 144 | 5 |
> | 14 | 14 | 68 | 98 |
> | 15 | 15 | 5 | 14 |
- `**products**`**:** `**id**`**,** `**price**`, `quantity`
- Products
| id | price | quantity |
| :--- | :---- | :------- |
| 1 | 154 | 18 |
| 2 | 98 | 3 |
| 3 | 54 | 15 |
| 4 | 142 | 14 |
| 5 | 70 | 2 |
| 6 | 189 | 7 |
| 7 | 44 | 3 |
| 8 | 62 | 16 |
| 9 | 101 | 8 |
| 10 | 192 | 9 |
| 11 | 4 | 21 |
| 12 | 208 | 3 |
| 13 | 144 | 5 |
| 14 | 68 | 98 |
| 15 | 5 | 14
Erstellen Sie eine Abfrage, die: Erstellen Sie eine Abfrage, die:
1. Die Produkt-ID anzeigt 1. Die Produkt-ID anzeigt
@@ -1136,3 +1136,62 @@ a*a*a
``` ```
`select id , (3*id*id*id*id + 5*id*id*id + 0.9*id*id + 2.2 * id +1 )as quartic from items` `select id , (3*id*id*id*id + 5*id*id*id + 0.9*id*id + 2.2 * id +1 )as quartic from items`
### Datumsangaben behandeln – Teil 1
Daten in SQL haben ein bestimmtes Format und wir können sie ähnlich wie Zahlen abfragen. Um ein Datum in einer Abfrage zu schreiben, verwenden wir das Format: YYYY-MM-DD (2012-09-24)
Um Datumsangaben abzufragen, können wir alle Operatoren verwenden, die wir bereits kennen – größer (`>`), kleiner (`<`) oder gleich (`=`) innerhalb des Schlüsselworts WHERE:
```sql
SELECT * FROM table1WHERE col1 > '2011-01-13'
```
Wir können sogar das Schlüsselwort BETWEEN verwenden:
```sql
SELECT * FROM table1WHERE col1 BETWEEN '2010-01-01' AND '2010-02-25'
```
Verfügbare Tabellen und Spalten:
`**games**`: `**id**`, `**date**`
Rufe alle Spiel-IDs ab, die **nicht** im Winter gespielt werden.
Winterdaten sind: `2022-12-21` – `2023-03-20`. Nur diese Tage sollten nicht enthalten sein.
Sortiere sie nach dem Datum in absteigender Reihenfolge und benenne die Spalte in **game** um.
| id | date |
| --- | ------------------------ |
| 5 | 2022-11-20T22:00:00.000Z |
| 6 | 2022-01-11T22:00:00.000Z |
| 7 | 2023-01-01T22:00:00.000Z |
| 8 | 2023-02-12T22:00:00.000Z |
| 9 | 2022-10-28T21:00:00.000Z |
| 10 | 2022-08-31T21:00:00.000Z |
| 11 | 2022-12-21T22:00:00.000Z |
| 12 | 2022-12-19T22:00:00.000Z |
| 13 | 2022-10-31T22:00:00.000Z |
| 14 | 2023-03-19T22:00:00.000Z |
```sql
select id as game from games where date < "2022-12-21" or date > "2023-03-20" order by date desc
```
### Datumsangaben behandeln – Teil 2
Datumsangaben können nicht wie Zahlen addiert oder subtrahiert werden. Um Berechnungen mit Datumsangaben durchzuführen, müssen wir sie mithilfe der Funktion JULIANDAY in Zahlen umwandeln.
Diese Funktion wandelt Datumsangaben in den julianischen Tag um, eine fortlaufende Zählung der Tage seit dem 1. Januar 4713 v. Chr., die von Astronomen für Zeitintervalle und Vergleiche zwischen verschiedenen Kalendern verwendet wird.
Beachte, dass im Julianischen Tagessystem der Tag mittags (12:00:00) beginnt, sodass ein Bruchteil von .5 genau Mittag darstellt.
Um es zu verwenden, schreiben wir:
```sql
SELECT JULIANDAY('2023-02-20 12:00:00')
```
Dies gibt `2459996.0` Tage zurück
Julianische Tage beginnen mittags, daher steht `.0` für Mittag, wie im Unterrichtsbeispiel gezeigt, in dem `'2023-02-20 12:00:00'` `2459996.0` zurückgibt. Daher steht `.5` für Mitternacht (auf halbem Weg durch den `JULIANDAY`), nicht für Mittag.