Möchten Sie als Entwickler die Programmiersprache Rust erkunden? Dieser Artikel bietet Ihnen einen Einblick in die Besonderheiten von Rust, einer bevorzugten Sprache für die Systemprogrammierung, um Ihnen bei Ihrer Entscheidung zu helfen.
In diesem Beitrag beleuchten wir Rust und seine charakteristischen Eigenschaften wie das Typsystem, die Speichersicherheit und das Konzept des Eigentums. Zudem stellen wir Ihnen eine Auswahl an Lernmaterialien vor, die Ihren Einstieg in Rust erleichtern sollen.
Legen wir los!
Was ist Rust?
Rust ist eine Systemprogrammiersprache, deren Ursprung im Jahr 2006 in einem persönlichen Projekt von Graydon Hoare liegt. Innerhalb eines Jahrzehnts hat sie sich als erste Wahl für die Systemprogrammierung und verwandte Anwendungsbereiche etabliert. Ein Rust-Programmierer erzielt durchschnittlich ein Jahreseinkommen von etwa 120.000 US-Dollar.
Ob Sie von C++ wechseln oder eine neue Sprache lernen möchten, Rust könnte eine exzellente Option sein. Die StackOverflow-Entwicklerumfrage hat Rust sieben Jahre in Folge zur beliebtesten Programmiersprache gekürt.
Bildquelle: StackOverflow
Rust kombiniert die Geschwindigkeit von Low-Level-Systemsprachen wie C und C++ mit der Sicherheit von High-Level-Sprachen wie Python.
Rust findet in einer Vielzahl von Projekten Anwendung, von renommierten Beispielen wie Dropbox und Firefox bis hin zu WebAssembly und eingebetteter Programmierung. Rust bietet über Cargo eine unkomplizierte Paketverwaltung.
Cargo: Der Paketmanager für Rust
Cargo ist der Standard-Paketmanager für Rust. Mit Cargo können Sie Pakete aus Crates, der Paketregistrierung für Rust, installieren. Neben der Installation und Verwaltung von Paketen dient Cargo auch als Test-Runner, Dokumentationsgenerator und Build-System.
Nach diesem Überblick über Rust werfen wir nun einen genaueren Blick auf einige Features, die es zu einer beliebten Wahl für die Systemprogrammierung machen.
Detaillierte Fehlermeldungen
Als Anfänger in der Programmierung werden Sie unweigerlich auf Fehler stoßen und Zeit mit dem Debuggen verbringen. Hierbei sind Fehlermeldungen und Warnungen des Compilers von großer Bedeutung. Präzise Meldungen können Ihren Debugging-Prozess erheblich beschleunigen.
Ein Beispiel für eine Fehlermeldung
Wenn Ihr Code nicht kompiliert, liefert Rust aussagekräftige Fehlermeldungen, die aufzeigen, welche Korrekturen erforderlich sind und wo diese im Code anzusetzen sind.
In diesem Beispiel wird die Variable `num2` innerhalb der Funktion `inner()` definiert und ist daher auf diesen Gültigkeitsbereich beschränkt. Ein Zugriff außerhalb dieser Funktion führt zu einer Fehlermeldung des Compilers:
fn main() {
let num1 = 10;
fn inner(){
let num2 = 9;
}
println!("Der Wert von num2 ist: {}", num2);
}
Die Fehlermeldung zeigt an, welche Korrekturen notwendig sind.
error(E0425): cannot find value `num2` in this scope
--> src/main.rs:6:42
|
6 | println!("Der Wert von num2 ist: {}", num2);
| ^^^^ Hilfe: Eine lokale Variable mit ähnlichem Namen existiert: `num1`
Warnungen während der Kompilierung
Der Compiler gibt auch nützliche Warnungen zu potenziellen Problemen in Ihrem Code aus. Wenn Sie Variablen deklarieren, diese aber nicht weiter verwenden, gibt Rust eine entsprechende Warnmeldung aus, wie das folgende Beispiel verdeutlicht.
fn main() {
let num1 = 10;
let num2 = 9;
println!("Der Wert von num1 ist: {}", num1);
}
Hier wird die Variable `num2` deklariert, aber nicht verwendet.
warning: unbenutzte Variable: `num2` --> src/main.rs:3:9 | 3 | let num2 = 9; | ^^^^ Hilfe: Wenn dies beabsichtigt ist, fügen Sie ein Unterstrich als Präfix hinzu: `_num2` |
Stark typisierte Sprache
Ein weiteres Argument für Rust ist sein Typsystem. Rust ist stark typisiert, was bedeutet, dass Typumwandlungen nicht automatisch erfolgen. Typumwandlung bezeichnet, wenn eine Sprache implizit einen Wert eines Datentyps in einen anderen umwandelt.
Beispielsweise wird der folgende Python-Code fehlerfrei ausgeführt. Python interpretiert jede Zahl ungleich Null als `True`, wodurch die if-Bedingung ausgeführt wird, auch wenn die Zahl `10` eine Ganzzahl und kein boolescher Wert ist.
num1 = 10
if num1:
num2 = 9
print(f"num2 ist {num2}")
# Ausgabe: num2 ist 9
Rust hingegen erzwingt strikt die Verwendung korrekter Datentypen. Der folgende Code führt daher zu einem Fehler:
fn main() {
let num1 = 10;
if num1{
let num2 = 9;
}
}
Der Fehler signalisiert einen Typkonflikt, bei dem ein boolescher Wert erwartet wurde, aber eine Ganzzahl gefunden wurde.
error(E0308): Typen stimmen nicht überein
--> src/main.rs:3:8
|
3 | if num1{
| ^^^^ Erwartet `bool`, aber gefunden Integer
Speichersicherheit
Die Speichersicherheit ist ein weiteres hervorstechendes Merkmal von Rust. Wir versuchen, Ihnen einen kurzen Überblick über die Funktionsweise zu geben.
Variablen müssen initialisiert werden
In Rust müssen alle Variablen initialisiert sein, bevor sie verwendet werden können. In Sprachen wie C würde folgender Code, in dem `num` nicht initialisiert ist, kompiliert und ausgeführt werden, wobei `num` einen zufälligen Wert enthält.
#include <stdio.h>
int main(void) {
int num;
printf("Der Wert von num ist %d", num);
return 0;
}
// Ausgabe: Der Wert von num ist 0
In Rust wird dieser Code zu einem Kompilierungsfehler führen. Rust verwendet keine Garbage Collection.
fn main() {
let num:i32;
println!("Der Wert von num ist: {}",num);
}
error(E0381): Der verwendete Bezeichner `num` ist nicht initialisiert
--> src/main.rs:3:40
|
2 | let num:i32;
| --- Bezeichner hier deklariert, aber nicht initialisiert
3 | println!("Der Wert von num ist: {}",num);
| ^^^ `num` wird hier verwendet, ist aber nicht initialisiert
|
Speichersicherheit zur Kompilierzeit
Rust gewährleistet Speichersicherheit während der Kompilierzeit. Ein einfaches Beispiel: Trotz der `if`-Bedingung, die immer `true` ist, was bedeutet, dass `num` immer den Wert `100` hat, wird ein Fehler ausgegeben, wenn wir den Wert von `num` ausgeben wollen.
fn main() {
let num:i32;
if true{
num = 100;
}
println!("Der Wert von num ist: {}", num);
}
Dies liegt daran, dass die bedingte Auswertung zur Laufzeit erfolgt und der Compiler nicht sicherstellen kann, dass `num` zur Kompilierzeit einen Wert hat.
error(E0381): Der verwendete Bezeichner `num` ist möglicherweise nicht initialisiert
--> src/main.rs:6:41
|
2 | let num:i32;
| --- Bezeichner hier deklariert, aber nicht initialisiert
3 | if true{
| ---- Wenn diese `if`-Bedingung `false` ist, wird `num` nicht initialisiert
4 | num = 100;
5 | }
| - Ein `else`-Zweig könnte hier fehlen, um `num` zu initialisieren
6 | println!("Der Wert von num ist: {}", num);
| ^^^ `num` wird hier verwendet, ist aber möglicherweise nicht initialisiert
Die Fehlermeldung zeigt, dass wir mit einem `else`-Zweig sicherstellen können, dass `num` immer einen Wert hat. Der folgende Code funktioniert fehlerfrei, da der Compiler dann garantieren kann, dass `num` zur Kompilierzeit ein Wert zugewiesen bekommt.
fn main() {
let num:i32;
if true{
num = 100;
}
else{
num = 50;
}
println!("Der Wert von num ist: {}", num);
}
Der Wert von num ist: 100
Unveränderbarkeit von Variablen
In Rust sind Variablen standardmäßig unveränderlich. Dies verhindert, dass der Wert einer Variablen versehentlich geändert wird. Ein Beispiel:
fn main() {
let num1 = 10;
num1 = 5;
println!("Der Wert von num1 ist: {}", num1);
}
Da `num1` mit `10` initialisiert wurde, wird beim Versuch, ihr den Wert `5` zuzuweisen, ein Fehler ausgegeben, der besagt, dass „der unveränderlichen Variable `num1` nicht zweimal zugewiesen werden kann“.
error(E0384): Der unveränderlichen Variable `num1` kann nicht zweimal zugewiesen werden --> src/main.rs:3:5 | 2 | let num1 = 10; | ---- | | | Erste Zuweisung zu `num1` | Hilfe: Erwägen Sie, den Bezeichner veränderlich zu machen: `mut num1` 3 | num1 = 5; | ^^^^^^^^ kann der unveränderlichen Variable nicht zweimal zugewiesen werden
Eigentümerschaft und Ausleihe
Das Eigentümerschaftssystem von Rust ist ein Schlüssel zur Speichersicherheit. Es lässt sich wie folgt zusammenfassen:
Jedes Objekt hat einen und nur einen Eigentümer. Wenn der Eigentümer den Gültigkeitsbereich verlässt, wird das Objekt freigegeben.
Hier ist ein einfaches Beispiel: Wir initialisieren einen String `str1` und verschieben seinen Wert nach `str2`. Da jedes Objekt nur einen Eigentümer haben kann, wird `str1` freigegeben, sobald sein Wert nach `str2` verschoben wurde.
fn main() {
let str1 = String::from("Rust");
let str2 = str1;
println!("Der Wert von str1 ist: {}", str1);
}
error(E0382): Ausleihe eines verschobenen Werts: `str1`
--> src/main.rs:4:42
|
2 | let str1 = String::from("Rust");
| ---- Die Verschiebung tritt auf, weil `str1` vom Typ `String` ist, welcher das `Copy` Trait nicht implementiert
3 | let str2 = str1;
| ---- Der Wert wurde hier verschoben
4 | println!("Der Wert von str1 ist: {}", str1);
| ^^^^ Der Wert wird hier nach der Verschiebung ausgeliehen
Dies mag nicht intuitiv erscheinen, es ist jedoch hilfreich, die Konzepte der Ausleihe und Referenzen zu verstehen, um die Funktionsweise von Eigentümerschaft vollständig zu begreifen.
Schnelle Entwicklung
Wir haben einige nützliche Features von Rust besprochen, darunter:
- Rust ist auf Geschwindigkeit und Sicherheit optimiert.
- Es kommt mit einem integrierten Paketmanager und einem Build-System.
- Es bietet eine umfangreiche Standardbibliothek.
Kurz gesagt, Rust bietet alles, was ein Entwickler benötigen könnte. Dadurch können Sie Anwendungen schnell mit minimalem Debugging und schnelleren Builds entwickeln.
Plattformübergreifende Entwicklung
Rust bietet Ihnen die Flexibilität, auf der Plattform Ihrer Wahl zu entwickeln. Rust unterstützt die gängigen Betriebssysteme: Linux, MacOS und Windows.
Die Anwendungsentwicklung ist unkompliziert, da Sie Rust-Quellcode in ausführbare Dateien kompilieren können, ohne auf zusätzliche Build-Tools oder externe Compiler angewiesen zu sein.
Aktive Community
Eine unterstützende Community ist für den Lernerfolg unerlässlich. Rust hat eine wachsende Benutzerbasis.
Die Beliebtheit von Rust in der StackOverflow-Entwicklerumfrage zeigt, dass es eine große Community mit vielen erfahrenen Entwicklern gibt, die ihr Wissen und ihre Expertise teilen.
Neben der offiziellen Dokumentation gibt es eine benutzergenerierte Dokumentationsseite und ein Diskussionsforum. Sie können auch in Rust-Subreddits und LinkedIn-Gruppen nach relevanten Diskussionen suchen.
Lernressourcen für den Einstieg in Rust
Dieser Abschnitt enthält eine Auswahl an hilfreichen Ressourcen, die Ihnen den Einstieg in Rust erleichtern. Die Liste ist nicht vollständig, aber sie beinhaltet einige empfehlenswerte Tutorials, Kurse und Bücher, die Sie auf Ihrer Lernreise unterstützen können.
#1. Rust nach Beispiel
Rust nach Beispiel bietet eine Einführung in Rust und seine Standardbibliotheken anhand von Beispielen, die Sie direkt in einem Online-Editor bearbeiten können.
Themen wie Crates, Cargo (der Paketmanager), Generics, Traits und Fehlerbehandlung werden behandelt.
#2. Rustlings
Rustlings ist eine weitere offizielle Lernressource. Ähnlich wie Rust nach Beispiel erfordert es das Einrichten einer lokalen Entwicklungsumgebung, das Klonen eines Beispiel-Repositorys und das Lösen von Aufgaben, um Konzepte zu erlernen.
#3. Exercism Rust Track
Der Exercism Rust Track bietet über 100 Übungen, um Ihr Verständnis von Rust zu verbessern. Exercism ist eine kostenlose Plattform, auf der Sie von erfahrenen Programmierern angeleitet werden und die Aufgaben durcharbeiten können.
#4. Ultimativer Rust-Crashkurs
Der Ultimate Rust Crash Course auf Udemy, geleitet von Nathan Stocks, behandelt:
- Grundlagen der Rust-Programmierung
- Modulsystem in Rust
- Datentypen und Kontrollstrukturen
- Referenzen und Ausleihe
- Strukturen, Traits und Sammlungen
#5. Ultimate Rust 2: Fortgeschrittene Konzepte
Ultimate Rust 2 ist eine Fortsetzung des Ultimate Rust Crash Course und behandelt Themen wie:
- Closures
- Iteratoren
- Fehlerbehandlung
- Unit- und Integrationstests
- Logging, Multithreading und Kanäle
#6. Rust lang: Der komplette Einsteiger-Guide 2023
Dieser von Catalin Stefan geleitete Udemy-Kurs ist ein umfassender Leitfaden zur Rust-Programmierung und deckt Themen ab wie:
- Rust-Grundlagen
- Datentypen, Kontrollstrukturen
- Funktionen, Eigenschaften
- Speicherverwaltung
- Parallele Programmierung
#7. Programmieren mit Rust: Schnelle, sichere Systementwicklung
Programmieren mit Rust von O’Reilly ist ein beliebtes Buch, das Folgendes vermittelt:
- Grundlegende Datentypen
- Eigentümerschaft und Ausleihe
- Asynchrone Programmierung
- Schnelle Multithread-Anwendungen
- Closures, Iteratoren
- Sammlungen
#8. Die Programmiersprache Rust, 2. Auflage
Das Buch Die Programmiersprache Rust wurde von renommierten Mitgliedern der Rust-Community verfasst und behandelt alles Wissenswerte über Rust, darunter:
- Eigentümerschaft und Ausleihe
- Generics, Traits
- Intelligente Zeiger, Multithreading
- Testen und Fehlerbehandlung
#9. Das vollständige Rust-Programmier-Referenzhandbuch
Das Complete Rust Programming Reference Guide von Packt behandelt:
- Implementierung von Datenstrukturen in Rust
- Erstellung wiederverwendbarer und testbarer Komponenten
- Entwurf von Multithread-Anwendungen, Algorithmusdesign
- Anwendungen von Rust in WebAssembly-, Netzwerk- und Befehlszeilenanwendungen
#10. Kreative Projekte für Rust-Programmierer
Für erfahrene Entwickler kann das Erstellen von Projekten hilfreich sein, um die Sprache zu meistern. Creative Projects for Rust Programmers von Packt lehrt Rust anhand von Projekten wie:
- Erstellen von RESTful-Webdiensten
- 2D-Spiele mit
- Entwicklung von Webanwendungen mit WebAssembly
- Emulatoren für Maschinensprache
- und mehr!
Fazit
Dieser Artikel bot einen Einblick in die Systemprogrammiersprache Rust und ihre Besonderheiten wie Speichersicherheit, verbesserte Paketverwaltung und vieles mehr. Wir haben zudem einige Ressourcen für Ihren Einstieg in Rust vorgestellt.
Als Nächstes können Sie eine oder mehrere der genannten Lernressourcen auswählen, um die Grundlagen von Rust zu erlernen. Viel Spaß beim Programmieren mit Rust!
Sie können auch einige der besten Hosting-Anbieter für Rust-Server erkunden.