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.
Lassen Sie uns beginnen!
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. Die Durchschnittsgehalt eines Rust-Programmierers beträgt etwa 120 $.
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 StackOverflow-Entwicklerumfragewurde Rust zur beliebtesten Programmiersprache gewählt – sieben Jahre in Folge.
Rost bietet die Geschwindigkeit von Low-Level-Systemprogrammiersprachen wie C und C++ und der Sicherheit von höheren Programmiersprachen wie Python.
Von bemerkenswerten Projekten wie Dropbox und Firefox bis hin zu WebAssembly und eingebetteter Programmierung ist Rust in allen Bereichen von weit verbreitet Software-Entwicklung. Rust bietet über Cargo eine sofort einsatzbereite Paketverwaltungsunterstützung.
Cargo: Der Paketmanager für Rust
Kastenwagen ist der Paketmanager für Rust. Sie können Cargo verwenden, um Pakete von zu installieren Kisten, die Rust-Paketregistrierung. 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.
Helpful Error Messages
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 die Variable num2 ist innerhalb der Funktion definiert inner(). 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 ist die Variable num2 wird 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`
|Strongly Typed Language
Ein weiterer Grund, warum Sie Rust für Ihre Entwicklungsprojekte verwenden sollten, ist dessen Typ System. Rost ist ein stark typisierte Sprache, was bedeutet, dass Typzwang nicht unterstützt wird. 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. Das liegt daran, dass in Python, eine Zahl ungleich Null hat einen Wahrheitswert von True, und daher wird die if-Anweisung ohne Fehler ausgeführt – obwohl die Zahl 10 eine ganze Zahl ist – und kein boolescher Wert.
num1 = 10
if num1:
num2 = 9
print(f"num2 is {num2}")
# Output: num2 is 9Andererseits 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 integerMemory Safety
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 alle Variablen sollen initialisiert werden, bevor sie verwendet werden können. In Sprachen wie C ist der folgende Code wo num nicht initialisiert wird 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 0Wenn Sie versuchen, etwas Ähnliches in Rust zu tun, werden Sie auf einen Kompilierungsfehler stoßen. Rost hat daher keine Vorstellung der Müllabfuhr.
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. Hier, obwohl die bedingte if-Anweisung einen booleschen Wert von hat true, was den Wert von bedeutet num immer 100 sein wird, erhalten wir eine Fehlermeldung, wenn wir versuchen, den Wert von auszudrucken num.
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 dies nicht garantieren kann num hat zur Kompilierzeit einen Wert.
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-uninitializedWenn Sie sich die Fehlermeldung genauer ansehen, sehen Sie das mit einer else-Anweisung, das können wir sicherstellen num wird einen Wert haben. Der folgende Code wird also ohne Fehler ausgeführt. Denn auf diese Weise kann der Compiler das feststellen num wird einen Wert haben – zur Kompilierzeit – also gibt es keine Fehler.
fn main() {
let num:i32;
if true{
num = 100;
}
else{
num = 50;
}
println!("The value of num is: {}", num);
}The value of num is: 100Unverä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);
}As num1 auf 10 initialisiert wird, wenn Sie versuchen, ihm einen Wert von 5 zuzuweisen, erhalten Sie eine Fehlermeldung, die besagt, dass unveränderliche Variable nicht zweimal zugewiesen werden kann num1'.
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 variableOwnership and Borrowing
Der Besitz gewährleistet die Speichersicherheit. Funktional lässt sich das Eigentum an Rust wie folgt zusammenfassen:
Jedes Objekt sollte haben der eine und einzige Inhaber. 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 Sie dann seinen Wert auf str2. Da jedes Objekt nur einen Besitzer haben kann, ist die str1 Objekt wird gelöscht, sobald sein Wert verschoben wird str2.
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 moveObwohl dies intuitiv erscheint, ist es hilfreich, die Konzepte von zu lernen, um besser zu verstehen und zu schätzen, wie Eigentümerschaft funktioniert Ausleihe und Referenzen.
Quick Development
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.
Cross-Platform Development
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.
Supportive Community
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
Rost am Beispiel wird Ihnen die Grundlagen und Standardbibliotheken von Rust anhand einer Reihe von Beispielen beibringen, die Sie in einem Online-Editor mitcodieren können.
Die behandelten Themen umfassen Kisten, Fracht: das Paketverwaltungstool für Rust, Generika, Traits, Fehlerbehandlung und vieles mehr.
# 2. Rascheln
Rascheln 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
Dieses Rust Track auf Übung verfügt über mehr als 100 Übungen, die Ihnen helfen, Ihr Verständnis von Rust zu erlernen und zu testen. 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
Dieses Ultimativer Rost-Crashkurs unterrichtet von Nathan Stocks auf Udemy umfasst Folgendes:
- Grundlagen der Rust-Programmierung
- Modulsystem in Rust
- Datentypen und Kontrollfluss
- Referenz und Ausleihe
- Strukturen, Merkmale und Sammlungen
# 5. Ultimate Rust 2: Zwischenkonzepte
Ultimativer Rost 2 ist ein Folgekurs zum Ultimate Rust Crash Course und behandelt folgende Themen:
- Verschlüsse
- Iteratoren
- Fehlerbehandlung
- Unit- und Integrationstest
- Protokollierung, Multithreading und Kanäle
# 6. Rust lang: Der komplette Einsteiger-Guide 2023
Diese Udemy natürlich unterrichtet von Catalin Stefan ist ein umfassender Kurs zur Rust-Programmierung. Einige der behandelten Themen umfassen:
- Rost Grundlagen
- Datentypen, Kontrollstrukturen
- Funktionen, Eigenschaften
- Speicherverwaltung
- Nebenläufigkeit
# 7. Programmierung von Rust: Schnelle, sichere Systementwicklung
| Vorschau | Produkt | Rating | Preis | |
|---|---|---|---|---|
|
Programmierung von Rust: Schnelle, sichere Systementwicklung | $ 38.49 | Bei Amazon kaufen |
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
- Kollektionen
# 8. Die Programmiersprache Rust, 2. Auflage
| Vorschau | Produkt | Rating | Preis | |
|---|---|---|---|---|
|
Die Programmiersprache Rust, 2. Auflage | $ 39.49 | Bei Amazon kaufen |
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
| Vorschau | Produkt | Rating | Preis | |
|---|---|---|---|---|
|
Das vollständige Referenzhandbuch für die Rust-Programmierung: Effektive Software entwerfen, entwickeln und bereitstellen… | $ 49.99 | Bei Amazon kaufen |
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
| Vorschau | Produkt | Rating | Preis | |
|---|---|---|---|---|
|
Kreative Projekte für Rust-Programmierer: Bauen Sie spannende Projekte auf Domänen wie Web-Apps,… | $ 44.99 | Bei Amazon kaufen |
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 erkunden Rust Server Hosting Anbieter.
