Learn Rust Coding · Lektion

Funktionen definieren

Parameter und Rückgabewerte

Funktionen definieren ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Eine Funktion deklarieren

Sie definieren eine Funktion mit dem Schlüsselwort fn, einem Namen, runden Klammern und einem Körper in geschweiften Klammern.

Für Funktionsnamen verwendet Rust konventionsgemäß snake_case.

fn main() {
    greet();
}

fn greet() {
    println!("Hello from a function!");
}

Die Funktion main

Jedes ausführbare Rust-Programm beginnt bei fn main(). Sie ist der Einstiegspunkt, den die Laufzeitumgebung zuerst aufruft.

fn main() {
    println!("Program starts here");
}

Parameter

Funktionen können Parameter entgegennehmen. Jeder Parameter muss seinen Typ nach einem Doppelpunkt angeben.

fn main() {
    print_number(7);
}

fn print_number(x: i32) {
    println!("The number is {}", x);
}

Mehrere Parameter

Trennen Sie mehrere Parameter durch Kommas. Jeder benötigt eine eigene Typannotation.

fn main() {
    describe("Rust", 2010);
}

fn describe(name: &str, year: i32) {
    println!("{} was released in {}", name, year);
}

Rückgabewerte

Geben Sie den Rückgabetyp nach einem Pfeil -> an. Die Funktion gibt einen Wert dieses Typs zurück.

Der letzte Ausdruck (ohne Semikolon) wird zum Rückgabewert.

fn main() {
    let result = square(5);
    println!("square is {}", result);
}

fn square(n: i32) -> i32 {
    n * n
}

Das Schlüsselwort return

Sie können auch mit dem Schlüsselwort return vorzeitig zurückkehren. Dies ist für Schutzbedingungen nützlich.

fn main() {
    println!("{}", abs_value(-8));
}

fn abs_value(n: i32) -> i32 {
    if n < 0 {
        return -n;
    }
    n
}

Parameter und Rückgabewerte kombinieren

Eine Funktion nimmt häufig Eingaben entgegen und erzeugt eine Ausgabe. Hier werden zwei Zahlen addiert.

fn main() {
    let total = add(3, 4);
    println!("total {}", total);
}

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

Funktionen rufen Funktionen auf

Funktionen können andere Funktionen aufrufen. So lässt sich aus kleinen, wiederverwendbaren Bausteinen ein größeres Verhalten aufbauen.

fn main() {
    println!("{}", double_then_add(5));
}

fn double(n: i32) -> i32 { n * 2 }

fn double_then_add(n: i32) -> i32 {
    double(n) + 1
}

Andere Typen zurückgeben

Funktionen können jeden beliebigen Typ zurückgeben: Zeichenketten, boolesche Werte, Tupel und mehr.

fn main() {
    let (sum, product) = compute(3, 4);
    println!("sum {} product {}", sum, product);
}

fn compute(a: i32, b: i32) -> (i32, i32) {
    (a + b, a * b)
}

Funktionen ohne Rückgabewert

Eine Funktion ohne Pfeil gibt den Unit-Typ () zurück. Sie führt ihre Arbeit durch Seiteneffekte wie das Ausgeben von Text aus.

fn main() {
    log_message("saving file");
}

fn log_message(msg: &str) {
    println!("[LOG] {}", msg);
}

Die Reihenfolge spielt keine Rolle

Anders als in manchen Sprachen können Sie in Rust eine Funktion aufrufen, die später in der Datei definiert wird. Der Compiler kennt alle Funktionen, bevor das Programm ausgeführt wird.

fn main() {
    println!("{}", helper());
}

fn helper() -> i32 {
    99
}

Kurztest

Rufen Sie sich in Erinnerung, wie Rust-Funktionen Werte zurückgeben.

Zusammenfassung

Funktionen in Rust:

Sie werden mit fn name(params) -> ReturnType { ... } definiert.
Parameter benötigen explizite Typen.
Der letzte Ausdruck (ohne Semikolon) ist der Rückgabewert; alternativ können Sie vorher return verwenden.
Ohne Rückgabetyp wird () zurückgegeben.

fn main() {
    let area = rectangle_area(4, 6);
    println!("area {}", area);
}

fn rectangle_area(w: i32, h: i32) -> i32 {
    w * h
}

Häufig gestellte Fragen

Ist die Lektion „Funktionen definieren“ kostenlos?

Ja — der vollständige Text von „Funktionen definieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Funktionen definieren“?

Parameter und Rückgabewerte Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn Rust Coding zu starten?

Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Funktionen definieren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?

Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Learn Rust Coding