Rust (eBook)

Das umfassende Handbuch

Marc Marburger (Autor)

eBook Download: EPUB

2024 | 1. Auflage
1016 Seiten
Rheinwerk Computing (Verlag)
978-3-8362-9020-3 (ISBN)

Infos

Werden Sie Rust-Profi und entwickeln Sie moderne, sichere Software!
Rust ist für sein cleveres Speichermanagement, hervorrangende Sicherheit und viele beliebte Features bekannt. Nutzen Sie das hervorrangende Design dieser Sprache, um moderne und robuste Software auf professionellem Niveau zu entwickeln! Dieses Handbuch begleitet Sie beim Einstieg und stellt Rust dann detailliert vor - sowohl für systemnahe Prorammierung als auch für Enterprise- und Cloud-Anwendungen. Mit vielen gut kommentierten Codebeispielen, Best Practices und einer durchgehenden Demo-Anwendung. Zugleich lassen sich alle Kapitel gut einzeln lesen und zum Nachschlagen verwenden. Der ideale Weg zu fundierten und umfassenden Kenntnissen!

Aus dem Inhalt:

• Rust installieren, Toolchain aufsetzen
• Fundierter Einstieg
• Speichermanagement
• Traits und Closures
• Collections und Iteratoren
• Asynchrone Programmierung
• Multithreading
• Arbeiten mit Text
• Dokumentation und Test automatisieren
• Schnittstellen zu anderen Sprachen

Marc Marburger hat langjährige Erfahrung in der App- und Softwareentwicklung. Angefangen hat er nach dem Abschluss in Informatik mit C++ und Assembler in der Industrieautomatisierung. Plattformübergreifende Apps beschäftigen ihn seit 2012, von C# auf der Windows-Plattform über Xamarin kommend liegt sein Fokus nun auf Dart und Flutter, die er täglich als freiberuflicher Softwareentwickler in Kundenprojekten einsetzt.

Textauszug

3.2    Variablen

Bits und Bytes benötigen ein Zuhause. Damit die Zahlen, logischen Aussagen und Zeichenketten nicht haltlos in der Codesuppe umhertreiben, führen wir beim Programmieren Variablen ein. Das geschieht in zwei Schritten: bei der Deklaration des Bezeichners und dessen Typs sowie bei der Zuweisung eines Werts, der Initialisierung.

Die nächsten Abschnitte führen Sie durch die Eigenschaften von Variablen, insbesondere betrachten wie die Veränderlichkeit. Daneben behandeln wir Sprachfeatures wie die Typinferenz und das Shadowing. Die Frage nach der Veränderlichkeit von Variablen und Referenzen stellt einen zentralen Baustein von Rust dar: Grundsätzlich sind alle Variablen und Referenzen unveränderlich, nachdem Sie sie eingeführt haben. Erst das Schlüsselwort mut, kurz für mutable (zu Deutsch »veränderlich«), das Sie in der Deklaration einsetzen, ermöglicht eine erneute Zuweisung oder den schreibenden Zugriff.

Diese Eigenschaften führt ein Beispiel am Ende des Abschnitts vor. Dort werden Sie sehen, wie Sie in Rust eine Zeichenkette einlesen und in eine numerische Repräsentation bringen.

3.2.1    Die Deklaration einer Variable

Rust ist eine statisch typisierte Sprache. Jeder Wert, jede Variable, jede Funktion oder jede Struktur weist folglich einen festen Typ auf. Eine Variable kann nur jene Werte binden, die dem eigenen Datentyp entsprechen: Einer Variable vom Typ einer Ganzzahl, wie in Listing 3.1, können Sie zum Beispiel keine Zeichenkette und nicht einmal eine Fließkommazahl zuweisen!

Das statische Typsystem von Rust unterstützt das Verständnis von Rust-Code. Es fällt leichter, der Verwendung einer Variable im Code zu folgen, wenn der Typ verbindlich ist. Der Compiler erhält überdies Zusagen über deren Speicherbedarf und kann etwaige Optimierungen vornehmen. Sie können zwar den Typ und den Wert in einem Zug angeben (mehr dazu folgt in Abschnitt 3.2.2), aber oft steht der initiale Wert nicht fest, sodass Sie eine Variable zunächst deklarieren. Das erspart Ihnen, die Variable unnötigerweise für kurze Zeit zuzuweisen.

Angenommen, Sie möchten das Alter einer Person in Ihrem Programm einlesen. Damit Sie die Eingabe abspeichern können, führen Sie mit dem Schlüsselwort let die Variable alter ein. Etwa so:

fn main() {
let alter: i8;
}

Listing 3.1     Die Deklaration der Variable »alter«

Im Rumpf der Funktion main sehen Sie die Deklaration einer Variable. Das Schlüsselwort let eröffnet die Zeile und führt den Bezeichner (engl. Identifier) alter für die Variable ein. Darauf folgt der Doppelpunkt, mit dem Sie den Datentyp angeben. Diese Schreibweise unterscheidet sich deutlich von C und C++. Rust ist damit jedoch nicht allein, denn unter anderem setzen auch die Programmiersprachen Swift und Kotlin diese Syntax ein.

Der Typ i8 repräsentiert einen Integer von 8 Bit Breite. Integer ist das englische Wort für Ganzzahl. Neben i8 kennt Rust weitere numerische Werte, etwa den Datentyp i16 für eine Ganzzahl mit 16 Bit Breite. Die Typen stehen Ihnen in gängigen Bitgrößen (16, 32, 64 …) zur Auswahl. In Abschnitt 3.4.2, »Integer«, stelle ich Ihnen die anderen Ganzzahl-Datentypen vor.

Warum eigentlich »let«?

Ist Ihnen das Schlüsselwort let bereits in anderen Programmiersprachen begegnet? Woher kommt let? Tatsächlich fand sich dieses Schlüsselwort schon in BASIC! Im Jahr 1964 erschien dessen erstes Benutzerhandbuch und erklärte die Verwendung von let.

Der Ausdruck lässt sich ursprünglich auf die Mathematik zurückführen. Erinnern Sie sich an Aufgabenstellungen wie »Gegeben sei X=2 …«? Auf Englisch sagt man dann: »Let X=2«. Somit lehnte sich BASIC an die mathematische Ausdrucksweise an. Damals waren die Felder Mathematik und »Informatik« noch viel enger miteinander verbunden. Tatsächlich wurde eine Vorstellung von Software-Engineering als etwas Eigenständiges (abseits der Hardware) erst auf der NATO Conference 1968 in Garmisch herausgearbeitet!

Auch heute verwenden neben Rust einige Sprachen das Schlüsselwort let. So findet sich let außer in Rust ebenfalls in JavaScript (seit ES2015), Swift und C# (LINQ).

3.2.2    Eine Variable initialisieren

Die Variable alter mit dem Typ i8 wartet nun auf eine Wertzuweisung. Die Initialisierung als zweiter Schritt steht noch aus. Falls Sie eine Variable auslesen möchten, die Sie davor nicht initialisiert haben, meldet der Compiler sofort einen Fehler!

Hierdurch verhindert Rust ein undefiniertes Verhalten: Ohne den Fehler könnte das Speicherobjekt der Variable ein Bitmuster aufweisen, das mit dem Datentyp inkompatibel ist. Ein Beispiel: Der Datentyp String stellt durch seine Schnittstellen sicher, dass sich darin ausschließlich Zeichen befinden, die als UTF-8 kodiert worden sind. Würden Sie einen String deklarieren und vor der Initialisierung auslesen, würden sich im Speicherobjekt Bitmuster befinden, die UTF-8 nur zufällig oder gar nicht repräsentieren kann.

Folgendermaßen weisen Sie der Variable im Zuge der Deklaration einen Wert zu:

fn main() {
let alter: i8 = 42;
}

Listing 3.2     Die Variable »alter« initialisieren

Rust prüft an dieser Stelle zwei Dinge:

• Weist der Wert, den Sie zuweisen wollen, den gleichen Datentyp auf oder müssten Sie ihn zuvor konvertieren?

• Und wird der Wert in den Wertebereich des Zieltyps passen?

Im Beispiel entspricht das Literal 42 den Anforderungen, die ein vorzeichenbehafteter und acht Bit breiter i8 aufstellt, dessen positiver Maximalwert die Zahl 127 nicht übersteigen kann (Zweierkomplement, -128 bis 127).

Fehler wie Überläufe führen zu Sicherheits- und Speicherfehlern oder zumindest zu Verwirrung über das Ergebnis. Die Prüfung des Wertebereichs zur Kompilierzeit stellt vor diesem Hintergrund eine bedeutende Hilfe für den Programmierer dar. Während etwa C oder C++ höchstens eine Warnung über die implizite Umwandlung einer größeren Ganzzahl in eine kleinere ausgibt, meldet der Rust-Compiler einen Fehler! C oder C++-Linter können Sie freilich so konfigurieren, dass eine Warnung zu einem Fehler führt. Diese Maßnahme und die vorauseilenden Diskussionen im Team über das Für und Wider sparen Sie sich jedoch in Rust.

Eine Probe gefällig? Ändern Sie den Wert 42 zu 420, und reichen Sie das Programm an den Compiler weiter. Das Ergebnis:

error: literal out of range for `i8`
–> src/main.rs:6:19
|
6 | let alter: i8 = 420;
| ^^^
|
= note: `#[deny(overflowing_literals)]` on by default
= note: the literal `420` does not fit into the type `i8` whose range is
`-128..=127`
= help: consider using the type `i16` instead

Der Compiler markiert die Fehlerposition innerhalb des Codeschnipsels. Darunter befinden sich Informationen zu der Regel, die vom Code verletzt wurde, und Hinweise dazu, wie Sie das Problem beheben. Rust lässt Sie mit einem Fehler also nicht allein. Tatsächlich unternimmt das Sprach-Team von Rust große Anstrengungen, um die bestmöglichen Fehlermeldungen auszugeben.

3.2.3    Eine Variable mit dem Schlüsselwort »mut« veränderlich machen

Viele Programmiersprachen erlauben es Ihnen, eine Variable ohne Weiteres nach der Initialisierung zu ändern. In Rust müssen Sie dagegen bereits bei der Deklaration das Schlüsselwort mut einsetzen. Erst dann dürfen Sie eine Variable überschreiben. Rust-Variablen sind nach der Deklaration standardmäßig als unveränderlich eingefroren (engl. frozen), während Sie diesen Effekt etwa in C++ mit dem Schlüsselwort const erst aktiv herbeiführen müssen.

Sollten Sie die Unveränderlichkeit verletzen, weist der Compiler Sie umgehend darauf hin. Ein Beispiel:

fn main() {
let alter: i8 = 42;

// Fehler
alter = 21;
}

Listing 3.3     Die Variable ist vor der erneuten Zuweisung geschützt.

Der Compiler meldet, dass alter schon bei der Einführung einen Wert erhalten hat. Nachträglich dürfen Sie die Variable demnach nicht verändern:

error[E0384]: cannot assign twice to immutable variable `alter`
--> src/main.rs
|
2 | let alter: i8 = 42;
| -----
| |
| first assignment to `alter`
| help: consider making this binding mutable: `mut alter`
4 |...

Produkt-Details

• Erscheint lt. Verlag: 6.6.2024
• Sprache: deutsch
• Themenwelt: Mathematik / Informatik ► Informatik ► Programmiersprachen / -werkzeuge
• ISBN-10: 3-8362-9020-0 / 3836290200
• ISBN-13: 978-3-8362-9020-3 / 9783836290203