Learn Rust Coding · Lekcja

Funkcje i sterowanie przepływem

Nauczą się Państwo definiować funkcje oraz używać wyrażeń `if`/`else`, `loop`, `while` i `for` do sterowania przebiegiem programu.

Funkcje i sterowanie przepływem to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 3 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn Rust Coding, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn Rust Coding zawiera 3 lekcji w sumie.

Czym są funkcje?

Funkcje to nazwane bloki kodu, które wykonują określone zadanie. Są podstawą porządkowania kodu i umożliwiają jego ponowne wykorzystanie.

Wielokrotne użycie kodu: Napisanie fragmentu logiki raz i używanie go wielokrotnie.
Modułowość: Dzielenie złożonych problemów na mniejsze, łatwiejsze do zarządzania części.
Czytelność: Nadawanie blokom kodu znaczących nazw, co ułatwia ich zrozumienie.

Pierwsza funkcja w języku Rust

W języku Rust funkcję definiuje się za pomocą słowa kluczowego fn. Funkcja main jest punktem wejścia każdego programu w języku Rust.

Oto jak zadeklarować i wywołać prostą funkcję:

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

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

Funkcje z parametrami

Funkcje mogą przyjmować wartości wejściowe nazywane parametrami. Dzięki nim funkcja może działać na innych danych przy każdym wywołaniu.

Parametry definiuje się za pomocą nazwy i typu oddzielonych dwukropkiem.

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

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

Funkcje zwracające wartości

Funkcje mogą również zwracać wartość do miejsca wywołania. Typ zwracany określa się po strzałce (->).

Ostatnie wyrażenie w treści funkcji jest zwracane niejawnie. Dla wyrażenia zwracanego nie trzeba dodawać średnika!

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);
}

Podejmowanie decyzji: `if`/`else`

Wyrażenie if pozwala programowi wykonywać różne bloki kodu w zależności od warunku. Warunki muszą zawsze mieć typ bool (przyjmować wartość true/false).

Użyj if dla pierwszego warunku.
Użyj else if dla kolejnych warunków.
Użyj else jako rozwiązania awaryjnego, gdy żaden inny warunek nie zostanie spełniony.

Element if w języku Rust jest wyrażeniem, co oznacza, że może zwracać wartość!

Wyrażenia if-else w praktyce

Oto jak używać if i else do przypisywania wartości na podstawie warunku. Należy zauważyć, że działa to podobnie do operatora trójargumentowego z innych języków.

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);
    }
}

Powtarzanie kodu: `loop`

Słowo kluczowe loop tworzy nieskończoną pętlę. Jest przydatne, gdy trzeba powtarzać działanie aż do momentu jawnego podjęcia decyzji o jego zakończeniu.

Użyj break, aby wyjść z pętli. Za pomocą break można nawet zwrócić wartość z wyrażenia loop.

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);
}

Powtarzanie warunkowe: `while`

Pętla while wykonuje blok kodu tak długo, jak długo określony warunek pozostaje prawdziwy. Jest idealna, gdy nie wiadomo dokładnie, ile razy pętla powinna się wykonać.

fn main() {
    let mut count = 3;

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

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

Iterowanie za pomocą pętli `for`

Pętla for służy do iterowania po elementach kolekcji lub zakresie liczb. Jest najczęściej używaną konstrukcją pętli w języku Rust, dzięki czemu kod jest bezpieczny i zwięzły.

Często używa się jej z zakresami (np. 1..4 oznacza 1, 2, 3, a 1..=4 oznacza 1, 2, 3, 4).
Działa z każdym typem implementującym cechę Iterator.

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);
    }
}

Wyzwanie: przepływ sterowania

Proszę przeanalizować poniższy kod w języku Rust. Jaka będzie końcowa wartość zmiennej 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?
}

Podsumowanie: funkcje i przepływ sterowania

Opanowali Państwo podstawowe elementy potrzebne do tworzenia dynamicznych programów!

Funkcje: Porządkuj i wykorzystuj ponownie kod za pomocą fn, parametrów i wartości zwracanych.
if/else: Podejmuj decyzje i warunkowo wykonuj kod. Pamiętaj, że jest to wyrażenie!
loop: Twórz nieskończone pętle, wychodź z nich za pomocą break i zwracaj wartości.
while: Wykonuj pętlę tak długo, jak długo warunek jest prawdziwy.
for: Bezpiecznie iteruj po kolekcjach i zakresach.

Te narzędzia są niezbędne do pisania uporządkowanych i wydajnych programów w języku Rust!

Często zadawane pytania

Czy lekcja „Funkcje i sterowanie przepływem” jest bezpłatna?

Tak — pełny tekst „Funkcje i sterowanie przepływem” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn Rust Coding, przejdź na CoddyKit PRO. Kurs Learn Rust Coding zawiera 3 lekcji w sumie.

Co nauczysz się w „Funkcje i sterowanie przepływem”?

Nauczą się Państwo definiować funkcje oraz używać wyrażeń `if`/`else`, `loop`, `while` i `for` do sterowania przebiegiem programu. Ćwiczysz Learn Rust Coding z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn Rust Coding?

Nie wymagamy żadnego doświadczenia. Learn Rust Coding w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 3.

Ile czasu zajmuje lekcja „Funkcje i sterowanie przepływem”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn Rust Coding?

Tak. Każda lekcja Learn Rust Coding zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Learn Rust Coding