Rust-Funktionen

Funktionen sind in der Rust-Sprache allgegenwärtig.

In den vorherigen Kapiteln haben wir bereits die Grundform von Rust-Funktionen kennengelernt:

fn <函数名> ( <参数> ) <函数体>

Der Namensstil für Rust-Funktionsnamen besteht aus Kleinbuchstaben, die durch Unterstriche getrennt sind:

Beispiel

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

fn another_function() {
    println!("Hello, example!");
}

Ausgabe:

Hello, world!
Hello, example!

Beachte, dass wir another_function im Quellcode nach der main-Funktion definiert haben. Rust ist es egal, wo du Funktionen definierst, du musst sie nur irgendwo definieren.

Funktionsparameter

Wenn eine Funktion in Rust Parameter benötigt, musst du die Parameternamen und -typen angeben:

Beispiel

fn main() {
    another_function(5, 6);
}

fn another_function(x: i32, y: i32) {
    println!("The value of x is: {}", x);
    println!("Der Wert von y ist: {}", y);
}

Ausgabe:

x 的值为 : 5
y 的值为 : 6

Anweisungen und Ausdrücke in Funktionskörpern

Rust-Funktionskörper bestehen aus einer Reihe von Anweisungen (Statements), die mit einem Ausdruck (Expression) enden können. Bisher haben wir nur Funktionen gesehen, die nicht mit einem Ausdruck enden, aber wir haben bereits Ausdrücke als Teil von Anweisungen verwendet.

Eine Anweisung ist ein Schritt, der eine Aktion ausführt und keinen Rückgabewert hat. Zum Beispiel:

let a = 6;

Dieser Schritt hat keinen Rückgabewert, daher ist die folgende Anweisung falsch:

let a = (let b = 2);

Ein Ausdruck hat Berechnungsschritte und einen Rückgabewert. Die folgenden sind Ausdrücke (angenommen, die vorkommenden Bezeichner wurden bereits definiert):

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

In Rust kannst du einen{}Block, der von {} eingeschlossen ist, verwenden, um einen komplexeren Ausdruck zu schreiben:

Beispiel

fn main() {
    let x = 5;

    let y = {
        let x = 3;
        x + 1
    };

    println!("The value of x is: {}", x);
    println!("Der Wert von y ist: {}", y);
}

Ausgabe:

x 的值为 : 5
y 的值为 : 4

Offensichtlich enthält dieses Programm einen Ausdrucksblock:

{
    let x = 3;
    x + 1
};

Außerdem können Funktionsanweisungen im Block verwendet werden, und der letzte Schritt ist ein Ausdruck. Der Ergebniswert dieses Ausdrucks ist der Wert, der durch den gesamten Ausdrucksblock dargestellt wird. Diese Art von Ausdrucksblock wird Funktionskörperausdruck genannt.

Hinweis:x + 1Danach steht kein Semikolon, sonst wird es zu einer Anweisung!

Diese Art von Ausdrucksblock ist ein gültiger Funktionskörper. Außerdem können in Rust Funktionsdefinitionen verschachtelt werden:

Beispiel

fn main() {
    fn five() -> i32 {
        5
    }
    println!("The value of five() is: {}", five());
}

Rückgabewerte von Funktionen

Das vorherige verschachtelte Beispiel hat bereits gezeigt, wie Rust-Funktionen Rückgabewerttypen deklarieren: Nach den Parameterdeklarationen verwendet man->, um den Rückgabewerttyp der Funktion zu deklarieren (nicht: ）。

Im Funktionskörper kann man jederzeit das Schlüsselwort return verwenden, um die Ausführung der Funktion zu beenden und einen Wert eines geeigneten Typs zurückzugeben. Dies ist auch der Ansatz, der der Erfahrung der meisten Entwickler am nächsten kommt:

Beispiel

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

Allerdings unterstützt Rust keine automatische Rückgabetyp-Inferenz! Wenn der Rückgabetyp der Funktion nicht explizit deklariert wird, wird die Funktion als "reine Prozedur" betrachtet und darf keinen Rückgabewert liefern. Auf das return-Schlüsselwort darf kein Rückgabewert-Ausdruck folgen. Der Zweck davon ist, es öffentlichen Funktionen zu ermöglichen, ein sichtbares Bulletin zu bilden.

Hinweis:Ein Funktionskörper-Ausdruck ist nicht gleichbedeutend mit einem Funktionskörper; er kann das Schlüsselwortreturnnicht verwenden.

Andere Erweiterungen