Funktionen in Rust verstehen

Funktionen sind wesentliche Programmierkonstrukte, da sie eine Grundlage für die Wiederverwendbarkeit von Code bilden und die modulare Programmierung erleichtern. Funktionen sind eigenständige Codeblöcke, die bestimmte Aufgaben ausführen. Sie können Eingaben in Form von Argumenten empfangen und einen Wert zurückgeben.

Rust bietet Funktionen für die Codeorganisation, Kapselung und Wiederverwendbarkeit von Code.

Funktionen in Rust definieren

Rust-Funktionen sind ähnlich funktioniert in jeder anderen Programmiersprache, obwohl es kleine Unterschiede gibt, die Sie verstehen müssen.

Mit der definieren Sie Funktionen für Ihre Rust-Programme fn Schlüsselwort gefolgt vom Funktionsnamen, optionalen Argumenten und einer optionalen Rückgabe Datentyp.

// Funktion, die weder Argumente akzeptiert noch einen Wert zurückgibt
fn Funktionsname() {
// Funktionskörper hier
}

Hier ist eine einfache Rust-Funktion, die keine Argumente aufnimmt oder Werte zurückgibt.

fn a_function(){
 sei x = 3;
println!("{}", X)
}

eine Funktion ist eine einfache Rust-Funktion, die die Variable ausgibt X.

Rust-Funktionssignaturen

Funktionssignaturen sind eine Möglichkeit, Funktionen zu benennen und ihre Argumente und Rückgabetypen zu beschreiben, ohne einen Funktionskörper einzuschließen. Funktionssignaturen sind nützlich, um APIs von Rust-Bibliotheken zu dokumentieren.

Hier ist ein Beispiel für eine Rust-Funktionssignatur:

fn-Name ()
fn grüßen (Name: &str)

Der Name function ist eine minimale Funktionssignatur, während die grüßen Signatur gibt an, dass die Funktion ein einzelnes Argument akzeptiert, Name, vom Typ Zeichenfolge (&str).

Deklarieren von Funktionen mit Argumenten und Rückgabewerten

Rust-Funktionen können viele Argumente aufnehmen, und die Grenze ist nicht explizit definiert. Funktionen mit Argumenten sind im Allgemeinen flexibler, da sie Werte aus anderen Funktionen und Codeteilen übernehmen können.

Hier ist das typische Modell einer Rust-Funktion, die Argumente aufnimmt:

fn Funktionsname (arg: Typ, arg2: Typ) {
// Funktionskörper hier
}

Der Funktionsargumenttyp kann ein in Rust integrierter Typ oder ein benutzerdefinierter Typ aus Ihrem Programm sein.

Hier ist ein Beispiel für eine einfache Funktion, die zwei ganze Zahlen als Argumente akzeptiert:

fn add_numbers (x: i32, y: i32) {
println!("{}", x + y);
}

Der add_numbers Die Funktion nimmt zwei 32-Bit-Ganzzahlen auf und gibt die Summe der Ganzzahlen aus.

Rust-Funktionen können mehrere Werte zurückgeben; Sie müssen den/die Rückgabetyp(en) angeben und die Werte des Typs aus der Funktion zurückgeben.

fn Funktionsname (arg: Typ, arg2: Typ) -> (Typ, Typ) {
// Funktionskörper hier
zurückkehren arg, arg2
}

Hier ist eine Funktion, die einen String und eine 32-Bit-Ganzzahl als Argument akzeptiert und die Argumente als Tupel zurückgibt.

fn string_and_integer (s: String, n: i32) -> (String, i32) {
zurückkehren (s, n);
}

Der string_and_integer Die Funktion nimmt einen String und eine 32-Bit-Ganzzahl entgegen und gibt sie als Tupel zurück. Sie können nur einen einzelnen Wert von einer Rust-Funktion zurückgeben.

Die kannst du weglassen zurückkehren Schlüsselwort, wenn der letzte Ausdruck von einer Funktion zurückgegeben wird, um den Code prägnanter zu machen.

fn string_and_integer (s: String, n: i32) -> (String, i32) {
zurückkehren (s, n);
}
// Die Funktionen sind äquivalent
fn str_and_int (s: String, n: i32) -> (String, i32) {
 (s, n)
}

Diese beiden Funktionen haben das gleiche Verhalten, da sie beide eine Zeichenfolge und eine ganze Zahl annehmen und diese Argumente als Tupel zurückgeben.

Rust-Funktionen aufrufen

Sie können eine Funktion von einer anderen aufrufen, indem Sie ihren Namen gefolgt von Werten, die Sie ihr übergeben möchten, in Klammern schreiben:

fn add_numbers (x: i32, y: i32) -> i32 {
 x + y
}
fn Haupt() {
 let result = add_numbers(3, 5);
println!("Das Ergebnis ist {}", Ergebnis); // Ausgabe: Das Ergebnis ist 8
}

Der hauptsächlich Funktionsaufrufe add_numbers, und übergibt ihm zwei ganze Zahlen. Es weist das Ergebnis der Funktion einer Variablen zu, Ergebnis.

Sie können Funktionen für Rust-Strukturen deklarieren

Sie können Funktionen innerhalb von Rust-Strukturen deklarieren. Diese werden zu Methoden für die Struktur, die darauf zugreifen und sie ändern kann.

Rust ist nicht rein objektorientiert, aber es stellt Strukturen bereit, um zusammengehörige Daten zu gruppieren. Sie können auf die Implementierung von OOP-Konzepten in Rust hinarbeiten, indem Sie Strukturen mit Methoden verwenden.