Funciones en Rust

Las funciones son comunes en el lenguaje Rust.

A través de los capítulos anteriores, ya podemos entender la forma básica de las funciones en Rust:

fn <nombre_de_función> ( <parámetros> ) <cuerpo_de_función>

En Rust, el estilo de nombramiento de los nombres de las funciones es en minúsculas con guiones bajos:

fn　main()　{
　　　　println!("¡Hola, mundo!");
　　　　another_function();
}
fn another_function() {
　　　　println!("¡Hola, w3codebox!);
}

Resultados de ejecución:

¡Hola, mundo!
¡Hola, w3codebox!

Tenga en cuenta que definimos another_function después de la función main en el código fuente. Rust no le importa dónde defina las funciones, siempre y cuando las defina en algún lugar.

Parámetros de la función

En Rust, al definir una función que necesite parámetros, debe declarar el nombre y el tipo de los parámetros:

fn　main()　{
　　　　another_function(5,　6;
}
fn another_function(x: i32, y: i32) {
　　　　println!("El valor de x es: {}", x);
　　　　println!("El valor de y es: {}", y);
}

Resultados de ejecución:

El valor de x es:　5
El valor de y es:　6

Instrucciones y expresiones del cuerpo de la función

El cuerpo de la función Rust se compone de una serie de instrucciones (Statement) que pueden terminar con una expresión (Expression). Hasta ahora, solo hemos visto funciones que no terminan con una expresión, pero ya hemos utilizado expresiones como parte de las instrucciones.

Las instrucciones son pasos que ejecutan ciertas operaciones sin tener un valor de retorno. Por ejemplo:

let a =　6;

Este paso no tiene valor de retorno, por lo que la siguiente instrucción no es correcta:

let a = (let b =　2;

La expresión tiene pasos de cálculo y un valor de retorno. A continuación se muestra la expresión (asumiendo que los identificadores que aparecen ya han sido definidos):

a　=　7
b　+　2
c　*　(a　+　b)

En Rust se puede escribir una expresión más compleja dentro de un bloque delimitado por {}

fn　main()　{
　　　　let　x　=　5;
　　　　let　y　=
　　　　　　　　let　x　=　3;
　　　　　　　　x　+　1
　　　　};
　　　　println!("El valor de x es: {}", x);
　　　　println!("El valor de y es: {}", y);
}

Resultados de ejecución:

El valor de x es:　5
El valor de y es:　4

Es evidente que en este programa hay un bloque de expresión:

{
　　　　let　x　=　3;
　　　　x　+　1
};

Además, se pueden usar expresiones de función dentro del bloque, y el último paso es una expresión, el valor de esta expresión es el valor del bloque de expresiones completo. Este bloque de expresión se llama expresión de cuerpo de función.

Nota: x + 1 ¡No hay punto y coma después de esto, de lo contrario se convertirá en una declaración!

Este bloque de expresión es un cuerpo de función válido. Además, en Rust, la definición de función puede estar anidad:

fn　main()　{
　　　　fn　five()　->　i32　{
　　　　　　　　5
　　　　}
　　　　println!("El valor de five() es: {}", five());
}

Valor de retorno de la función

En el ejemplo de nivel superior ya se ha mostrado cómo declarar el tipo de retorno de la función en Rust: después de la declaración de parámetros usando -> para declarar el tipo de retorno de la función (no : ).

En el cuerpo de la función, se puede finalizar la ejecución de la función en cualquier momento utilizando la palabra clave return y devolver un valor adecuado de tipo. Esto es lo más cercano a la práctica de la mayoría de los desarrolladores:

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

Pero Rust no admite la determinación automática del tipo de retorno de valores! Si no se declara explícitamente el tipo de retorno de la función, la función se considerará "procedural pura", no se permite la generación de valores de retorno, no se puede tener una expresión de retorno después de return. El objetivo de esto es que las funciones públicas puedan formar un informe visible.

Nota:La expresión del cuerpo de la función no es equivalente al cuerpo de la función, no puede usar return Palabras clave.