Learn Rust Coding · Lekcja

Definiowanie funkcji

Parametry i wartości zwracane

Definiowanie funkcji to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 1 z 4. 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 4 lekcji w sumie.

Deklarowanie funkcji

Funkcję definiuje się za pomocą słowa kluczowego fn, nazwy, nawiasów i ciała ujętego w nawiasy klamrowe.

Zgodnie z konwencją Rust używa zapisu snake_case dla nazw funkcji.

fn main() {
    greet();
}

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

Funkcja main

Każdy wykonywalny program w Rust rozpoczyna działanie od fn main(). Jest to punkt wejścia, który środowisko uruchomieniowe wywołuje jako pierwszy.

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

Parametry

Funkcje mogą przyjmować parametry. Po dwukropku przy każdym parametrze trzeba podać jego typ.

fn main() {
    print_number(7);
}

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

Wiele parametrów

Wiele parametrów oddzielaj przecinkami. Każdy z nich wymaga własnej adnotacji typu.

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

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

Wartości zwracane

Typ zwracany deklaruje się po strzałce ->. Funkcja zwraca wartość tego typu.

Ostatnie wyrażenie (bez średnika) staje się wartością zwracaną.

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

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

Słowo kluczowe return

Można również wcześniej zakończyć działanie funkcji za pomocą słowa kluczowego return. Jest to przydatne w warunkach ochronnych.

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

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

Łączenie parametrów i wartości zwracanych

Funkcja często przyjmuje dane wejściowe i tworzy wynik. W tym przykładzie dodajemy dwie liczby.

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

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

Funkcje wywołujące funkcje

Funkcje mogą wywoływać inne funkcje, co pozwala budować większe zachowania z małych, wielokrotnie używanych elementów.

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

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

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

Zwracanie innych typów

Funkcje mogą zwracać dowolny typ: łańcuchy znaków, wartości logiczne, krotki i inne.

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

Funkcje bez wartości zwracanej

Funkcja bez strzałki zwraca typ unit (). Wykonuje działanie za pomocą efektów ubocznych, takich jak wyświetlanie tekstu.

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

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

Kolejność nie ma znaczenia

W przeciwieństwie do niektórych języków, w Rust można wywołać funkcję zdefiniowaną później w pliku. Kompilator widzi wszystkie funkcje przed uruchomieniem programu.

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

fn helper() -> i32 {
    99
}

Szybkie sprawdzenie

Przypomnij sobie, jak funkcje w Rust zwracają wartości.

Podsumowanie

Funkcje w Rust:

Definiuje się je za pomocą fn name(params) -> ReturnType { ... }.
Parametry wymagają jawnego określenia typów.
Ostatnie wyrażenie (bez średnika) jest wartością zwracaną; można też wcześniej użyć return.
Brak typu zwracanego oznacza zwracanie ().

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

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

Często zadawane pytania

Czy lekcja „Definiowanie funkcji” jest bezpłatna?

Tak — pełny tekst „Definiowanie funkcji” 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 4 lekcji w sumie.

Co nauczysz się w „Definiowanie funkcji”?

Parametry i wartości zwracane Ć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 1 z 4.

Ile czasu zajmuje lekcja „Definiowanie funkcji”?

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