mibeon
Start Projekte Leistungen Docs Tools Welten
--:-- CET
esc
    • Start
    • Projekte
    • Leistungen

      Kategorien

      • Websites
      • Web-Design
      • Web-Apps
      • Onlineshops
      • Web-Portale
      • APIs & Schnittstellen
      • SaaS
      • SEO
      • Linux

      Technologien

      • Angular
      • Astro
      • TypeScript
      • JavaScript
      • Node.js
      • Python
      • Django
      • FastAPI
      • PHP
      • WordPress
      • JTL-Shop
      • Grav CMS
      • Bootstrap
      • HTML & CSS
      • Go
    • Docs
      • JavaScript
      • Angular
      • TypeScript
      • Python
      • Linux
      • SysAdmin
      • PostgreSQL
      • React
      • Go
      • Electron
      • Angular Material
      • Web-APIs
      • Svelte
      • Web-Sicherheit
      • Emacs
      • Vim
      • Neovim (neues Fenster)
      • Rust
    • Tools

      Entwickler

      • JSON Formatter
      • Case Converter
      • Slug Generator
      • UUID Generator
      • Base64 Encoder/Decoder
      • URL Encoder/Decoder
      • Hash Generator
      • JWT Decoder
      • Passwort Generator
      • Zahlenbasis-Konverter
      • RegEx Tester
      • Unix Timestamp ↔ ISO 8601

      Bau & Handwerk

      • Beton-, Estrich- & Mörtelrechner
      • Schüttgut-Volumenrechner
      • Pflaster- & Fliesenrechner

      Rechnungen & Finanzen

      • IBAN-Validator & -Rechner
      • USt-IdNr.-Validator
      • SEPA-QR-Code-Generator
      • Brutto-Netto-Rechner
      • Skonto, Rabatt & Aufschlag
      • Reisekosten-Rechner

      Wissenschaftliche Rechner

      • Mathematik
        • Rechner-App
        • Grundrechenarten & Zahlen
        • Prozent & Verhältnisse
        • Potenzen & Wurzeln
        • Algebra
        • Folgen & Reihen
        • Geometrie Längen & Winkel
        • Geometrie Flächen
        • Geometrie Volumen & Oberfläche
        • Analytische Geometrie
        • Differentialrechnung
        • Integralrechnung
        • Statistik & Wahrscheinlichkeit
        • Finanzmathematik
        • Komplexe Zahlen
      • Physik
        • Rechner-App
        • Kinematik
        • Dynamik (Kräfte)
        • Energie, Arbeit & Leistung
        • Schwingungen
        • Elektrizität
        • Magnetismus & Induktion
        • Thermodynamik
        • Wellen & Schall
        • Fluide & Strömungslehre
        • Optik
        • Atom- & Kernphysik
        • Relativitätstheorie
        • Astronomie & Astrophysik
      • Chemie
        • Rechner-App
        • Stöchiometrie
        • Lösungen & Konzentrationen
        • Säuren & Basen
        • Elektrochemie
        • Thermochemie
        • Chemisches Gleichgewicht
        • Gasgesetze (Chemisch)
        • Reaktionskinetik
        • Radioaktive Chemie
        • Allgemeine Chemie
      • Biologie
        • Rechner-App
        • Zellbiologie
        • Genetik & Vererbung
        • Populationsbiologie
        • Ökologie
        • Stoffwechsel & Energetik
        • Photosynthese
        • Enzyme & Kinetik
        • Membran & Transport
        • Atmung & Gasaustausch
        • Herz & Kreislauf
        • Anthropometrie & Medizin
        • Mikrobiologie
        • Evolutionsbiologie
        • Neurobiologie
      • Elektrotechnik
        • Rechner-App
        • Gleichstrom-Grundlagen
        • Reihen- & Parallelschaltung
        • Kirchhoffsche Gesetze
        • Kondensator
        • Spule & Induktivität
        • Wechselstrom-Grundlagen
        • Impedanz & Reaktanz
        • Resonanz & Schwingkreis
        • Leistung im Wechselstromkreis
        • Transformator
        • Elektrisches Feld
        • Magnetisches Feld
        • Halbleiter & Dioden
        • Transistor (BJT)
        • Operationsverstärker
        • Leitungen & Kabel
        • Elektrische Maschinen
        • Messtechnik
      • Informatik
        • Rechner-App
        • Zahlensysteme & Kodierung
        • Boolesche Algebra
        • Datendarstellung & Speicher
        • IEEE 754 Gleitkomma
        • Algorithmen & Komplexität
        • Datenstrukturen
        • Netzwerk & Protokolle
        • Kryptographie & Hashing
        • Datenbanken
        • Betriebssysteme & Prozesse
        • Compilerbau & Formale Sprachen
        • Informationstheorie
        • Computergrafik
        • Performance & Benchmarking
      • Einheiten-Umrechner
        • Rechner-App
    • Welten
      • Geistnatur
      • Politik
      • Agitation
      • Ökonomie
    Start/Docs/Rust

    Rust

    Die ultimative deutschsprachige Rust-Doku: Ownership, References, Lifetimes, Traits, Async, Smart Pointers — plus durchgehende Tutorials für Iced-Desktop, Axum-API und Fullstack-WebApps mit Leptos.

    Grundlagen

    Alle ansehen
    • Grundlagen Der Einstieg in Rust — Sprache, Toolchain, erstes Programm
    • Was ist Rust? Systemnahe Sprache mit Memory Safety ohne Garbage Collector
    • Installation mit rustup rustup als Toolchain-Manager — stable, beta, nightly nebeneinander
    • Erstes Programm Hello World mit rustc und Cargo, Anatomie von main.rs
    • Cargo-Grundlagen Cargo als Build- und Paketmanager — Projekte, Dependencies, Profile
    • Projektstruktur Wie ein Rust-Projekt auf der Festplatte aussieht und warum
    • Editionen 2015 / 2018 / 2021 / 2024 Was Editionen sind, was sie ändern und wie du migrierst
    • Compiler und Fehlerlesen Wie eine rustc-Diagnose aufgebaut ist und wie man sie nutzt

    Variablen & Bindungen

    Alle ansehen
    • Variablen & Bindungen Wie Werte in Rust an Namen kommen — und warum let keine Variable ist
    • let-Bindung let bindet einen Namen an einen Wert — keine klassische Variable
    • mut und Immutability Default immutable, mit mut explizit veränderbar — drei Ebenen
    • Shadowing Eine neue Bindung mit altem Namen — mit oder ohne Typ-Wechsel
    • const vs. static Zwei Wege, zur Compile-Zeit feste Werte auszudrücken
    • Type Inference Wie der Compiler in 90 % aller Fälle den Typ selbst kennt
    • Scoping und Blocks Jede Schweifklammer ist ein Scope — und gleichzeitig eine Expression

    Primitive Datentypen

    Alle ansehen
    • Primitive Datentypen Die eingebauten Basistypen — und ihre besonderen Eigenheiten
    • Integer-Typen Zehn Integer-Familien, klare Bitbreiten, deterministischer Overflow
    • Float-Typen f32 und f64 nach IEEE 754 — mit allen Eigenheiten
    • bool Wirklich nur zwei Werte — kein automatisches Casten
    • char Vier Bytes Unicode-Scalar — nicht zu verwechseln mit Byte
    • Tuple Heterogene Bündel mit fester Größe — ohne Feldnamen
    • Array Stack-allokierte, homogene Sequenz mit Compile-Zeit-Länge
    • Slice View über zusammenhängenden Speicher — ohne Eigentum
    • Unit und Never Die zwei besonderen Typen — () und !
    • Numeric Conversions Drei Wege, zwischen Zahlentypen zu konvertieren — mit klaren Trade-offs

    Strings & Text

    Alle ansehen
    • Strings & Text Wie Rust mit Text umgeht — UTF-8 strikt, zwei Typen statt einem
    • str vs. String Zwei String-Typen, klare Aufgaben — und ein Trick zur API-Wahl
    • String-Slicing und Bytes Slicing in UTF-8 — wo Byte- und Zeichen-Indices auseinander gehen
    • UTF-8 und char-Iteration Drei Wege durch einen String — bytes, chars, Grapheme
    • Das format!-Makro Compile-Time-validierte Formatierung — von Padding bis Hex
    • Parsing und Konvertierung Strings in andere Typen — und umgekehrt
    • Cow<str> Mal Referenz, mal owned — Allokation nur wenn nötig

    Kontrollfluss

    Alle ansehen
    • Kontrollfluss Bedingungen, Schleifen, Pattern-Shortcuts — alle als Expressions
    • if als Expression Bedingungen, die Werte liefern — kein ternärer Operator nötig
    • loop mit Wert-Rückgabe Endlos-Schleife — und die einzige mit Wert über break
    • while Bedingung am Schleifen-Anfang — plus die while let-Variante
    • for und Range Die idiomatische Iteration — auf jedem IntoIterator
    • break, continue, Labels Schleifen beenden, überspringen, mit Labels gezielt steuern
    • if let und let else Pattern-Matches kompakt — und mit garantiertem Ausstieg

    Funktionen

    Alle ansehen
    • Funktionen Funktionen in Rust — kompakte Syntax, Expression-orientiert
    • fn-Deklaration Funktionen deklarieren — Syntax, Namens-Konventionen, pub
    • Expressions vs. Statements Das Semikolon als Bedeutungs-Grenze — Expression oder Anweisung
    • Parameter und Rückgabe Wie Werte rein- und rauskommen — Pass-by-Value, Referenzen, Tupel
    • Divergierende Funktionen Funktionen, die niemals zurückkehren — Typ !
    • Funktions-Pointer und fn-Typen Funktionen als Werte — fn-Pointer und der Vergleich zu Closures

    Ownership

    Alle ansehen
    • Ownership Das Kern-Konzept — Memory-Safety durch Compile-Zeit-Beweis
    • Ownership-Regeln Drei einfache Regeln — und der Compiler beweist Memory-Safety
    • Move-Semantik Was bei einer Zuweisung wirklich passiert — auf Bit-Ebene
    • Copy-Trait und Clone Zwei Mechanismen für Wert-Kopie — wann was?
    • Drop-Trait Deterministisches Cleanup beim Scope-Ende — das Fundament für RAII
    • Funktionsparameter und Ownership Wie Werte durch Funktionen wandern — Move, Borrow, Round-Trip
    • Stack vs. Heap Wo Werte leben — Stack (schnell, klein) vs. Heap (flexibel, groß)

    References & Borrowing

    Alle ansehen
    • References & Borrowing Werte teilen, ohne Ownership zu übergeben
    • Shared vs. Mut References Zwei Reference-Typen, eine Regel: Aliasing XOR Mutability
    • Borrow Checker Wie der Compiler die Borrow-Regeln zur Bauzeit prüft
    • Reborrowing Wie &mut-Referenzen in Funktions-Calls überleben — implizit
    • Dereferenzierung und Auto-Deref Vom Pointer zum Wert — und warum das oft unsichtbar passiert
    • Dangling References Pointer auf freigegebenen Speicher — in Safe Rust unmöglich

    Slices & Views

    Alle ansehen
    • Slices & Views Universelle Views auf zusammenhängende Daten — ohne Ownership
    • String-Slice &str Der String-Slice — UTF-8-validiert, leicht, der API-Standard
    • Array-Slices &[T] Der generische Element-Slice — universeller Funktions-Parameter
    • Mutable Slices In-Place-Bearbeitung — und der Borrow-Checker-Trick split_at_mut
    • Slice-Patterns Pattern-Matching auf Slice-Länge und Elementen — elegant
    • windows und chunks Iteratoren über Sub-Slices — gleitend oder feste Blöcke

    Structs & Methoden

    Alle ansehen
    • Structs & Methoden Eigene Datentypen mit Verhalten — das Fundament jeder Domäne
    • Struct-Grundlagen Field-Structs — die Default-Form für benannte Datenstrukturen
    • Tuple-Structs Structs mit positionalen Feldern — und der Newtype-Spezialfall
    • Unit-Structs Structs ohne Felder — kostenlose Typ-Marker
    • impl-Blocks und Methoden Methoden zu Structs hinzufügen — Receiver-Typen verstehen
    • Associated Functions Funktionen, die zum Typ gehören — nicht zur Instanz
    • derive-Makro-Grundlagen Standard-Traits automatisch ableiten — eine Zeile spart hunderte
    • Builder-Pattern Konfigurierbare Konstruktoren mit Method-Chaining
    • Newtype-Pattern Tuple-Structs mit einem Feld — typsichere Wrapper mit Zero-Cost

    Enums & Pattern Matching

    Alle ansehen
    • Enums & Pattern Matching Sum-Types und exhaustives match — das Rückgrat sicherer APIs
    • Enum-Grundlagen Sum-Types mit drei Varianten-Formen — Unit, Tuple, Struct
    • Option Optionale Werte ohne null — typsicher und explizit
    • Result Fallible Operationen ohne Exceptions — typsicher und kompositional
    • match-Exhaustiveness Der Compiler verlangt, dass du alle Varianten abdeckst
    • Patterns-Katalog Das vollständige Pattern-Vokabular der Sprache
    • if let und while let Pattern-Match für einen Branch — kompakter als match
    • let else Pattern-Match mit divergierendem Else — der Game-Changer

    Collections

    Alle ansehen
    • Collections Die wichtigsten Container der Stdlib — wann welcher
    • Vec Der wichtigste Container — wachsende Sequenz auf dem Heap
    • String als Collection String aus Container-Sicht — Vec<u8> mit UTF-8-Garantie
    • HashMap Key-Value-Lookup mit O(1) — die zweitwichtigste Collection
    • HashSet Unique-Werte-Sammlung mit O(1)-Membership
    • BTreeMap und BTreeSet Sortierte Sammlungen mit O(log n) — und Range-Queries
    • VecDeque und LinkedList VecDeque als Ring-Buffer für FIFO/LIFO — LinkedList nur selten
    • Kapazität und Reallocation Wie Vec, String, HashMap wachsen — und wie du Reallocations vermeidest

    Error Handling

    Alle ansehen
    • Error Handling Fehlerbehandlung ohne Exceptions — typsicher und explizit
    • panic vs. recoverable Wann panic, wann Result — die wichtigste Designentscheidung
    • Result im Detail Das vollständige Result-API — Kombinatoren, Extraktion, Konvertierung
    • ?-Operator Fehler-Propagation in einem Zeichen — das Standard-Werkzeug
    • From-Trait für Error-Conversion Wie der ?-Operator verschiedene Fehler-Typen automatisch konvertiert
    • Eigene Error-Typen Domain-Errors als Enum mit Error-Trait und Display-Impl
    • thiserror-Pattern Das idiomatische Crate für Library-Errors — derive statt Hand-Code
    • anyhow-Pattern Das idiomatische Crate für Application-Errors — flexibel und kontextreich
    • Error-Strategie Die richtige Wahl: thiserror, anyhow, Stdlib — wann was?

    Generics

    Alle ansehen
    • Generics Code, der mit beliebigen Typen funktioniert — ohne Laufzeit-Kosten
    • Typ-Parameter Die Syntax für generische Typen — in allen Sprach-Konstrukten
    • Trait-Bounds Constraints für Type-Parameter — welche Capabilities sind erforderlich?
    • where-Klauseln Bounds übersichtlich auslagern — die where-Syntax
    • Turbofish ::<T> — die explizite Form, wenn Type-Inference scheitert
    • Monomorphisierung Wie Generics ohne Laufzeit-Kosten funktionieren — Spezialisierung im Compiler
    • Const-Generics Typ-Parameter, die konstante Werte statt Typen sind

    Traits

    Alle ansehen
    • Traits Das zentrale Polymorphismus-Konstrukt der Sprache
    • Trait-Definition Die Syntax eines Traits — wie Verträge in Rust ausgedrückt werden
    • Default-Methoden Methoden mit Body, die der Implementierer überschreiben kann
    • Trait-Bounds im Detail Trait-Bounds in allen Kontexten — vom einfachen bis zum komplexen Fall
    • dyn Trait-Objekte Heterogene Sammlungen und runtime-polymorphe APIs mit dyn Trait
    • Static vs. Dynamic Dispatch Wann Generics, wann dyn — der definitive Vergleich
    • Associated Types Typen, die zur Trait-Implementation gehören
    • Supertraits Traits, die andere Traits voraussetzen
    • Orphan-Rule Wer darf welches Trait für welchen Typ implementieren?
    • Blanket-Implementations Eine Implementation für ALLE Typen mit bestimmten Eigenschaften
    • Marker-Traits: Send, Sync, Sized, Copy, Unpin Traits ohne Methoden, die Eigenschaften eines Typs auszeichnen
    • Operator-Overloading-Traits Operator-Verhalten für eigene Typen über Trait-Implementations

    Lifetimes

    Alle ansehen
    • Lifetimes – Übersicht Wie Rust ohne Garbage Collector Speicher-Sicherheit garantiert
    • Was sind Lifetimes Lifetimes konkret: wie der Borrow-Checker arbeitet
    • Lifetime-Annotations Die Syntax der expliziten Lifetime-Annotations
    • Lifetimes in Funktionen Funktions-Signaturen mit Lifetimes — Input, Output, Mehrfach-Refs
    • Lifetimes in Structs Structs, die Referenzen halten — Lifetime-Parameter und Konsequenzen
    • Lifetime-Elision Wann der Compiler Lifetimes von selbst ableitet
    • Static-Lifetime Die Lifetime, die so lange lebt wie das Programm
    • Lifetime-Bounds Lifetime-Constraints an Type-Parametern und Lifetime-Parametern
    • Higher-Ranked Trait Bounds (HRTB) for<'a>-Syntax für Lifetime-quantifizierte Trait-Bounds
    • Lifetimes in impl-Blöcken impl-Blöcke für Typen mit Lifetime-Parametern
    • Subtyping und Variance Wie Lifetimes sich zueinander konvertieren lassen

    Smart Pointers

    Alle ansehen
    • Smart Pointers – Übersicht Wann welcher Wrapper-Typ — der Entscheidungs-Baum für die Stdlib-Werkzeuge
    • Box Der grundlegende Heap-Container — ein Owner, eine Allocation, sauberer Drop
    • Rc Mehrere Owner für denselben Wert — single-threaded, ohne Atomics
    • Arc Wie Rc, aber thread-safe — der atomic-Counter erlaubt Sharing zwischen Threads
    • RefCell und Cell Mutation hinter geteilten Referenzen — Runtime-Borrow-Check statt Compile-Zeit
    • Mutex Exklusive Mutation über Thread-Grenzen — blockierend, mit Poison-Schutz
    • RwLock Viele Reader gleichzeitig, exklusive Writer — wann sich der Aufwand lohnt
    • Cow Borrowed oder Owned je nach Bedarf — die Allocation nur, wenn wirklich nötig
    • Rc-RefCell-Pattern und Arc-Mutex-Pattern Geteiltes Eigentum plus Interior Mutability — wann das nötig ist, wann ein Code-Smell
    • Deref-Coercion Wie aus &Box&lt;String&gt; automatisch &str wird — die Mechanik dahinter
    © 2026 MIBEON — ALLE RECHTE VORBEHALTEN
    ÜBER GLOSSAR IMPRESSUM

    Strg + Rechtsklick: Browsermenü

    Dein Browser kann nicht alle Treffer gleichzeitig hervorheben. Der aktuelle Treffer wird ausgewählt.