Rust-Funktionen

Funktionen sind im Rust-Sprachgebrauch weit verbreitet.

Durch die vorherigen Kapitel können Sie bereits das grundlegende Format einer Rust-Funktion kennenlernen:

fn <Funktionsname> ( <Parameter> ) <Funktionskörper>

Der Name einer Rust-Funktion ist im Allgemeinen in Kleinbuchstaben und durch Unterstriche getrennt:

fn main() {
　　　　println!("Hallo, world!");
　　　　another_function();
}
fn another_function() {
　　　　println!("Hallo, w3codebox!);
}

Laufender Output:

Hallo, world!
Hallo, w3codebox!

Beachten Sie, dass wir die Funktion another_function nach der main-Funktion im Quellcode definiert haben. Rust kümmert sich nicht darum, wo Sie die Funktionen definieren, solange Sie sie irgendwo definieren.

Funktionseigenschaften

In Rust muss eine Funktion, die über Parameter verfügt, die Parametername und -typ angeben:

fn main() {
　　　　another_function(5,　6;
}
fn another_function(x: i32, y: i32) {
　　　　println!("x Wert: {}", x);
　　　　println!("y Wert: {}", y);
}

Laufender Output:

x Wert:　5
y Wert:　6

Anweisungen und Ausdrücke im Funktkörper

Der Körper einer Rust-Funktion besteht aus einer Reihe von Anweisungen (Statement), die mit einem Ausdruck (Expression) enden können. Bisher haben wir nur Funktionen ohne Ausdruck am Ende gesehen, aber die Ausdrücke wurden bereits als Teil einer Anweisung verwendet.

Eine Anweisung führt bestimmte Operationen aus und gibt keinen Rückgabewert zurück. Zum Beispiel:

let a =　6;

Dieser Schritt gibt keinen Rückgabewert zurück, daher ist die folgende Anweisung falsch:

let a = (let b =　2;

Der Ausdruck hat Berechnungsschritte und gibt einen Rückgabewert zurück. Nachfolgend ist der Ausdruck angegeben (vorausgesetzt, die identifizierten Bezeichner sind bereits definiert):

a =　7
b　+　2
c　*　(a　+　b)

In Rust können Sie in einem Block, der mit {} umgeben ist, einen komplexen Ausdruck schreiben:

fn main() {
　　　　let x =　5;
　　　　let y =
　　　　　　　　let x =　3;
　　　　　　　　x　+　1
　　　　};
　　　　println!("x Wert: {}", x);
　　　　println!("y Wert: {}", y);
}

Laufender Output:

x Wert:　5
y Wert:　4

Natürlich enthält dieses Programm einen Ausdrucksblock:

{
　　　　let x =　3;
　　　　x　+　1
};

Und Sie können in dem Block Funktionsanweisungen verwenden, der letzte Schritt ist ein Ausdruck, der den Wert des Ausdrucksblocks darstellt. Diesen Ausdrucksblock nennt man Funktionskörper-Ausdruck.

Beachtung: x + 1 Es gibt kein Semikolon, sonst würde es ein Statement sein!

Dieser Ausdrucksblock ist ein gültiger Funktionskörper. Und in Rust können Funktionen eingebettet werden:

fn main() {
　　　　fn five()　-> i32　{
　　　　　　　　5
　　　　}
　　　　println!("five() Wert: {}", five());
}

Funktion Rückgabewert

Im vorherigen eingebetteten Beispiel wurde bereits gezeigt, wie Rust den Typ des Rückgabewerts der Funktion deklariert: Nach der Parameterdeklaration wird -> um den Typ des Rückgabewerts der Funktion zu deklarieren (nicht : ).

In der Funktionskörpers können Sie jederzeit mit dem Schlüsselwort return die Ausführung der Funktion beenden und einen passenden Wert zurückgeben. Dies ist auch die Annäherung, die den meisten Entwicklern vertraut ist:

fn a: i32, b: i32)　-> i32　{
　　　　return a　+　b;
}

Allerdings unterstützt Rust keine automatische Typbestimmung von Rückgabewerten! Wenn der Typ des Rückgabewerts der Funktion nicht explizit angegeben ist, wird die Funktion als "reiner Prozess" betrachtet, keine Rückgabewerte erzeugen dürfen, nach return dürfen keine Rückgabewerte-Ausdrücke stehen. Dies geschieht, um sicherzustellen, dass öffentliche Funktionen sichtbare Berichte bilden können.

Beachtung:Der Ausdrucksblock des Funktionskörpers ist nicht gleichwertig mit dem Funktionskörper, er kann nicht verwendet werden return Schlüsselwörter.