Rust: Unterschied zwischen den Versionen

Aus Dokument
Zur Navigation springen Zur Suche springen
← Zum vorherigen Versionsunterschied

Thorsten (Diskussion | Beiträge)

3 Benutzergruppen
69 Bearbeitungen
VisuellWikitext
// via Wikitext Extension for VSCode
 
(53 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).
''Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).''
----


Rust ist eine von Mozilla Research entwickelte Programmiersprache, die sich auf Sicherheit, Geschwindigkeit und Parallelität konzentriert. Sie ist syntaktisch ähnlich zu C++, aber mit zusätzlichen Funktionen, die die Sicherheit und die Nebenläufigkeit verbessern. Rust wurde 2010 von Graydon Hoare entworfen und ist seit 2012 Open Source. Rust wurde von Mozilla Research entwickelt und wird von der Rust Foundation unterstützt. Rust wird hauptsächlich für Systemprogrammierung verwendet, wo Sicherheit, Geschwindigkeit und Nebenläufigkeit wichtig sind. Rust ist eine statisch typisierte Sprache, die eine starke Typisierung und Typinferenz verwendet. Rust verwendet ein Borrow-Checker-System, um Speicherfehler zur Kompilierzeit zu verhindern. Rust hat eine aktive Community und eine wachsende Anzahl von Bibliotheken und Frameworks. Rust ist eine moderne Programmiersprache, die sich auf Sicherheit, Geschwindigkeit und Parallelität konzentriert. Rust ist eine von Mozilla Research entwickelte Programmiersprache, die sich auf Sicherheit, Geschwindigkeit und Parallelität konzentriert. Sie ist syntaktisch ähnlich zu C++, aber mit zusätzlichen Funktionen, die die Sicherheit und die Nebenläufigkeit verbessern. Rust wurde 2010 von Graydon Hoare entworfen und ist seit 2012 Open Source. Rust wurde von Mozilla Research entwickelt und wird von der Rust Foundation unterstützt. Rust wird hauptsächlich für Systemprogrammierung verwendet, wo Sicherheit, Geschwindigkeit und Nebenläufigkeit wichtig sind. Rust ist eine statisch typisierte Sprache, die eine starke Typisierung und Typinferenz verwendet. Rust verwendet ein Borrow-Checker-System, um Speicherfehler zur Kompilierzeit zu verhindern. Rust hat eine aktive Community und eine wachsende Anzahl von Bibliotheken und Frameworks. Rust ist eine moderne Programmiersprache, die sich auf Sicherheit, Geschwindigkeit und Parallelität konzentriert. Rust ist eine von Mozilla Research entwickelte Programmiersprache, die sich auf Sicherheit, Geschwindigkeit und Parallelität konzentriert. Sie ist syntaktisch ähnlich zu C++,
==Weblink==
== Rust Installieren==
* Boris Paskhaver Learn to Code with Rust
<pre>
sudo apt  install curl
sudo apt install build-essential
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
</pre>
== Rust Web Frameworks==
* Actix-Web


Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).
== Phase 1: [[Rust/Grundlagen|Grundlagen]] (Wochen 1-2) ==
Ziel: Verstehen der Basiskonzepte von Rust und der Toolchain.
 
* '''[[Rust/Installation und Setup|Installation und Setup]]'''
** [[Rust/Installation von `rustup`, `rustc` und `cargo`|`rustup`, `rustc` und `cargo`]].
** [[Rust/"Hello World!" Programm|"Hello World!" Programm]].
** [[Rust/IDE-Setup|IDE-Setup]] (z. B. VS Code mit rust-analyzer).
* '''Grundlegende Syntax'''
** Variablen und Mutabilität (`let`, `let mut`).
** Datentypen (Skalare und Verbundtypen).
** Funktionen und Kommentare.
* '''Kontrollstrukturen'''
** `if`, `else if`, `else`.
** Schleifen (`loop`, `while`, `for`).
* '''Ressourcen:''' [https://doc.rust-lang.org/book/ch01-00-getting-started.html Das offizielle Rust Book (Kapitel 1-3)]
 
== Phase 2: Ownership und Borrowing (Wochen 3-4) ==
Ziel: Meistern des wichtigsten und einzigartigsten Konzepts von Rust.
 
* '''Ownership'''
** Stack vs. Heap.
** Ownership-Regeln.
** Die `String` Typen und Speichermanagement.
* '''Referenzen und Borrowing (Ausleihen)'''
** Mutable und Immutable References.
** Data Races verhindern.
* '''Slices'''
** String Slices (`&str`).
** Array Slices.
* '''Ressourcen:''' [https://doc.rust-lang.org/book/ch04-00-understanding-ownership.html The Rust Book (Kapitel 4)], Rustlings Übungen.
 
== Phase 3: Fortgeschrittene Datenstrukturen (Wochen 5-6) ==
Ziel: Komplexe Datenmodelle erstellen.
 
* '''Structs (Strukturen)'''
** Definieren und Instanziieren.
** Methoden und assoziierte Funktionen (`impl` Blöcke).
* '''Enums (Aufzählungen) und Pattern Matching'''
** Enums definieren.
** Die `Option<T>` und `Result<T, E>` Enums.
** Der `match` Kontrollfluss.
** `if let` Syntax.
* '''Collections (Auflistungen)'''
** Vektoren (`Vec<T>`).
** Strings (`String` vs `&str`).
** Hash Maps (`HashMap<K, V>`).
* '''Ressourcen:''' The Rust Book (Kapitel 5, 6, 8).
 
== Phase 4: Fehlerbehandlung, Generics und Traits (Wochen 7-8) ==
Ziel: Robusten und wiederverwendbaren Code schreiben.
 
* '''Fehlerbehandlung'''
** Unrecoverable Errors (`panic!`).
** Recoverable Errors (`Result`).
** Propagieren von Fehlern (der `?` Operator).
* '''Generics'''
** In Funktionen, Structs und Enums.
* '''Traits (Schnittstellen)'''
** Traits definieren und implementieren.
** Trait Bounds.
* '''Lifetimes (Lebensdauern)'''
** Validierung von Referenzen.
* '''Ressourcen:''' The Rust Book (Kapitel 9, 10).
 
== Phase 5: Praktische Anwendung und fortgeschrittene Themen (Wochen 9-12) ==
Ziel: Eigene Projekte bauen und das Ökosystem verstehen.
 
* '''Schreiben von automatisierten Tests'''
** Unit-Tests und Integrations-Tests.
* '''Iteratoren und Closures'''
** Funktionale Sprachfeatures in Rust.
* '''Cargo und Crates.io'''
** Eigene Libraries schreiben und Abhängigkeiten verwalten.
** Workspaces.
* '''Smart Pointers (Optional/Fortgeschritten)'''
** `Box<T>`, `Rc<T>`, `RefCell<T>`.
* '''Nebenläufigkeit (Concurrency)'''
** Threads.
** Message Passing (Channels).
** Shared State (`Mutex<T>`, `Arc<T>`).
 
== Abschlussprojekt ==
* '''Ideen:'''
** Ein CLI-Tool (z. B. eine eigene `grep`-Version wie `minigrep` aus dem Buch).
** Ein einfacher Webserver (z.B. mit dem `axum` oder `actix-web` Framework).
** Ein kleines TUI-Spiel (z.B. Snake) mit `ratatui`.
 
== Kontinuierliches Lernen ==
* [https://doc.rust-lang.org/rust-by-example/ Rust by Example]
* Täglich oder wöchentlich an [https://github.com/rust-lang/rustlings Rustlings] arbeiten.
* Rust-Code von Open-Source-Projekten lesen.
 
----
''Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).''

Aktuelle Version vom 4. März 2026, 08:11 Uhr

Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).

  • Boris Paskhaver Learn to Code with Rust

Phase 1: Grundlagen (Wochen 1-2)

Ziel: Verstehen der Basiskonzepte von Rust und der Toolchain.

Phase 2: Ownership und Borrowing (Wochen 3-4)

Ziel: Meistern des wichtigsten und einzigartigsten Konzepts von Rust.

  • Ownership
    • Stack vs. Heap.
    • Ownership-Regeln.
    • Die `String` Typen und Speichermanagement.
  • Referenzen und Borrowing (Ausleihen)
    • Mutable und Immutable References.
    • Data Races verhindern.
  • Slices
    • String Slices (`&str`).
    • Array Slices.
  • Ressourcen: The Rust Book (Kapitel 4), Rustlings Übungen.

Phase 3: Fortgeschrittene Datenstrukturen (Wochen 5-6)

Ziel: Komplexe Datenmodelle erstellen.

  • Structs (Strukturen)
    • Definieren und Instanziieren.
    • Methoden und assoziierte Funktionen (`impl` Blöcke).
  • Enums (Aufzählungen) und Pattern Matching
    • Enums definieren.
    • Die `Option<T>` und `Result<T, E>` Enums.
    • Der `match` Kontrollfluss.
    • `if let` Syntax.
  • Collections (Auflistungen)
    • Vektoren (`Vec<T>`).
    • Strings (`String` vs `&str`).
    • Hash Maps (`HashMap<K, V>`).
  • Ressourcen: The Rust Book (Kapitel 5, 6, 8).

Phase 4: Fehlerbehandlung, Generics und Traits (Wochen 7-8)

Ziel: Robusten und wiederverwendbaren Code schreiben.

  • Fehlerbehandlung
    • Unrecoverable Errors (`panic!`).
    • Recoverable Errors (`Result`).
    • Propagieren von Fehlern (der `?` Operator).
  • Generics
    • In Funktionen, Structs und Enums.
  • Traits (Schnittstellen)
    • Traits definieren und implementieren.
    • Trait Bounds.
  • Lifetimes (Lebensdauern)
    • Validierung von Referenzen.
  • Ressourcen: The Rust Book (Kapitel 9, 10).

Phase 5: Praktische Anwendung und fortgeschrittene Themen (Wochen 9-12)

Ziel: Eigene Projekte bauen und das Ökosystem verstehen.

  • Schreiben von automatisierten Tests
    • Unit-Tests und Integrations-Tests.
  • Iteratoren und Closures
    • Funktionale Sprachfeatures in Rust.
  • Cargo und Crates.io
    • Eigene Libraries schreiben und Abhängigkeiten verwalten.
    • Workspaces.
  • Smart Pointers (Optional/Fortgeschritten)
    • `Box<T>`, `Rc<T>`, `RefCell<T>`.
  • Nebenläufigkeit (Concurrency)
    • Threads.
    • Message Passing (Channels).
    • Shared State (`Mutex<T>`, `Arc<T>`).

Abschlussprojekt

  • Ideen:
    • Ein CLI-Tool (z. B. eine eigene `grep`-Version wie `minigrep` aus dem Buch).
    • Ein einfacher Webserver (z.B. mit dem `axum` oder `actix-web` Framework).
    • Ein kleines TUI-Spiel (z.B. Snake) mit `ratatui`.

Kontinuierliches Lernen

Hinweis: Diese Inhalte wurden mit Unterstützung von Künstlicher Intelligenz erstellt und redaktionell überprüft (Transparenzhinweis gemäß Art. 50 EU AI Act).

Abgerufen von „https://mediawiki.wissen-ahrensburg.de/index.php?title=Rust&oldid=3134“