Alles, was Sie wissen müssen, um mit dem Schreiben von Rust zu beginnen

Seit seiner Veröffentlichung im Jahr 2015 hat Rust als eine der beliebtesten Programmiersprachen von Entwicklern an Popularität gewonnen. Rust bietet hervorragende Leistungs- und Sicherheitsfunktionen mit intuitiver und prägnanter Syntax, die die Sprache begehrenswert machen.

Rust eignet sich zum Erstellen verschiedener Programme, darunter Web-Apps, Befehlszeilentools und Netzwerkdienste. Rust enthält viele Funktionen, die Sie von einer modernen Programmiersprache erwarten, wie Parallelität, Typinferenz und mehr.

Erste Schritte mit Rust

Rust ist eine plattformübergreifende Programmiersprache, die auf den meisten Betriebssystemen läuft. Um mit Rust zu beginnen, gehen Sie zum offiziellen Rust-Website und installieren Sie die bevorzugte Version für Ihr Betriebssystem.

Sobald Sie Rust installiert haben, können Sie mit dem Schreiben von Programmen in Rust-Dateien beginnen

.rs Verlängerung. Rust ist vielseitig und leicht zu erlernen. Wenn Sie über Programmiererfahrung verfügen, wird es Ihnen leicht fallen.

Variablen und Konstanten in Rust

Rust ist sehr ausdrucksstark und es gibt mehrere Möglichkeiten, Variablen zu deklarieren. Du kannst den... benutzen lassen Schlüsselwort zum Deklarieren von Variablen.

So können Sie Variablen in Rust deklarieren:

lassen A: Zeichenfolge;
lassen B: i32;
lassen c: () = ();

Der A Und B Variablen sind jeweils eine Zeichenfolge und eine Ganzzahl. Der C Variable ist ein Rust-Einheitentyp, der als Platzhalter für Funktionen und Ausdrücke fungiert.

Nach der optionalen Datentypdeklaration können Sie Variablen mit Werten über ein Gleichheitszeichen deklarieren und initialisieren.

fnhauptsächlich(){
lassen Alter: Zeichenfolge = Zeichenfolge::aus(„fünf Jahre alt“);
lassen Alter = 5; // äquivalent zu let age: i32 = 5;
println!("{}", Alter);
}

Das Programm deklariert zwei Alter Variablen vor dem Drucken mit dem println! Makro. Der erste Alter Variable gibt den Datentyp an, die zweite nicht.

Sie müssen den Datentyp einer Variablen nicht angeben, wenn Sie sie deklarieren. Der Rust-Compiler leitet den Typ zur Kompilierungszeit aus dem Datentyp des Werts ab.

Sie können in Rust auch Konstanten mit dem deklarieren const Schlüsselwort auf ähnliche Weise wie beim Deklarieren von Variablen:

const Alter: &str = „fünf Jahre alt“;

Sie können den Wert einer Variablen, die Sie als Konstante deklarieren, nicht ändern.

Rust bietet Funktionen für einzeilige und Blockkommentare. Sie können doppelte Schrägstriche verwenden (//) für einzeilige Kommentare:

fnhauptsächlich() {
// Dies ist ein Zeilenkommentar
lassen x = 5; // Dieser Kommentar erklärt den Zweck der Variablen „x“.
}

Für mehrzeilige Kommentare (Blockkommentare) verwenden Sie einen Schrägstrich gefolgt von einem Sternchen (/*) und schließen Sie den Block mit einem Sternchen gefolgt von einem Schrägstrich (*/):

fnhauptsächlich() {
/*
 Dies ist ein Blockkommentar, der sich über mehrere Zeilen erstreckt.
 Es wird oft verwendet, um einen größeren Codeblock zu beschreiben.
 */
lassen x = 5;
}

Ihre Kommentare sollten prägnant und unkompliziert sein.

Arrays in Rust

Arrays sind eine Sammlung fester Größe von Elementen desselben Datentyps. Rust weist standardmäßig Arrays auf dem Stapel zu.

So können Sie Arrays in Rust deklarieren:

fnhauptsächlich() {
lassen Zahlen = [1, 2, 3, 4, 5];
}

Der Zahlen Das Array enthält fünf Elemente. Sie können über seinen Index auf den Wert an einer Stelle in einem Array zugreifen:

fnhauptsächlich() {
lassen Zahlen = [1, 2, 3, 4, 5];
lassen x = Zahlen[3];
println!("{}", X)
}

Der hauptsächlich Funktion druckt die X Variable, die auf das vierte Element des Arrays zugreift.

Vektoren in Rust

Rust stellt Vektoren bereit, um die Einschränkungen des Arrays zu vertuschen. Vektoren haben eine dynamische Größe; Sie können je nach Bedarf wachsen und schrumpfen.

So können Sie Vektoren in Rust deklarieren:

fnhauptsächlich() {
lassen my_vec: Vec<i32> = vec![1, 2, 3, 4, 5];
lassen x = my_vec[3];
println!("{}", X)
}

Der my_vec Vektor ist ein Vektor aus 32-Bit-Ganzzahlen. Der X Die Variable greift auf das vierte Element des Vektors zu und die hauptsächlich Die Funktion gibt den Wert auf der Konsole aus.

Rusts bedingte Anweisungen

Bedingte Anweisungen sind eine davon Rusts Kontrollstrukturen zur Entscheidungsfindung in Programmen. Du kannst den... benutzen Wenn Und anders Schlüsselwörter zur Handhabung von Entscheidungen in Ihren Programmen.

Hier ist ein Wenn Anweisung, die basierend auf der Gleichheit zweier Ganzzahlen eine Zeichenfolge an die Konsole ausgibt.

fnhauptsächlich() {
lassen A: i32 = 12;
Wenn ein == 12 {
println!(„a ist gleich zwölf“);
 }
}

Der hauptsächlich Die Funktion gibt den String mit dem aus println! Makro, da die Variable gleich 12 ist.

Du kannst den... benutzen anders Schlüsselwort zur Behandlung von Fällen, in denen die Wenn Aussage wertet falsch aus:

fnhauptsächlich() {
lassen A: i32 = 12;
Wenn ein == 123 {
println!(„a ist gleich zwölf“);
 } anders {
println!(„a ist nicht gleich zwölf“);
 }
}

In diesem Beispiel ist die anders Die Anweisung wird ausgeführt, weil der Wert von a nicht gleich 123 ist.

Sie können Match-Anweisungen mit dem deklarieren passen Schlüsselwort für komplexe Bedingungen:

fnhauptsächlich() {
lassen Alter: i32 = 7;
passen Alter {
1 => println!("eins"),
2 => println!("zwei"),
3 => println!("drei"),
 _ => println!("null"),
 }
}

Der hauptsächlich Funktion entspricht der Alter variabel zu Fällen in der passen Anweisung und führt den Ausdruck aus, der dem Wert entspricht. Der Unterstrich (_) ist die Standardanweisung, die ausgeführt wird, wenn eine Übereinstimmung für den Wert vorliegt.

Schleifen in Rust

Rust bietet Schleifen für sich wiederholende Aufgaben. Rust hat drei Haupttypen von Schleifen: Schleife, während, Und für Schleifen.

Der Schleife Schlüsselwort erstellt eine Endlosschleife, die ausgeführt wird, bis sie auf ein Schlüsselwort break trifft:

fnhauptsächlich() {
Schleife {
println!(„Wird wiederholt gedruckt, bis eine Break-Anweisung auftritt.“);
brechen;
 }
}

Der während Die Schleife ist praktisch, wenn Sie einen Codeblock wiederholen möchten, solange eine Bedingung als wahr ausgewertet wird:

fnhauptsächlich() {
lassenmut zählen = 0;
während zählen < 5 {
println!(„Die Anzahl ist {}“, zählen);
 zählen += 1;
 }
}

A für Die Schleife eignet sich gut zum Durchlaufen einer Sammlung von Elementen, beispielsweise eines Arrays:

fnhauptsächlich() {
lassen Zahlen = [1, 2, 3, 4, 5];
für Artikel In zahlen.iter() {
println!(„Der aktuelle Artikel ist {}“, Artikel);
 }
}

Das für Schleife durchläuft die Zahlen Array und gibt jedes Element auf der Konsole aus.

Deklarieren und Aufrufen von Rust-Funktionen

Benutzen Sie die fn Stichwort zu Deklarieren Sie eine Rust-Funktion, gefolgt vom Funktionsnamen, einer Liste von Parametern und einem Rückgabetyp (falls vorhanden).

So können Sie eine Funktion mit Parametern und einem Rückgabetyp deklarieren:

fnhinzufügen(A: i32, B: i32) -> i32 {
zurückkehren a + b;
}

Der hinzufügen Die Funktion nimmt zwei 32-Bit-Ganzzahlen auf und gibt eine 32-Bit-Ganzzahl zurück, die Summe der beiden Parameter.

Um eine Funktion von einer anderen Stelle in Ihrem Code aufzurufen, geben Sie einfach den Namen und die Argumente (falls vorhanden) an:

fnhauptsächlich() {
lassen Ergebnis = hinzufügen(2, 3);
println!("2 + 3 = {}", Ergebnis);
}

Der Ergebnis Die Variable enthält das Ergebnis des Aufrufs von hinzufügen Funktion. Der hauptsächlich Die Funktion druckt das Ergebnis mit der auf der Konsole aus println! Makro.

Strukturen in Rust

Rust stellt Strukturen zum Definieren benutzerdefinierter Datentypen bereit, die verwandte Werte gruppieren. Strukturen sind Blaupausen zum Erstellen von Objekten mit bestimmten Eigenschaften.

So können Sie eine Struktur deklarieren:

StrukturPerson {
 Name: Zeichenfolge,
 Alter: u32,
 ist_männlich: bool,
}

Der Person struct hat drei Felder: einen String, eine vorzeichenlose 32-Bit-Ganzzahl und einen booleschen Wert.

Nachdem Sie eine Struktur definiert haben, können Sie Instanzen davon in anderen Teilen Ihres Programms erstellen:

fnhauptsächlich() {
lassen person1 = Person {
 Name: Zeichenfolge::aus(„Candace Flynn“),
 Alter: 16,
 ist_männlich: FALSCH,
 };
}

Der Person1 Variable ist eine Instanz von Person Struktur. Bei der Instanziierung können Sie den Strukturfeldern Werte zuweisen. Sie können beliebig viele Instanzen einer Struktur erstellen.

Sie können OOP-Konzepte in Rust implementieren

Rust ist flexibel und Sie können die OOP-Konzepte in Rust mit integrierten Datenstrukturen wie Strukturen implementieren.

Sie verwenden Strukturen als Alternative zu Klassen. Mit der Struktur von Rust können Sie einen Entwurf für den Typ definieren und die verschiedenen OOP-Konzepte mit den Funktionalitäten implementieren, die Rust für Strukturen bereitstellt.