Functies in roest begrijpen

Functies zijn essentiële programmeerconstructies, omdat ze een basis leggen voor herbruikbaarheid van code en modulaire programmering mogelijk maken. Functies zijn op zichzelf staande codeblokken die specifieke taken uitvoeren. Ze kunnen input ontvangen, in de vorm van argumenten, en een waarde retourneren.

Rust biedt functies voor codeorganisatie, inkapseling en herbruikbaarheid van code.

Functies definiëren in roest

Roestfuncties lijken veel op functies in elke andere programmeertaal, hoewel er kleine verschillen zijn die u moet begrijpen.

U definieert functies voor uw Rust-programma's met de fn trefwoord gevolgd door de functienaam, optionele argumenten en een optionele return data type.

// functie die geen argumenten opneemt en geen waarde retourneert
fn functienaam() {
// function body hier
}

Hier is een eenvoudige Rust-functie die geen argumenten opneemt of waarden retourneert.

fn a_function(){
 laat x = 3;
println!("{}", X)
}

een functie is een eenvoudige Rust-functie die de variabele afdrukt X.

Roest functie handtekeningen

Functiehandtekeningen zijn een manier om functies een naam te geven en hun argumenten en retourtypen te beschrijven, zonder een functielichaam toe te voegen. Functiehandtekeningen zijn handig voor het documenteren van API's van Rust-bibliotheken.

Hier is een voorbeeld van de handtekening van de Rust-functie:

fn naam()
fn greet (naam: &str)

De naam functie is een minimale functiehandtekening, terwijl de begroeten handtekening geeft aan dat de functie een enkel argument nodig heeft, naam, van het type tekenreeks (&str).

Functies declareren met argumenten en retourwaarden

Rust-functies kunnen veel argumenten opnemen en de limiet is niet expliciet gedefinieerd. Functies met argumenten zijn over het algemeen flexibeler omdat ze waarden kunnen overnemen van andere functies en delen van code.

Hier is het typische model van een Rust-functie die argumenten opneemt:

fn functienaam (arg: type, arg2: type) {
// function body hier
}

Het functieargumenttype kan een ingebouwd Rust-type zijn of een aangepast type uit uw programma.

Hier is een voorbeeld van een eenvoudige functie die twee gehele getallen als argumenten gebruikt:

fn add_numbers (x: i32, y: i32) {
println!("{}", x + y);
}

De voeg_nummers toe functie neemt twee gehele getallen van 32 bits op en drukt de som van de gehele getallen af.

Rust-functies kunnen meerdere waarden retourneren; u moet het (de) retourtype(n) specificeren en de waarden van het type uit de functie retourneren.

fn functienaam (arg: type, arg2: type) -> (type, type) {
// function body hier
opbrengst arg, arg2
}

Hier is een functie die een string en een 32-bits geheel getal als argument opneemt en de argumenten als een tuple retourneert.

fn string_and_integer (s: String, n: i32) -> (String, i32) {
opbrengst (s, n);
}

De tekenreeks_en_geheel getal functie neemt een string en een 32-bits geheel getal op en retourneert ze als een tuple. U kunt slechts één waarde uit een Rust-functie retourneren.

Je kunt de opbrengst sleutelwoord bij het retourneren van de laatste uitdrukking van een functie, om de code beknopter te maken.

fn string_and_integer (s: String, n: i32) -> (String, i32) {
opbrengst (s, n);
}
// de functies zijn equivalent
fn str_and_int (s: String, n: i32) -> (String, i32) {
 (s, n)
}

Deze twee functies gedragen zich hetzelfde omdat ze allebei een string en een geheel getal opnemen en die argumenten als een tuple retourneren.

Roestfuncties aanroepen

U kunt een functie vanuit een andere aanroepen door de naam ervan te schrijven, gevolgd door de waarden die u eraan wilt doorgeven tussen haakjes:

fn add_numbers (x: i32, y: i32) -> i32 {
 x + y
}
fn hoofd() {
 laat resultaat = add_numbers(3, 5);
println!("Het resultaat is {}", resultaat); // Uitvoer: het resultaat is 8
}

De voornaamst functie oproepen voeg_nummers toe, twee gehele getallen doorgeven. Het wijst het resultaat van de functie toe aan een variabele, resultaat.

U kunt functies declareren voor roeststructuren

U kunt functies declareren binnen Rust structs. Dit worden methoden voor de structuur die deze kan openen en wijzigen.

Rust is niet puur objectgeoriënteerd, maar biedt structuren om gerelateerde gegevens te groeperen. U kunt werken aan het implementeren van OOP-concepten in Rust met behulp van structs met methoden.