Les funcions són una part fonamental de qualsevol llenguatge de programació, i Rust no és una excepció. En aquest tema, aprendrem com definir i utilitzar funcions en Rust, així com alguns conceptes avançats relacionats amb les funcions.

Continguts

Definició de Funcions

En Rust, les funcions es defineixen amb la paraula clau fn, seguida del nom de la funció, els paràmetres entre parèntesis i el cos de la funció entre claus.

fn main() {
    println!("Hola, món!");
}

Exemple

fn saluda() {
    println!("Hola, món!");
}

fn main() {
    saluda();
}

En aquest exemple, hem definit una funció anomenada saluda que imprimeix "Hola, món!" a la consola. Després, hem cridat aquesta funció des de la funció main.

Paràmetres i Tipus de Retorn

Les funcions poden acceptar paràmetres i retornar valors. Els paràmetres es defineixen dins dels parèntesis després del nom de la funció, i el tipus de retorn es defineix després d'una fletxa (->).

Exemple amb Paràmetres

fn saluda_nom(nom: &str) {
    println!("Hola, {}!", nom);
}

fn main() {
    saluda_nom("Anna");
}

Exemple amb Tipus de Retorn

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

fn main() {
    let resultat = suma(5, 3);
    println!("El resultat és: {}", resultat);
}

En aquest exemple, la funció suma accepta dos paràmetres de tipus i32 i retorna un valor de tipus i32.

Expressions i Sentències

En Rust, les funcions poden contenir expressions i sentències. Una expressió retorna un valor, mentre que una sentència no ho fa.

Exemple d'Expressió

fn suma(a: i32, b: i32) -> i32 {
    a + b // Aquesta és una expressió
}

Exemple de Sentència

fn imprimeix_suma(a: i32, b: i32) {
    let resultat = a + b; // Aquesta és una sentència
    println!("El resultat és: {}", resultat);
}

Funcions Anònimes (Closures)

Les closures són funcions anònimes que poden capturar variables del seu entorn. Es defineixen amb pipes (|) per als paràmetres i una fletxa (->) per al tipus de retorn opcional.

Exemple de Closure

fn main() {
    let suma = |a: i32, b: i32| -> i32 {
        a + b
    };

    let resultat = suma(5, 3);
    println!("El resultat és: {}", resultat);
}

Exercicis Pràctics

Exercici 1: Funció de Multiplicació

Defineix una funció anomenada multiplica que accepti dos paràmetres de tipus i32 i retorni el seu producte.

fn multiplica(a: i32, b: i32) -> i32 {
    // Implementa la funció aquí
}

fn main() {
    let resultat = multiplica(4, 5);
    println!("El resultat és: {}", resultat); // Ha de imprimir "El resultat és: 20"
}

Solució

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

fn main() {
    let resultat = multiplica(4, 5);
    println!("El resultat és: {}", resultat); // Ha de imprimir "El resultat és: 20"
}

Exercici 2: Funció de Salutació Personalitzada

Defineix una funció anomenada saluda_personalitzat que accepti un paràmetre de tipus &str i imprimeixi un missatge de salutació personalitzat.

fn saluda_personalitzat(nom: &str) {
    // Implementa la funció aquí
}

fn main() {
    saluda_personalitzat("Joan"); // Ha de imprimir "Hola, Joan!"
}

Solució

fn saluda_personalitzat(nom: &str) {
    println!("Hola, {}!", nom);
}

fn main() {
    saluda_personalitzat("Joan"); // Ha de imprimir "Hola, Joan!"
}

Conclusió

En aquesta secció, hem après com definir i utilitzar funcions en Rust, incloent-hi paràmetres, tipus de retorn, expressions, sentències i closures. Les funcions són una eina poderosa per organitzar i reutilitzar el codi, i comprendre-les és essencial per a qualsevol programador de Rust. En el següent mòdul, explorarem el flux de control, incloent-hi condicions i bucles.

© Copyright 2024. Tots els drets reservats