Estructuras de control de óxido y cómo usarlas

Las estructuras de control son una construcción de programación que le permite controlar el flujo de ejecución en sus programas. Las estructuras de control le permiten especificar instrucciones para ejecutar solo si se cumplen ciertas condiciones.

Las estructuras de control de Rust son cruciales para administrar el flujo del programa, lo que permite una ejecución eficiente del código y simplifica tareas complejas en componentes más pequeños y reutilizables.

Declaraciones condicionales de óxido

Las declaraciones condicionales son construcciones que le permiten ejecutar código en función de las condiciones. Las declaraciones condicionales son útiles para la toma de decisiones, ya que la ejecución del programa depende de si la condición se evalúa como verdadero o FALSO. El óxido proporciona si, demás, y fósforo declaraciones para la toma de decisiones.

En los programas de Rust, el si declaración prueba si una determinada condición se evalúa como verdadera. Si lo hace, el programa ejecuta el bloque de código asociado. Si la condición se evalúa como falsa, el programa omite ese bloque de código y pasa a la siguiente declaración o ejecuta el

demás bloque de declaraciones si hay alguno.

El fósforo es una poderosa construcción de flujo de control que permite que un programa haga coincidir valores con una serie de patrones y ejecute código basado en el patrón coincidente.

Declaraciones if de Rust

declararás si declaraciones en sus programas de Rust con el si palabra clave seguida de una condición:

si condición {
// código a ejecutar si la condición es verdadera
}

Aquí hay un ejemplo de cómo puede usar una declaración if en sus programas Rust:

fnprincipal() {
dejar x = 15;
si X > 10 {
imprimir!("x es mayor que 10");
 }
}

El X La variable contiene un entero de 32 bits, y la declaración if verifica si el valor de x es mayor que diez antes de ejecutar el bloque de código que lo imprime.

Declaraciones else de Rust

Usarás el demás palabra clave para ejecutar un bloque de código cuando anticipa que un si declaración se evaluaría como falsa.

si condición {
// código a ejecutar si la condición es verdadera
} demás {
// código a ejecutar si la condición es falsa
}

He aquí un ejemplo donde X no es mayor que 10, el si declaración evalúa FALSO, y un demás se ejecuta la declaración.

fnprincipal(){
dejar x = 5;
si X > 10 {
imprimir!("x es mayor que 10");
 } demás {
imprimir!("x no es mayor que 10");
 }
}

Desde X es 5 y 5 no es mayor que 10, el programa salta el si bloquea y ejecuta el demás bloquear.

Declaraciones de coincidencia de Rust

Usarás el fósforo palabra clave para la toma de decisiones complejas para verificar una serie de patrones y ejecutar código basado en coincidencias de patrones. Las declaraciones de coincidencia son similares a cambiar declaraciones en C#, Ir y C++.

Aquí está la estructura de una declaración de coincidencia de Rust:

fósforo valor {
 patrón1 => {
// código a ejecutar si el valor coincide con patrón1
 },
 patrón2 => {
// código a ejecutar si el valor coincide con el patrón2
 },
// etc.
}

Así es como puede usar sentencias de coincidencia en sus programas:

dejar grado = 'B';
fósforo calificación {
'A' => imprimir!("¡Excelente trabajo!"),
'B' => imprimir!("Buen trabajo."),
'C' => imprimir!("Podrias hacerlo mejor."),
 _ => imprimir!("Esa no es una calificación válida".),
}

El calificación variable es un caracter, y el fósforo La instrucción comprueba cuál de los caracteres se evalúa como el valor de la variable de calificación antes de ejecutar el código después del operador =>. Puede utilizar el patrón de guión bajo (_) para hacer coincidir valores que no coinciden con otros patrones (el patrón predeterminado).

Bucles en óxido

Los bucles son una construcción fundamental utilizada para tareas repetitivas como raspado web y otras acciones automatizadas. Rust proporciona diferentes tipos de bucles, incluidos mientras bucles, para bucles, y el bucle bucle.

Bucles while de Rust

Los bucles while repiten un bloque de código siempre que una condición específica se evalúe como verdadera. Antes de especificar la condición, especificará los bucles while en Rust con el mientras palabra clave.

mientras condición {
// codigo a ejecutar
}

La condición debe ser una expresión booleana que determine la continuación del ciclo. Cuando la condición se evalúa como falsa, el ciclo sale.

Aquí hay un ejemplo de un bucle while de Rust que imprime números del uno al cinco.

fnprincipal() {
dejarmudo yo = 1;
mientras yo <= 5 {
imprimir!("{}", i);
 yo += 1;
 }
}

El ciclo while en el principal La función recorre los números del uno al cinco mientras incrementa el i variable por uno hasta i variable es mayor que cinco, donde termina el bucle.

El bucle Bucle

El bucle palabra clave crea un bucle infinito hasta que indique una salida con el romper palabra clave.

bucle {
// codigo a ejecutar
si condición {
romper;
 }
}

El código en el bucle el bloque seguirá ejecutándose hasta que el ciclo encuentre un romper palabra clave.

He aquí un ejemplo del uso de la bucle bucle para imprimir los números del uno al cinco antes de especificar el romper palabra clave para la salida.

fnprincipal() {
dejarmudo yo = 1;
bucle {
imprimir!("{}", i);
 yo += 1;
si yo > 5 {
romper;
 }
 }
}

El principal La función ejecuta el ciclo, y el si declaración incrementa el i variable. El si instrucción especifica la terminación del ciclo cuando el i variable excede cinco.

Rust para bucles

En Rust, los bucles for iteran a través de un rango o una colección de valores. Usarás el para palabra clave para iniciar un bucle for, antes de especificar el rango o la colección sobre la que actúa.

para variable en rango {
// codigo a ejecutar
}

El rango es una expresión que se evalúa como una secuencia de valores, y la variable es una variable que toma cada valor en la secuencia a su vez. El bloque de código se ejecutará una vez para cada valor en la secuencia.

Aquí hay un ejemplo de un bucle for que imprime valores que van del uno al diez.

fnprincipal() {
para i en1..=10 {
imprimir!("{}", i);
 }
}

El ciclo itera a través de los valores del 1 al 10. En cada iteración, la variable (i) tiene el siguiente valor, que el imprimir! macro luego se imprime.

Puedes usar el continuar palabra clave para omitir valores en bucles for. Así es como puede omitir los números pares cuando opera en un rango:

fnprincipal() {
para número en1..=10 {
si número % 2 == 0 {
continuar; // saltar números pares
 }
imprimir!("{}", número); // imprime numeros impares
 }
}

El si declaración utiliza el continuar palabra clave para especificar que el ciclo debe omitir números divisibles por dos.

Además, puede salir de un bucle for con el romper palabra clave. El bucle termina al encontrar el romper palabra clave.

fnprincipal() {
para número en1..=10 {
si número == 5 {
romper; // sale del bucle cuando el número es igual a 5
 }
imprimir!("{}", número); // imprime los números del 1 al 4
 }
}

El si sentencia especifica que el bucle debe terminar cuando el i variable es igual a cinco.

Use las estructuras de control de Rust con tipos de datos para dominar el lenguaje

Rust proporciona estas estructuras de control flexibles para operaciones en tipos de datos integrados y personalizados. Puede usar estas estructuras de control para operar en estructuras de datos compuestas y compuestas como matrices, vectores, estructuras y enumeraciones.

Rust también proporciona estructuras. Las estructuras son estructuras de datos que agrupan valores relacionados en un solo objeto. Son similares a las clases en los lenguajes orientados a objetos, e incluso puedes definir métodos en ellas.