Organización de proyectos de Rust con paquetes, rutas y módulos

Rust es una excelente opción para crear aplicaciones complejas y confiables. Una de las habilidades esenciales para desarrollar aplicaciones Rust es estructurar sus proyectos de manera efectiva, incluida la incorporación de paquetes de terceros.

La organización efectiva del proyecto es crucial para desarrollar aplicaciones de Rust. Las aplicaciones de Rust bien estructuradas mejoran la colaboración y facilitan las integraciones de aplicaciones de terceros, lo que reduce significativamente el tiempo y el esfuerzo necesarios para el desarrollo de aplicaciones. Rust proporciona un administrador de paquetes incorporado y otras herramientas para una organización y administración de código efectivas.

Configuración de proyectos de Rust

Configurar proyectos Rust es fácil una vez que haya instalado Rust en su máquina; puede usar Cargo (el administrador de paquetes y el sistema de compilación integrados de Rust) para crear y configurar un proyecto de Rust. Es similar a otros administradores de paquetes como

npm para Node.js y pipa para Python. Cargo administra dependencias, compila código y genera documentación, lo que lo convierte en una herramienta esencial para el desarrollo de Rust.

Ejecute este comando para verificar su instalación de Cargo:

carga --versión

El comando muestra la versión Cargo instalada.

Puede crear un nuevo proyecto de Rust con el carga nueva dominio. Deberá especificar el nombre del proyecto.

carga nueva mi_proyecto

El comando creará un nuevo directorio en el directorio actual que contiene los archivos básicos que necesita para su proyecto Rust, incluido un carga.toml archivo para administrar las dependencias de su proyecto.

El espacio de nombres del paquete Rust

Los paquetes y cajas son componentes esenciales en Rust. Las cajas son bibliotecas o archivos binarios que los desarrolladores de Rust pueden usar y compilar para algún uso específico, y los paquetes son una colección de cajas. Los paquetes generalmente contienen una caja que contiene el código reutilizable y un binario que proporciona una CLI para la caja de la biblioteca.

Las cajas deben contener el Cargo.toml archivo que contiene metadatos sobre el paquete, como su nombre, versión, dependencias y scripts de compilación.

Los paquetes de Rust siguen una convención de nomenclatura para evitar conflictos de nomenclatura entre paquetes. Los nombres de los paquetes deben ser únicos en todo el mundo, estar en minúsculas y contener solo letras, dígitos y guiones. Si el nombre de un paquete contiene varias palabras, sepárelas con guiones, p. hiperservidor.

Puede acceder al código dentro de un espacio de nombres de paquete de Rust con el usar palabra clave seguida de los nombres del paquete y la caja.

Este es un ejemplo de cómo importar un timbre función de un rand caja:

usar rand:: Rng;

Puede crear varios espacios de nombres para paquetes. Cuando crea una carpeta, crea un nuevo espacio de nombres al que puede acceder con la notación de puntos para especificar la ruta al identificador.

En Rust, puede haber múltiples espacios de nombres para paquetes. Cuando crea una carpeta, crea un nuevo espacio de nombres. Para acceder al código desde otro espacio de nombres, utiliza una notación de puntos para especificar la ruta al identificador.

Aquí hay un ejemplo de cómo acceder a una función desde un espacio de nombres diferente:

// archivo en el espacio de nombres carpeta1
pubfncarpeta() -> u32 {
// algún cuerpo de función aquí
devolver0;
}
// archivo en el espacio de nombres carpeta2
usar carpeta1::carpeta;
pubfndirectorio() {
// accediendo a la función de carpeta desde el espacio de nombres folder1
dejar carpeta_func = carpeta();
}

El programa define dos módulos de Rust en diferentes espacios de nombres, carpeta1 y carpeta2 respectivamente. El carpeta1 módulo contiene una función pública carpeta que devuelve un valor entero sin signo de 32 bits.

El carpeta2 módulo importa el carpeta función de la carpeta1 espacio de nombres con el usar palabra clave, lo que permite la directorio función para acceder a la carpeta función de la carpeta1 módulo. El directorio función llama a la carpeta función, y el valor de retorno se asigna a la función_carpeta variable.

Deberá escribir en mayúscula el nombre de los identificadores de un paquete o caja para exportarlos. Cuando exporta un identificador, lo hace accesible en otros paquetes que usan el código.

Este es un ejemplo de una función pública que se puede exportar.

// función exportada a otros paquetes y cajas
pubfnmi función() {
// algún cuerpo de función aquí
}

También deberá utilizar el pub palabra clave. En óxido, el pub palabra clave es la abreviatura de público. Cuando una función, estructura, enumeración, cualquier tipo de datos de Rust o el módulo está marcado con la palabra clave pub, se vuelve accesible fuera de su módulo. El elemento es privado para su módulo sin la palabra clave pub y solo se puede acceder desde él.

Definición de módulos para controlar el alcance y la privacidad

Puede usar módulos para controlar el alcance y la privacidad en los programas de Rust. Los módulos le permiten organizar el código en unidades lógicas que son más fáciles de administrar y mantener.

Puede declarar módulos con el modificación palabra clave seguida del nombre del módulo y llaves. Definir un nuevo módulo crea un nuevo espacio de nombres para su contenido, lo que significa que funciones, estructuras o otros elementos definidos dentro del módulo solo son accesibles dentro del módulo, excepto que exporte explícitamente a ellos.

Los módulos ayudan a evitar conflictos de nombres, lo que hace que el código sea más intuitivo de entender.

Aquí está la sintaxis para un módulo simple:

modificación mi_módulo {
// el contenido del módulo va aquí
}

Dentro del módulo, puede definir variables, funciones, estructuras, enumeraciones y otros tipos.

modificación mi_módulo {
fnañadir_números(a: i32, b: i32) -> i32 {
 a + b
 }
}

Puedes usar el pub palabra clave para exportar la función y acceder a la función en otras partes del programa.

modificación mi_módulo {
pubfnañadir_números(a: i32, b: i32) -> i32 {
 a + b
 }
}

Ahora, puedes llamar al añadir_números función de otras partes de su programa.

También puede controlar la privacidad de los módulos con el pub palabra clave en definiciones de módulos.

pubmodificación mi_módulo {
pubfnañadir_números(a: i32, b: i32) -> i32 {
 a + b
 }
}

Ahora el mi_módulo El módulo es público y puede acceder al módulo desde otros módulos.

Si necesita hacer que un módulo o elemento sea accesible para un módulo específico o un conjunto de módulos, puede usar el taberna (caja) palabra clave. El taberna (caja) La palabra clave hace que el artículo sea accesible desde módulos dentro de la misma caja pero no desde módulos en otras cajas.

modificación mi_módulo {
pubestructuraMiEstructura {
pub(caja) algún_campo: u32,
 }
}

Ahora puede acceder al elemento específico (en este caso, el algún_campo campo de la MiEstructura struct) en otras partes de su programa.

fnprincipal() {
dejar mi_estructura = mi_módulo:: MiEstructura { algún_campo: 42 };
imprimir!("{}", mi_estructura.algún_campo);
}

El mi_estructura variable es una instancia de la MiEstructura estructura La variable accede a la estructura con el separador de ruta (::). El principal la función imprime el algún_campo campo de la estructura con el imprimir! macro.

El modelo de propiedad de Rust garantiza la seguridad de la memoria

Organizar el código de Rust es una forma de garantizar que su código sea fácil de mantener y admitir a lo largo del tiempo. Es más fácil abordar los errores y garantizar la seguridad en un código bien organizado que sigue las reglas y convenciones de la comunidad de Rust.

De forma predeterminada, Rust garantiza que los programas sean seguros para la memoria con un modelo de propiedad incorporado. El modelo de propiedad garantiza la seguridad de la memoria al garantizar que las variables en la memoria tengan un propietario único. El modelo de propiedad evita el seguimiento de datos y muchos tipos de errores de memoria.