Funciones de Rust

Las funciones son omnipresentes en el lenguaje Rust.

En los capítulos anteriores ya se puede conocer la forma básica de las funciones de Rust:

fn <函数名> ( <参数> ) <函数体>

El estilo de nomenclatura de las funciones de Rust es usar letras minúsculas separadas por guiones bajos:

Ejemplo

fn main() {
println!("Hello, world!");
another_function();
}

fn another_function() {
println!("Hello, ejemplo!");
}

Resultado de ejecución:

Hello, world!
Hello, ejemplo!

Nota: definimos another_function después de la función main en el código fuente. A Rust no le importa dónde definas las funciones, solo necesitas definirlas en algún lugar.

Parámetros de función

En Rust, si una función necesita parámetros, debe declarar el nombre y el tipo de cada parámetro:

Ejemplo

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

Resultado de ejecución:

x 的值为 : 5
y 的值为 : 6

Sentencias y expresiones del cuerpo de la función

El cuerpo de una función de Rust está compuesto por una serie de sentencias (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 usado expresiones como parte de sentencias.

Una sentencia es un paso que realiza cierta operación y no tiene valor de retorno. Por ejemplo:

let a = 6;

Este paso no tiene valor de retorno, por lo que la siguiente sentencia es incorrecta:

let a = (let b = 2);

Una expresión tiene pasos de cálculo y un valor de retorno. Lo siguiente son expresiones (suponiendo que los identificadores que aparecen ya han sido definidos):

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

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

Ejemplo

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

Resultado de ejecución:

x 的值为 : 5
y 的值为 : 4

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

{
    let x = 3;
    x + 1
};

Además, en el bloque se pueden usar sentencias; el último paso es una expresión, y el valor de esta expresión es el valor que representa todo el bloque de expresión. Este tipo de bloque de expresión se denomina expresión de cuerpo de función.

Nota:x + 1Después no debe haber punto y coma; de lo contrario, se convertirá en una sentencia.

Este bloque de expresión es un cuerpo de función válido. Además, en Rust, las definiciones de funciones se pueden anidar:

Ejemplo

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

Valores de retorno de la función

En el ejemplo anidado anterior ya se mostró la forma en que Rust declara el tipo de valor de retorno: después de declarar los parámetros, se usa->para declarar el tipo de valor de retorno de la función (no: ）。

En el cuerpo de la función, se puede usar la palabra clave `return` en cualquier momento para finalizar la ejecución de la función y devolver un valor del tipo adecuado. Esta es también la práctica más cercana a la experiencia de la mayoría de los desarrolladores:

Ejemplo

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

Pero Rust no admite la inferencia automática del tipo de valor de retorno. Si no se declara explícitamente el tipo de valor de retorno, se considera que la función es un "procedimiento puro" y no se permite generar un valor de retorno; después de `return` no puede haber una expresión de valor de retorno. El propósito de esto es que las funciones públicas puedan formar un contrato visible.

Nota:La expresión de cuerpo de función no es equivalente al cuerpo de la función; no puede usarreturnla palabra clave.

Otras extensiones