Sind Sie ein Entwickler, der Rust kennenlernen möchte? Um Ihnen bei der Entscheidung zu helfen, stellt dieser Artikel einige der Funktionen von Rust vor, einer der beliebtesten Programmiersprachen für Systeme.
In diesem Artikel werden wir die Programmiersprache Rust und ihre Funktionen wie Typsystem, Speichersicherheit und Eigentümerschaft untersuchen. Wir werden auch eine Liste von Ressourcen durchgehen, die Ihnen helfen können, Rust zu lernen.
Lass uns anfangen!
Inhaltsverzeichnis
Was ist Rost?
Rust ist eine Systemprogrammiersprache. Es begann als persönliches Projekt von Graydon Hoare, einem Entwickler, im Jahr 2006. In weniger als einem Jahrzehnt hat es sich zur ersten Wahl für Systemprogrammierung und verwandte Anwendungen entwickelt. Das durchschnittliche Gehalt eines Rust-Programmierers beträgt etwa 120.000 $.
Wenn Sie also von C++ zu Rust wechseln oder eine neue Sprache lernen möchten, kann das Erlernen von Rust eine gute Wahl sein! Laut der StackOverflow-Entwicklerumfrage wurde Rust zur beliebtesten Programmiersprache gewählt – und das sieben Jahre in Folge.
Bildquelle: StackOverflow
Rust bietet die Geschwindigkeit von Low-Level-Systemprogrammiersprachen wie C und C++ und die Sicherheit von High-Level-Programmiersprachen wie Python.
Von bemerkenswerten Projekten wie Dropbox und Firefox bis hin zu WebAssembly und eingebetteter Programmierung ist Rust in allen Bereichen der Softwareentwicklung weit verbreitet. Rust bietet über Cargo eine sofort einsatzbereite Paketverwaltungsunterstützung.
Cargo: Der Paketmanager für Rust
Cargo ist der Paketmanager für Rust. Sie können Cargo verwenden, um Pakete aus Crates, der Rust-Paketregistrierung, zu installieren. Cargo ist nicht nur ein Paketmanager, mit dem Sie Pakete suchen, installieren und verwalten können, sondern dient auch als Test-Runner, Dokumentgenerator und Build-System.
Nachdem Sie sich nun einen Überblick über Rust verschafft haben, werfen wir einen genaueren Blick auf einige der Features von Rust, die es zu einer weit verbreiteten Systemprogrammiersprache machen.
Hilfreiche Fehlermeldungen
Als Programmieranfänger werden Sie auf Fehler stoßen und viel Zeit damit verbringen, Ihren Code zu debuggen. Sie verwenden die vom Compiler bereitgestellten Fehlermeldungen und Warnungen, um diese Probleme zu beheben. Und hilfreiche Meldungen können Ihnen dabei helfen, schneller zu debuggen.
Eine Beispiel-Fehlermeldung
Wenn Ihr Code nicht erfolgreich kompiliert wird, liefert Rust hilfreiche Fehlermeldungen, die erklären, was in Ihrem Code behoben werden muss und wo.
In diesem Beispiel wird die Variable num2 innerhalb der Funktion inner() definiert. Sie ist daher auf den Funktionsumfang beschränkt. Wenn Sie versuchen, außerhalb der Funktion darauf zuzugreifen, gibt der Compiler einen Fehler aus:
fn main() {
let num1 = 10;
fn inner(){
let num2 = 9;
}
println!("The value of num2 is: {}", num2);
}
Und die Fehlermeldung gibt Auskunft darüber, was behoben werden muss.
error(E0425): cannot find value `num2` in this scope
--> src/main.rs:6:42
|
6 | println!("The value of num2 is: {}", num2);
| ^^^^ help: a local variable with a similar name exists: `num1`
Warnungen während der Kompilierung
Der Compiler bietet auch hilfreiche Warnungen zu Problemen in Ihrem Code. Wenn Sie Variablen definieren, aber nie im Rest des Programms verwenden, gibt Rust Ihnen eine Warnmeldung aus, wie gezeigt.
fn main() {
let num1 = 10;
let num2 = 9;
println!("The value of num1 is: {}", num1);
}
Hier wird die Variable num2 deklariert, aber nie verwendet.
warning: unused variable: `num2` --> src/main.rs:3:9 | 3 | let num2 = 9; | ^^^^ help: if this is intentional, prefix it with an underscore: `_num2` |
Stark typisierte Sprache
Ein weiterer Grund, warum Sie Rust für Ihre Entwicklungsprojekte verwenden sollten, ist das Typsystem. Rust ist eine stark typisierte Sprache, was bedeutet, dass sie Typzwang nicht unterstützt. Typumwandlung liegt vor, wenn eine Sprache einen Wert in einem Datentyp implizit in einen anderen umwandeln kann.
Beispielsweise wird der Python-Code in der folgenden Codezelle ohne Fehler ausgeführt. Dies liegt daran, dass in Python eine Zahl ungleich Null den Wahrheitswert True hat und daher die if-Anweisung fehlerfrei ausgeführt wird – obwohl die Zahl 10 eine Ganzzahl und kein boolescher Wert ist.
num1 = 10
if num1:
num2 = 9
print(f"num2 is {num2}")
# Output: num2 is 9
Andererseits erzwingt Rust keine Typen. Der folgende Code löst also einen Fehler aus:
fn main() {
let num1 = 10;
if num1{
let num2 = 9;
}
}
Der Fehler meldet einen Typenkonflikt, bei dem ein boolescher Wert erwartet und eine ganze Zahl gefunden wurde.
error(E0308): mismatched types
--> src/main.rs:3:8
|
3 | if num1{
| ^^^^ expected `bool`, found integer
Speichersicherheit
Speichersicherheit ist ein weiteres Merkmal von Rust, das es für Programmierer attraktiv macht. Wir werden versuchen, einen flüchtigen Überblick darüber zu geben, wie dies funktioniert.
Variablen müssen initialisiert werden, bevor sie verwendet werden
In Rust müssen alle Variablen initialisiert werden, bevor sie verwendet werden können. In Sprachen wie C wird der folgende Code, in dem num nicht initialisiert ist, kompiliert und ohne Fehler ausgeführt. Der Wert der nicht initialisierten Variablen ist irgendein Garbage-Wert.
#include <stdio.h>
int main(void) {
int num;
printf("The value of num is %d", num);
return 0;
}
// Output: The value of num is 0
Wenn Sie versuchen, etwas Ähnliches in Rust zu tun, werden Sie auf einen Kompilierungsfehler stoßen. Rust hat daher keine Ahnung von Garbage Collection.
fn main() {
let num:i32;
println!("The value of num is: {}",num);
}
error(E0381): used binding `num` isn't initialized
--> src/main.rs:3:40
|
2 | let num:i32;
| --- binding declared here but left uninitialized
3 | println!("The value of num is: {}",num);
| ^^^ `num` used here but it isn't initialized
|
Speichersicherheit zur Kompilierzeit
Rust gewährleistet Speichersicherheit zur Kompilierzeit. Nehmen wir ein einfaches Beispiel. Obwohl die Bedingung if den booleschen Wert wahr hat, was bedeutet, dass der Wert von num immer 100 ist, erhalten wir hier eine Fehlermeldung, wenn wir versuchen, den Wert von num auszugeben.
fn main() {
let num:i32;
if true{
num = 100;
}
println!("The value of num is: {}", num);
}
Dies liegt daran, dass die bedingte Auswertung zur Laufzeit erfolgt und der Compiler nicht garantieren kann, dass num zur Kompilierzeit einen Wert hat.
error(E0381): used binding `num` is possibly-uninitialized
--> src/main.rs:6:41
|
2 | let num:i32;
| --- binding declared here but left uninitialized
3 | if true{
| ---- if this `if` condition is `false`, `num` is not initialized
4 | num = 100;
5 | }
| - an `else` arm might be missing here, initializing `num`
6 | println!("The value of num is: {}", num);
| ^^^ `num` used here but it is possibly-uninitialized
Wenn Sie sich die Fehlermeldung genauer ansehen, sehen Sie, dass wir mit einer else-Anweisung sicherstellen können, dass num einen Wert hat. Der folgende Code wird also ohne Fehler ausgeführt. Denn auf diese Weise kann der Compiler feststellen, dass num zur Kompilierzeit einen Wert haben wird, sodass keine Fehler auftreten.
fn main() {
let num:i32;
if true{
num = 100;
}
else{
num = 50;
}
println!("The value of num is: {}", num);
}
The value of num is: 100
Unveränderlichkeit von Variablen
Es ist auch hilfreich zu beachten, dass Variablen in Rust standardmäßig unveränderlich sind. Das bedeutet, dass Sie als Entwickler keine Angst haben müssen, versehentlich den Wert einer bestimmten Variablen zu überschreiben. Hier ist ein Beispiel:
fn main() {
let num1 = 10;
num1 = 5;
println!("The value of num1 is: {}", num1);
}
Da num1 auf 10 initialisiert wird, erhalten Sie beim Versuch, ihm einen Wert von 5 zuzuweisen, eine Fehlermeldung, die besagt, dass „unveränderliche Variable num1 nicht zweimal zugewiesen werden kann“.
error(E0384): cannot assign twice to immutable variable `num1` --> src/main.rs:3:5 | 2 | let num1 = 10; | ---- | | | first assignment to `num1` | help: consider making this binding mutable: `mut num1` 3 | num1 = 5; | ^^^^^^^^ cannot assign twice to immutable variable
Eigentum und Kreditaufnahme
Der Besitz gewährleistet die Speichersicherheit. Funktional lässt sich das Eigentum an Rust wie folgt zusammenfassen:
Jedes Objekt sollte einen und nur einen Eigentümer haben. Wenn der Eigentümer den Gültigkeitsbereich verlässt, wird das Objekt gelöscht.
Nehmen wir ein einfaches Beispiel. Hier initialisieren wir einen String str1 und verschieben dann seinen Wert nach str2. Da jedes Objekt nur einen Eigentümer haben kann, wird das str1-Objekt gelöscht, sobald sein Wert nach str2 verschoben wird.
fn main() {
let str1 = String::from("Rust");
let str2 = str1;
println!("The value of str1 is: {}", str1);
}
error(E0382): borrow of moved value: `str1`
--> src/main.rs:4:42
|
2 | let str1 = String::from("Rust");
| ---- move occurs because `str1` has type `String`, which does not implement the `Copy` trait
3 | let str2 = str1;
| ---- value moved here
4 | println!("The value of str1 is: {}", str1);
| ^^^^ value borrowed here after move
Obwohl dies intuitiv erscheint, ist es hilfreich, die Konzepte der Ausleihe und Referenzen zu lernen, um besser zu verstehen und zu schätzen, wie Eigentum funktioniert.
Schnelle Entwicklung
Bisher haben wir einige nützliche Funktionen der Programmiersprache Rust besprochen. Um einige zu überprüfen:
- Rust ist sowohl auf Geschwindigkeit als auch auf Sicherheit optimiert.
- Es wird mit einem integrierten Paketverwaltungstool geliefert und baut ein System auf.
- Es hat auch eine umfangreiche Standardbibliothek.
Im Wesentlichen bietet Rust alles, was ein Entwickler sich wünschen kann. Daher können Sie mit Rust Anwendungen schnell mit minimalem Debugging und schnelleren Builds entwickeln.
Plattformübergreifende Entwicklung
Mit Rust können Sie sich entscheiden, auf einer Plattform Ihrer Wahl zu entwickeln. Rust unterstützt die gängigsten Plattformen: Linux, MacOS und Windows.
Die Anwendungsentwicklung ist im Allgemeinen einfach, da Sie den Rust-Quellcode in eine ausführbare Datei kompilieren können, ohne auf andere Build-Tools und externe Compiler angewiesen zu sein.
Eine unterstützende Community trägt wesentlich dazu bei, Ihre Lernreise zu vereinfachen. Rust hat eine riesige Benutzerbasis, die mit jedem Jahr wächst.
Die Popularität von Rust in der StackOverflow-Entwicklerumfrage zeigt, dass es eine große Community von Benutzern gibt, mit vielen erfahrenen Entwicklern, die bereit sind, ihr Wissen und ihre Expertise zu teilen.
Neben der offiziellen Dokumentation gibt es auch eine benutzergenerierte Dokumentationsseite und ein Diskussionsforum. Sie können auch im Rust-Subreddit und in den LinkedIn-Gruppen nach relevanten Diskussionen suchen.
Lernressourcen für den Einstieg in Rust
Dieser Abschnitt listet einige hilfreiche Ressourcen auf, die Ihnen bei den ersten Schritten mit Rust helfen. Dies ist keine vollständige Liste, enthält jedoch einige empfohlene Tutorials, Kurse und Bücher, die Sie bei Ihrer Lernreise unterstützen.
#1. Rost am Beispiel
Rust By Example vermittelt Ihnen anhand einer Reihe von Beispielen, die Sie in einem Online-Editor codieren können, die Grundlagen von Rust und Standardbibliotheken.
Die behandelten Themen umfassen Kisten, Fracht: das Paketverwaltungstool für Rust, Generika, Traits, Fehlerbehandlung und vieles mehr.
#2. Rascheln
Rustlings ist eine weitere offizielle Lernressource für die Programmiersprache Rust. Es ist zum Beispiel ähnlich wie Rust. Es erfordert jedoch, dass Sie Ihre lokale Entwicklungsumgebung einrichten, ein Beispiel-Repository klonen und einfache Probleme lösen, um diese Konzepte zu erlernen.
#3. Übung Rust Track
Der Rust Track on Exercise enthält mehr als 100 Übungen, mit denen Sie Ihr Rust-Verständnis erlernen und testen können. Exercism ist eine kostenlose Plattform, auf der Sie sich von erfahrenen Programmierern beraten lassen und sich durch die Übungen codieren lassen können.
#4. Ultimativer Rost-Crashkurs
Der Ultimate Rust Crash Course, der von Nathan Stocks auf Udemy unterrichtet wird, behandelt Folgendes:
- Grundlagen der Rust-Programmierung
- Modulsystem in Rust
- Datentypen und Kontrollfluss
- Referenz und Ausleihe
- Strukturen, Merkmale und Sammlungen
#5. Ultimate Rust 2: Zwischenkonzepte
Ultimate Rust 2 ist ein Folgekurs zum Ultimate Rust Crash Course und behandelt die folgenden Themen:
- Schließungen
- Iteratoren
- Fehlerbehandlung
- Unit- und Integrationstest
- Protokollierung, Multithreading und Kanäle
#6. Rust lang: Der komplette Einsteiger-Guide 2023
Dieser von Catalin Stefan geleitete Udemy-Kurs ist ein umfassender Kurs zur Rust-Programmierung. Einige der behandelten Themen umfassen:
- Rost Grundlagen
- Datentypen, Kontrollstrukturen
- Funktionen, Eigenschaften
- Speicherverwaltung
- Parallelität
#7. Programmieren von Rust: Schnelle, sichere Systementwicklung
Programmieren von Rust von O’Reilly ist ein beliebtes Rust-Programmierbuch, das Ihnen Folgendes beibringt:
- Grundlegende Datentypen
- Eigentum und Leihe
- Asynchrone Programmierung
- Schnelle Multithreading-Anwendungen
- Closures, Iteratoren
- Sammlungen
#8. Die Programmiersprache Rust, 2. Auflage
Die Rust-Programmiersprache wurde von renommierten Mitwirkenden der Rust-Community verfasst. Dieses Buch behandelt alles, was Sie über Rust wissen müssen, einschließlich:
- Eigentum und Leihe
- Generika, Merkmale
- Intelligente Zeiger, Multithreading
- Testen und Fehlerbehandlung
#9. Das vollständige Programmierreferenzhandbuch für Rust
Das Complete Rust Programming Reference Guide von Packt deckt Folgendes ab:
- Implementieren von Datenstrukturen in Rust
- Wiederverwendbare und testbare Komponenten in Rust schreiben
- Entwerfen von Multithread-Anwendungen, Algorithmusdesign und
- Anwendungen von Rust in WebAssembly-, Netzwerk- und Befehlszeilenanwendungen
#10. Kreative Projekte für Rust-Programmierer
Wenn Sie ein erfahrener Entwickler sind, der Rust lernt, reicht es aus, ein paar Projekte in Ihrem Interessengebiet zu erstellen, um ein gutes Verständnis der Sprache zu erlangen. Creative Projects for Rust Programmers von Packt ist ein Buch, das Rust lehrt, indem es sie auf Projekte anwendet, wie zum Beispiel:
- Erstellen von Restful-Webdiensten
- 2D-Spiele mit
- Entwicklung von Webanwendungen mit WebAssembly
- Emulatoren für Maschinensprache
- und mehr!
Fazit
Dieser Artikel gab einen Überblick über Rust als Systemprogrammiersprache, einschließlich Funktionen wie Speichersicherheit, verbesserte Paketverwaltung und mehr. Wir haben auch Lernressourcen aufgelistet, die Ihnen helfen sollen, mit Rust loszulegen.
Als nächsten Schritt können Sie eine oder mehrere der genannten Lernressourcen auswählen, um sich die Grundlagen von Rust anzueignen. Viel Spaß beim Rust-Programmieren!
Sie können auch einige der besten Hosting-Anbieter für Rust-Server erkunden.