0Pricing
Learn Rust Coding · Lektion

Funktionen und Kontrollfluss

Lernen Sie, Funktionen zu definieren und `if`/`else`, `loop`, `while` und `for`-Ausdrücke zur Steuerung des Programmablaufs zu verwenden.

Funktionen und Kontrollfluss ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 3 von 3. 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 3 Lektionen.

Was sind Funktionen?

Funktionen sind benannte Codeblöcke, die eine bestimmte Aufgabe ausführen. Sie sind grundlegend für die Strukturierung Ihres Codes und machen ihn wiederverwendbar.

  • Wiederverwendbarkeit: Schreiben Sie eine Logik einmal und verwenden Sie sie mehrfach.
  • Modularität: Teilen Sie komplexe Probleme in kleinere, überschaubare Teile auf.
  • Lesbarkeit: Vergeben Sie aussagekräftige Namen für Codeblöcke, um das Verständnis zu verbessern.

Ihre erste Rust-Funktion

In Rust definieren Sie eine Funktion mit dem Schlüsselwort fn. Die Funktion main ist der Einstiegspunkt jedes Rust-Programms.

So deklarieren und rufen Sie eine einfache Funktion auf:

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

fn main() {
    say_hello(); // Call the function
    println!("Back in main.");
}

Funktionen mit Parametern

Funktionen können Eingabewerte annehmen, die Parameter genannt werden. Dadurch kann Ihre Funktion bei jedem Aufruf mit anderen Daten arbeiten.

Parameter werden mit einem Namen und einem durch einen Doppelpunkt getrennten Typ definiert.

fn greet(name: &str) {
    println!("Hello, {}!", name);
}

fn main() {
    greet("Alice");
    greet("Bob");
}

Funktionen mit Rückgabewerten

Funktionen können auch einen Wert an den Aufrufer zurückgeben. Den Rückgabetyp geben Sie nach einem Pfeil (->) an.

Der letzte Ausdruck im Funktionsrumpf wird implizit zurückgegeben. Für den Rückgabeausdruck ist kein Semikolon erforderlich!

fn add_numbers(x: i32, y: i32) -> i32 {
    x + y // No semicolon: this expression is returned
}

fn main() {
    let sum = add_numbers(5, 7);
    println!("The sum is: {}", sum);
}

Entscheidungen treffen: `if`/`else`

Der Ausdruck if ermöglicht es Ihrem Programm, abhängig von einer Bedingung unterschiedliche Codeblöcke auszuführen. Bedingungen müssen immer ein bool sein (true/false).

  • Verwenden Sie if für die erste Bedingung.
  • Verwenden Sie else if für weitere Bedingungen.
  • Verwenden Sie else als Ausweichfall, wenn keine andere Bedingung erfüllt ist.

if ist in Rust ein Ausdruck, das heißt, er kann einen Wert zurückgeben!

If-Else-Ausdrücke in Aktion

So können Sie if und else verwenden, um abhängig von einer Bedingung einen Wert zuzuweisen. Beachten Sie, dass sich dies ähnlich wie ein ternärer Operator in anderen Sprachen verhält.

fn main() {
    let number = 7;

    let message = if number < 10 {
        "Small number"
    } else {
        "Large number"
    };

    println!("The number is: {}", message);

    let other_num = 15;
    if other_num % 2 == 0 {
        println!("{} is even", other_num);
    } else {
        println!("{} is odd", other_num);
    }
}

Code wiederholen: `loop`

Das Schlüsselwort loop erzeugt eine Endlosschleife. Das ist nützlich, wenn Sie eine Aktion wiederholen müssen, bis Sie sie ausdrücklich beenden.

Verwenden Sie break, um die Schleife zu verlassen. Mit break können Sie sogar einen Wert aus einem loop-Ausdruck zurückgeben.

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2; // Break and return a value
        }
    };

    println!("The result is {}", result);
}

Bedingte Wiederholung: `while`

Die while-Schleife führt einen Codeblock aus, solange eine angegebene Bedingung wahr bleibt. Sie eignet sich besonders, wenn Sie nicht genau wissen, wie oft die Schleife durchlaufen werden muss.

fn main() {
    let mut count = 3;

    while count != 0 {
        println!("{}!", count);
        count -= 1;
    }

    println!("LIFTOFF!!!");
}

Mit `for`-Schleifen iterieren

Die for-Schleife wird verwendet, um über eine Sammlung von Elementen oder einen Zahlenbereich zu iterieren. Sie ist die am häufigsten verwendete Schleifenkonstruktion in Rust und macht Ihren Code sicher und kompakt.

  • Sie wird häufig mit Bereichen verwendet (z. B. 1..4 für 1, 2, 3 oder 1..=4 für 1, 2, 3, 4).
  • Sie funktioniert mit jedem Typ, der das Merkmal Iterator implementiert.
fn main() {
    // Loop through a range
    for number in 1..4 { // 1, 2, 3
        println!("Number: {}", number);
    }

    // Loop through an array
    let a = [10, 20, 30, 40, 50];
    for element in a.iter() {
        println!("The value is: {}", element);
    }
}

Herausforderung zur Ablaufsteuerung

Betrachten Sie den folgenden Rust-Code. Welchen endgültigen Wert hat result?

fn calculate_value(input: i32) -> i32 {
    if input > 10 {
        input * 2
    } else if input == 5 {
        input + 5
    } else {
        input
    }
}

fn main() {
    let result = calculate_value(5);
    // What is result?
}

Rückblick: Funktionen und Ablaufsteuerung

Sie haben die grundlegenden Bausteine für dynamische Programme gemeistert!

  • Funktionen: Strukturieren Sie Code und verwenden Sie ihn wieder mit fn, Parametern und Rückgabewerten.
  • if/else: Treffen Sie Entscheidungen und führen Sie Code bedingt aus. Denken Sie daran: Es handelt sich um einen Ausdruck!
  • loop: Erstellen Sie Endlosschleifen, verlassen Sie sie mit break und geben Sie Werte zurück.
  • while: Wiederholen Sie Code, solange eine Bedingung wahr ist.
  • for: Iterieren Sie sicher über Sammlungen und Bereiche.

Diese Werkzeuge sind unverzichtbar, um strukturierte und effiziente Rust-Programme zu schreiben!

Häufig gestellte Fragen

Ist die Lektion „Funktionen und Kontrollfluss“ kostenlos?

Ja — der vollständige Text von „Funktionen und Kontrollfluss“ 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 3 Lektionen.

Was lerne ich in „Funktionen und Kontrollfluss“?

Lernen Sie, Funktionen zu definieren und `if`/`else`, `loop`, `while` und `for`-Ausdrücke zur Steuerung des Programmablaufs zu verwenden. 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 3 von 3.

Wie lange dauert die Lektion „Funktionen und Kontrollfluss“?

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

  1. Variablen, Veränderlichkeit und Shadowing
  2. Primitive Datentypen und Operatoren
  3. Funktionen und Kontrollfluss
← Zurück zu Learn Rust Coding