Control de flujo de ejecución

Las dos estructuras más importantes para el control del flujo de ejecución son los lazos y la expresión if:

Expresiones if/else

Muy similar a otros lenguajes, se evalúa si es falso o verdadero una expresión. En este caso se evalúa si una variable es menor a 10 o no:

 fn main() {
     let a = 5;
     if a < 10 {
         println!("la expresión es verdadera");
     }else {
         println!("la exprexión es false");
     }
 }

La expresión a evaluar debe ser de tipo bool, de lo contrario producirá un error 308. Sobre comparaciones entre variables, se puede ver acá

El else es opcional, y se pueden colocar varias expresiones if/else en cascada:

 fn main() {
     let a = 5;
     if a == 10 {
         println!("la variable es 10");
     }else if a == 4 {
         println!("la variable es 4");
     }else if a == 7 {
         println!("la variable es 7");
     }else {
         println!("la variable no es ni 10, 4 ni 7");
     }
 }

Si debes poner muchos if/else en cascada, lo mejor sería usar un match.

Usando en let

Como el if es una expresión, se puede utilizar en el lado derecho de un let:

 fn main() {
     let a = 5;
     let b = 7;
     let c = if a>b {3} else {1};
     println!("El valor es {}",c);
 }

Al ejecutar este programa, la salida sería "1".

Lazos con loop

El comando loop causa que un bloque de código se repita infinitas veces a menos de que explícitamente se le ordene que termine. Este código nunca terminará:

 fn main() {
     loop {
         println!("hola");
     }
 }

La única forma de que deje de imprimir "hola" es usando Control-C.

Saliendo de un lazo con break

Con break la iteración termina y se sale del lazo.

 fn main() {
     let mut a=0;
     loop {
         a=a+1;
         println!("{}",a);
         if a == 100 {break;}
     }
 }

En este programa, al llegar la impresión a 100, terminará el programa.

Devolviendo un valor

loop ejecuta una expresión varias veces y se puede utilizar el break para devolver un valor, por ejemplo en una asignación:

 fn main() {
     let mut a =0;
     let b= loop {
         a=a+1;
         if a == 100 {
             break a;
        }
     };
     println!("{}",b);
 }

Lazos condicionales con while

Una forma de tener un lazo con un condicional es usar while. El programa anterior modificado sería:

 fn main() {
     let mut a =0;
     while a != 100 {
         a=a+1;
     }
     println!("{}",a);
 }

Lazos con for

Hay varias formas de usar for para crear un lazo con un iterador.

Iterador con ..

Con un iterador a..b, los valores van desde a inclusive hasta b (excluyendolo):

 fn main() {
     for a in 1..10 {
        println!("{}",a);
     }
 }

En este ejemplo, se imprimirán los valores desde 1 hasta 9. En este caso la variable a no necesita ser declarada explícitamente antes.

Si quisiéramos que el iterador fuera desde a hasta b inclusive, podemos poner un = antes de la segunda variable:

 fn main() {
     for a in 1..=10 {
        println!("{}",a);
     }
 }

Iteradoradores

Hay varios iteradores: into_iter, iter y iter_mut.

iter

Toma cada elemento de la colección para cada iteración.