Rust

Name: Rust | Konzepte und Praxis für die sichere Anwendungsentwicklung
Brand: dpunkt
Price: 36.9 EUR
Availability: OnlineOnly

Konzepte und Praxis für die sichere Anwendungsentwicklung

Marco Amann Joachim Baumann Marcel Koch(Autor*in)

dpunkt (Verlag)

1. Auflage

Erschienen am 1. Juni 2022

456 Seiten

E-Book

PDF mit Wasserzeichen-DRM

Systemvoraussetzungen

978-3-96910-614-3 (ISBN)

36,90 €inkl. 7% MwSt.

Systemvoraussetzungen

für PDF mit Wasserzeichen-DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Weitere Details

Weitere Ausgaben

Personen

Inhalt

Intro
Inhaltsverzeichnis
Vorwort
Zielgruppe für dieses Buch
Notwendige Vorkenntnisse für das Buch
Was dieses Buch nicht enthält
Was dieses Buch enthält
Begleitrepository
Danksagung
Marco, Joachim
Marcel
1 Rust - Einführung
1.1 Warum Rust?
1.1.1 Rust und der Speicher
1.1.2 Rust und Objektorientierung
1.1.3 Rust und funktionale Programmierung
1.1.4 Rust und Parallelverarbeitung
1.2 Ein Beispielprogramm
1.3 Installation von Rust
1.3.1 Installation von rustup
1.4 IDE-Integration
1.4.1 Rust Language Server und Rust-Analyzer
1.4.2 Visual Studio Code
1.4.3 IntelliJ IDEA
1.4.4 Eclipse
1.4.5 Welche Entwicklungsumgebung ist die beste?
1.5 Unsere erste praktische Erfahrung
1.6 Das Build-System von Rust
1.6.1 Die Struktur von Rust-Programmen
1.6.2 Die Erzeugung eines Packages
1.6.3 Übersetzen und Ausführen eines Packages
1.6.4 Verwaltung von Abhängigkeiten
1.6.5 Workspaces
1.6.6 Weitere nützliche Befehle von Cargo
1.7 Entwicklung der Sprache und Kompatibilität
2 Syntax von Rust-Programmen
2.1 Programmstruktur
2.2 Anweisungsblöcke
2.3 Rangfolge von Operatoren
2.4 Gängige Kontrollflussstrukturen
2.4.1 Das If-Konstrukt
2.4.2 Das Loop-Konstrukt
2.4.3 Die While-Schleife
2.4.4 Die For-Schleife
3 Variablen
3.1 Veränderbare und nicht veränderbare Variablen
3.2 Weitere Arten der Variablendefinition
3.2.1 Globale Variablen
3.2.2 Konstanten
4 Datentypen
4.1 Skalare Datentypen
4.1.1 Ganzzahlen
4.1.2 Fließkommazahlen
4.1.3 Logische Werte
4.1.4 Zeichen
4.1.5 Typkonvertierung
4.2 Tupel und Felder
4.2.1 Tupel
4.2.2 Felder
4.3 Strukturierte Datentypen
4.3.1 Unterstützung bei der Initialisierung
4.4 Tupelstrukturen
4.5 Aufzählungstypen
4.5.1 In Aufzählungen eingebettete Datentypen
5 Musterabgleich
5.1 Das Match-Konstrukt
5.1.1 Einfache Verwendung
5.1.2 Rückgabewerte
5.1.3 Zusätzliche Bedingungen für das Muster
5.1.4 Zuweisungen im Muster
5.2 Andere Datentypen und das Match-Konstrukt
5.3 Weitere Musterabgleiche
5.3.1 Das »If Let«-Konstrukt
5.3.2 Das »While Let«-Konstrukt
5.3.3 Das Makro matches!
6 Funktionen
6.1 Referenzen auf Funktionen
7 Einführung in das Speichermodell
7.1 Stack und Heap
7.2 Rust und der Speicher
7.3 Das Modell für skalare Datentypen
7.3.1 Wechsel von Gültigkeitsbereichen
7.3.2 Aufruf von Funktionen
7.4 Das allgemeinere Modell
7.4.1 Wechsel von Gültigkeitsbereichen
7.4.2 Aufruf von Funktionen
7.5 Referenzen in Rust
7.5.1 Lesereferenzen auf nicht veränderbare Variablen
7.5.2 Lesereferenzen auf veränderbare Variablen
7.5.3 Veränderbare Referenzen
7.6 Verwendung von Variablen und Referenzen
7.7 Vor- und Nachteile des Modells
7.7.1 Nachteile
7.7.2 Vorteile
8 Generische Datentypen
8.1 Typparameter in Datenstrukturen
8.2 Typparameter in Funktionen
8.3 Typparameter in Aufzählungstypen
9 Objektorientierte Konzepte
9.1 Methoden
9.1.1 Die Verwendung von Typparametern
9.2 Module und Sichtbarkeiten
9.2.1 Importieren von Elementen aus anderen Namensräumen
9.2.2 Hierarchische Module
9.2.3 Erweiterte Sichtbarkeiten
9.2.4 Aufteilung in mehrere Dateien
9.3 Traits
9.3.1 Erzeugung und Verwendung
9.3.2 Abhängigkeit von anderen Traits
9.3.3 Verwendung in Funktionen
9.3.4 Verwendung mit generischen Datentypen
9.3.5 Einschränkung von Typparametern mit Traits
9.3.6 Polymorphe Rückgabetypen
9.3.7 Assoziierte Datentypen
9.3.8 Die Größe von Instanzen
9.3.9 Dynamische Trait-Objekte
9.3.10 Traits, die Rust bereitstellt
9.3.11 Der Trait Drop
9.3.12 Das Attributsmakro Derive
10 Problembehandlung in Rust
10.1 Der Datentyp Option
10.2 Der Datentyp Result
10.3 Interoperabilität von Option und Result
10.4 Der ?-Operator
10.5 Nicht behebbare Fehler
10.6 Bewertung
11 Standarddatentypen von Rust
11.1 Kollektionen
11.1.1 Sequenzdatentypen
11.1.2 Map-Datentypen
11.1.3 Mengen
11.1.4 Verschiedene Datentypen in Kollektionen
11.1.5 Der Datentyp Slice
11.1.6 Zeichenketten
11.2 Der Datentyp Range
11.3 Closures
11.3.1 Verwendung als anonyme Funktion
11.3.2 Der umgebende Gültigkeitsbereich
11.4 Iteratoren
11.4.1 Erzeugung von Iteratoren
11.4.2 Erste Verwendung von Iteratoren
11.4.3 Weitere Verarbeitungsmöglichkeiten
11.4.4 Erzeugung von Iteratoren aus Iteratoren
11.4.5 Erzeugung neuer Kollektionen
12 Makros
12.1 Bekannte Makros
12.2 Beispiele für weitere Makros
12.2.1 Assertionen
12.2.2 Makros für Zeichenketten
12.3 Arten von Makros
12.4 Ein eigenes deklaratives Makro
13 Strukturierung von Projekten
13.1 Konfiguration des Packages
14 Zusammenfassung
15 Ownership im Detail
15.1 Näheres zum bekannten Ownership-Modell
15.1.1 Move, Copy, Clone, Borrow
15.1.2 Lifetimes
15.1.3 Die Sicherheit von Rust
15.2 Smart Pointer
15.2.1 Box
15.2.2 Rc
15.2.3 RefCell und Cell
15.2.4 Zusammenfassung
15.3 Vergleich mit anderen Sprachen ohne Ownership
16 Nebenläufige und parallele Programmierung
16.1 Grundlagen
16.2 Channels
16.3 Shared State
16.3.1 Arc
16.3.2 Send und Sync
16.3.3 Mutex
16.3.4 RwLock
16.4 Einfache Parallelisierung mit Rayon
16.5 Sicherheit trotz Parallelität
16.6 Async/Await
16.7 Zusammenfassung
17 Testen
17.1 Arten von Tests
17.1.1 Unit-Tests
17.1.2 Integration-Tests
17.1.3 UI-Tests
17.1.4 Testpyramide, Nachwort
17.2 Rust, Cargo und Tests
17.2.1 Platzierung von Testcode
17.3 Ausführung
17.3.1 Erwartungen der Testergebnisse (Assertions)
17.3.2 Benennung der Testfunktionen
17.4 Mocking
17.4.1 Erste Schritte ohne Framework
17.4.2 Einsatz eines Frameworks: Mockall
17.4.3 Abschließendes zu Mockall
17.5 Snapshot-Tests mit insta
17.6 Der Rust-Compiler sieht viel, aber nicht alles
17.6.1 Überläufe (Overflows)
17.6.2 OutOfBoundsCheck
17.6.3 Stockungen (Deadlocks)
17.7 Fazit
18 Webprogrammierung
18.1 Einführung
18.1.1 Warum Rust für Webprogrammierung?
18.1.2 Warum nicht Rust für Webprogrammierung?
18.1.3 Themen in diesem Kapitel
18.1.4 Eine kleine Warnung vorab
18.2 Grundlagen von Rocket
18.2.1 Handler
18.2.2 Return Types
18.2.3 Ein Blick hinter die Kulissen
18.2.4 Shared State
18.3 Das Kontaktformular
18.3.1 Routen
18.3.2 Formulare
18.3.3 Datenbankverbindung
18.3.4 Was macht Rust bis hierher so besonders?
18.3.5 Middleware
18.3.6 Guards
18.3.7 Fairings oder Guards?
18.3.8 Serverside-Templates
18.3.9 Testen mit Rocket
18.4 Betrieb
18.4.1 Logging
18.4.2 Konfiguration
18.4.3 Deployment
18.5 Fazit
19 Microservices
19.1 Eignet sich Rust für Microservices?
19.2 Aufteilung der Webanwendung in Microservices
19.3 Vorbereitungen
19.3.1 Build mit Docker
19.3.2 Cross Compilation
19.4 Die Microservices
19.4.1 Anfragen annehmen: der »Web«-Service
19.4.2 Gemeinsame Funktionalität
19.4.3 Speichern der Anfragen in der Datenbank
19.4.4 Mail verschicken
19.5 Betrieb
19.5.1 Metriken und Monitoring
19.5.2 Tracing
19.5.3 Skalierung
19.6 Zusammenfassung
20 Systemnahe Programmierung
20.1 Unsafe Rust
20.1.1 Pointer-Grundlagen
20.1.2 Unsafe in std: RefCell als Beispiel
20.2 Systemaufruf
20.2.1 Systemaufruf in Handarbeit
20.2.2 Systemaufruf mit dem Crate libc
20.3 Integration von externen Bibliotheken in Rust
20.3.1 Fallstricke
20.4 Performanceuntersuchung
20.4.1 Erste Schritte
20.4.2 Benchmarks
20.4.3 Untersuchungen
20.4.4 Optimierung
20.5 Zusammenfassung
21 Spracherweiterungen (Language Bindings)
21.1 Java
21.1.1 Grundsätzliches - Java ruft Rust auf
21.1.2 j4rs
21.1.3 Zusammenfassung
21.2 Node.js
21.3 Fazit
22 WebAssembly
22.1 Aktueller Stand von WebAssembly
22.1.1 Im Browser
22.1.2 Außerhalb des Browsers - ein Anfang
22.2 Rust & WASM
22.2.1 Warum Rust für WASM?
22.2.2 Im Browser: wasm-bindgen & wasm-pack
22.2.3 Auf dem Server
22.3 Fazit
23 Zusammenfassung und Ausblick
23.1 Zusammenfassung
23.2 Ausblick

Systemvoraussetzungen

Als PDF speichern Als Link merken