Todo lo que necesitas saber para empezar a escribir Rust

Desde su lanzamiento en 2015, Rust ha ganado popularidad como uno de los lenguajes de programación favoritos de los desarrolladores. Rust ofrece excelentes funciones de rendimiento y seguridad con una sintaxis intuitiva y concisa que hace que el lenguaje sea deseable.

Rust es adecuado para crear varios programas, incluidas aplicaciones web, herramientas de línea de comandos y servicios de red. Rust incluye muchas funciones que esperará de un lenguaje de programación moderno, como simultaneidad, inferencia de tipos y más.

Comenzando con el óxido

Rust es un lenguaje de programación multiplataforma que se ejecuta en la mayoría de los sistemas operativos. Para comenzar con Rust, diríjase al oficial sitio web de óxido e instale la versión preferida para su sistema operativo.

Una vez que haya instalado Rust, puede comenzar a escribir programas en archivos Rust con un

.rs extensión. Rust es versátil y fácil de aprender. Lo encontrará sencillo si tiene experiencia previa en programación.

Variables y constantes en Rust

Rust es muy expresivo y hay múltiples formas de declarar variables. Puedes usar el dejar palabra clave para declarar variables.

Así es como puede declarar variables en Rust:

dejar a: Cadena;
dejar b: i32;
dejar c: () = ();

El a y b las variables son una cadena y un entero, respectivamente. El C variable es un tipo de unidad de Rust que actúa como marcador de posición para funciones y expresiones.

Después de la declaración de tipo de datos opcional, puede declarar e inicializar variables con valores usando un signo igual.

fnprincipal(){
dejar edad: Cadena = Cadena::de("cinco años de edad");
dejar edad = 5; // equivalente a let age: i32 = 5;
imprimir!("{}", edad);
}

El programa declara dos edad variables antes de imprimir con el imprimir! macro. La primera edad variable especifica el tipo de datos, y la segunda no.

No tiene que especificar el tipo de datos de una variable cuando la declara. El compilador de Rust infiere el tipo del tipo de datos del valor en el momento de la compilación.

También puede declarar constantes en Rust con el constante palabra clave de manera similar a la declaración de variables:

constante edad: &calle = "cinco años de edad";

No puede modificar el valor de una variable que declara como constante.

Rust proporciona funcionalidad para comentarios de una sola línea y de bloque. Puede utilizar barras diagonales dobles (//) para comentarios de una sola línea:

fnprincipal() {
// Este es un comentario de línea
dejar x = 5; // Este comentario explica el propósito de la variable `x`
}

Para comentarios de varias líneas (comentarios de bloque), use una barra inclinada seguida de un asterisco (/*) y cierre el bloque con un asterisco seguido de una barra diagonal (*/):

fnprincipal() {
/*
 Este es un comentario de bloque que abarca varias líneas.
 A menudo se usa para describir un bloque de código más grande.
 */
dejar x = 5;
}

Sus comentarios deben ser concisos y directos.

Matrices en Rust

Las matrices son una colección de tamaño fijo de elementos del mismo tipo de datos. Rust asigna matrices en la pila de forma predeterminada.

Así es como puede declarar matrices en Rust:

fnprincipal() {
dejar números = [1, 2, 3, 4, 5];
}

El números matriz contiene cinco elementos. Puede acceder al valor en una ubicación en una matriz usando su índice:

fnprincipal() {
dejar números = [1, 2, 3, 4, 5];
dejar x = numeros[3];
imprimir!("{}", X)
}

El principal la función imprime el X variable que accede al cuarto elemento del arreglo.

Vectores en Rust

Rust proporciona vectores para cubrir las limitaciones de la matriz. Los vectores tienen un tamaño dinámico; pueden crecer y encogerse según sea necesario.

Así es como puede declarar vectores en Rust:

fnprincipal() {
dejar mi_vec: Vec<i32> = vec![1, 2, 3, 4, 5];
dejar x = mi_vec[3];
imprimir!("{}", X)
}

El mi_vec vector es un vector de enteros de 32 bits. El X variable accede al cuarto elemento del vector, y el principal La función imprime el valor en la consola.

Declaraciones condicionales de Rust

Las declaraciones condicionales son una de Estructuras de control de Rust para la toma de decisiones en los programas. Puedes usar el si y demás palabras clave para manejar decisiones en sus programas.

Aquí hay un si instrucción que imprime una cadena en la consola basada en la igualdad de dos enteros.

fnprincipal() {
dejar a: i32 = 12;
si un == 12 {
imprimir!("a es igual a doce");
 }
}

El principal La función imprime la cadena con el imprimir! macro ya que la variable es igual a 12.

Puedes usar el demás palabra clave para manejar casos donde el si declaración evalúa falso:

fnprincipal() {
dejar a: i32 = 12;
si un == 123 {
imprimir!("a es igual a doce");
 } demás {
imprimir!("a no es igual a doce");
 }
}

En este ejemplo, el demás se ejecuta porque el valor de a no es igual a 123.

Puede declarar sentencias de coincidencia con el fósforo palabra clave para condicionales complejos:

fnprincipal() {
dejar edad: i32 = 7;
fósforo edad {
1 => imprimir!("uno"),
2 => imprimir!("dos"),
3 => imprimir!("tres"),
 _ => imprimir!("cero"),
 }
}

El principal función coincide con la edad variable a los casos en el fósforo instrucción y ejecuta la expresión que coincide con el valor. El guión bajo (_) es la declaración predeterminada que se ejecuta si hay una coincidencia para el valor.

Bucles en óxido

Rust proporciona bucles para tareas repetitivas. Rust tiene tres tipos principales de bucles: bucle, mientras, y para bucles

El bucle La palabra clave crea un bucle infinito que se ejecuta hasta que encuentra una palabra clave de interrupción:

fnprincipal() {
bucle {
imprimir!("impreso repetidamente hasta que se encuentra la instrucción break".);
romper;
 }
}

El mientras loop es útil cuando desea repetir un bloque de código siempre que una condición se evalúe como verdadera:

fnprincipal() {
dejarmudo contar = 0;
mientras contar < 5 {
imprimir!("La cuenta es {}", contar);
 contar += 1;
 }
}

A para loop es bueno para iterar sobre una colección de elementos, como una matriz:

fnprincipal() {
dejar números = [1, 2, 3, 4, 5];
para artículo en numeros.iter() {
imprimir!("El elemento actual es {}", artículo);
 }
}

Este para el bucle itera a través del números array e imprime cada elemento en la consola.

Declarando y llamando a funciones de Rust

Utilizar el fn palabra clave para declarar una función de Rust, seguido del nombre de la función, una lista de parámetros y un tipo de devolución (si corresponde).

Así es como puede declarar una función con parámetros y un tipo de retorno:

fnagregar(a: i32, b: i32) -> i32 {
devolver a + b;
}

El agregar La función toma dos enteros de 32 bits y devuelve un entero de 32 bits, la suma de los dos parámetros.

Para llamar a una función desde otra parte de su código, simplemente especifique el nombre y los argumentos (si corresponde):

fnprincipal() {
dejar resultado = sumar(2, 3);
imprimir!("2 + 3 = {}", resultado);
}

El resultado variable contiene el resultado de llamar a la agregar función. El principal La función imprime el resultado en la consola usando el imprimir! macro.

Estructuras en Rust

Rust proporciona estructuras para definir tipos de datos personalizados que agrupan valores relacionados. Las estructuras son planos para crear objetos con propiedades específicas.

Así es como puede declarar una estructura:

estructuraPersona {
 nombre: Cadena,
 edad: u32,
 es hombre: bool,
}

El Persona struct tiene tres campos: una cadena, un entero de 32 bits sin signo y un valor booleano.

Después de definir una estructura, puede crear instancias de ella en otras partes de su programa:

fnprincipal() {
dejar persona1 = Persona {
 nombre: Cadena::de("Candace Flynn"),
 edad: 16,
 es hombre: FALSO,
 };
}

El persona1 variable es una instancia de la Persona estructura En la creación de instancias, puede asignar valores a los campos de estructura. Puede crear tantas instancias de una estructura como desee.

Puede implementar conceptos OOP en Rust

Rust es flexible y puede implementar los conceptos de OOP en Rust con estructuras de datos integradas como structs.

Usará estructuras como una alternativa a las clases. Con la estructura de Rust, puede definir un modelo para el tipo e implementar los diferentes conceptos de programación orientada a objetos con las funcionalidades que proporciona Rust en las estructuras.