Cargo es el sistema de construcción y administrador de paquetes de Rust. La mayoría de los Rustaceanos usan esta herramienta para administrar sus proyectos de Rust porque Cargo maneja muchas tareas, como compilar el código, descargar dependencias y construir esas dependencias.
Los programas Rust más simples, como el que hemos escrito hasta ahora, no tienen dependencias. Entonces, si hubiéramos construido Hello, world! proyecto con Cargo, solo usaría la parte de Cargo que maneja la compilación. A medida que escriba programas Rust más complejos, agregará dependencias, y si comienza un proyecto con Cargo, será mucho más fácil agregar dependencias.
Cargo viene instalado con Rust podemos verificar si Cargo está instalado escribiendo lo siguiente en la terminal:
$ cargo --version
Si ve un número de versión, ¡lo tiene! Si ve un error, como “command not found”, consulte la documentación de su método de instalación para determinar cómo instalar Cargo por separado.
Creemos un nuevo proyecto con Cargo y veamos cómo se diferencia de nuestro Hello, world original. Vamos a la carpeta donde pondremos el código. Luego, ejecutamos lo siguiente:
$ cargo new hello_cargo
$ cd hello_cargo
El primer comando crea un nuevo directorio llamado hello_cargo. Hemos llamado a nuestro proyecto hello_cargo, y Cargo crea sus archivos en un directorio del mismo nombre.
Con "cd hello_cargo" nos hubicamos en el directorio hello_cargo y si ejecutamos ls podremos ver los archivos. Cargo ha generado dos archivos y un directorio: un archivo Cargo.toml y un directorio src con un archivo main.rs dentro. También ha inicializado un nuevo repositorio de Git junto con un archivo .gitignore.
Si abrimos Cargo.toml con un editor de texto. Debería verse algo así :
[package]
name = "hello_cargo"
version = "0.1.0"
authors = ["Your Name <you@example.com>"]
edition = "2018"
[dependencies]
Este archivo está en el formato TOML (Tom's Obvious, Minimal Language), que es el formato de configuración de Cargo.
La primera línea, [paquete], es un encabezado de sección que indica que las siguientes declaraciones están configurando un paquete. A medida que agreguemos más información a este archivo, agregaremos otras secciones.
Las siguientes cuatro líneas establecen la información de configuración que Cargo necesita para compilar su programa: el nombre, la versión, quién lo escribió y la edición de Rust para usar. Cargo obtiene su nombre e información de correo electrónico de su entorno, por lo que si esa información no es correcta, se puede correjir y guarde el archivo.
La última línea, [dependencias], es el comienzo de una sección de dependencias del proyecto. En Rust, los paquetes de código se denominan cajas. No necesitaremos ninguna otra caja para este proyecto, por lo que no usaremos esta sección de dependencias.
Ahora abra src / main.rs y veremos lo siguiente:
fn main() {
println!("Hello, world!");
}
Cargo ha generado un Hola, mundo! programa similar al post anterior. Hasta ahora, las diferencias entre nuestro proyecto anterior y el proyecto que genera Cargo son que Cargo colocó el código en el directorio src, y tenemos un archivo de configuración Cargo.toml en el directorio superior.
Cargo espera que sus archivos de origen vivan dentro del directorio src. El directorio de proyectos de nivel superior es solo para archivos README, información de licencia, archivos de configuración y cualquier otra cosa que no esté relacionada con su código. Usar Cargo te ayuda a organizar tus proyectos. Hay un lugar para todo, y todo está en su lugar.
Si comenzó un proyecto que no usa Cargo, como hicimos con Hello, world! proyecto, puede convertirlo en un proyecto que use Cargo. Lo que tenemos que hacer es mover el código del proyecto al directorio src y crear un archivo Cargo.toml apropiado.
Desde el directorio hello_cargo, compilaremos el proyecto ingresando el siguiente comando:
$ cargo build
Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
Finished dev [unoptimized + debuginfo] target(s) in 2.85 secs
Este comando crea un archivo ejecutable en target/debug/hello_cargo (o target \debug\hello_cargo.exe en Windows) y luego podemos ejecurar dicho programa.
$ ./target/debug/hello_cargo
Hello, world!
Si todo va bien, "Hello, world!" debe ser impreso en la terminal. La ejecución de la construcción por primera vez también hace que Cargo cree un nuevo archivo en el nivel superior: Cargo.lock. Este archivo realiza un seguimiento de las versiones exactas de las dependencias en su proyecto. Este proyecto no tiene dependencias, por lo que el archivo va a estar vacio. Nunca necesitará cambiar este archivo manualmente; Cargo gestiona sus contenidos.
Acabamos de construir un proyecto con Cargo Build y lo ejecutamos con ./target/debug/hello_cargo, pero también podemos usar "Cargo Run" para compilar el código y luego ejecutarlo :
$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
Running `target/debug/hello_cargo`
Hello, world!
Tenga en cuenta que esta vez no hemos visto resultados que indiquen que Cargo estaba compilando hello_cargo. Cargo descubrió que los archivos no habían cambiado, por lo que simplemente ejecutó el binario. Si hubiera modificado su código fuente, Cargo habría reconstruido el proyecto antes de ejecutarlo, y habría visto este resultado:
$ cargo run
Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
Finished dev [unoptimized + debuginfo] target(s) in 0.33 secs
Running `target/debug/hello_cargo`
Hello, world!
"cargo check" verifica rápidamente su código para asegurarse de que se compila pero no produce un ejecutable:
$ cargo check
Checking hello_cargo v0.1.0 (file:///projects/hello_cargo)
Finished dev [unoptimized + debuginfo] target(s) in 0.32 secs
¿Por qué no querrías un ejecutable? A menudo, la verificación de Cargo es mucho más rápida que la compilación, ya que omite el paso de producir un ejecutable. Si continuamente revisas tu trabajo mientras escribes el código, ¡usar el control de carga acelerará el proceso! Como tal, muchos Rustaceanos realizan controles de Cargo periódicamente mientras escriben su programa para asegurarse de que se compila. Luego ejecutan la construcción de carga cuando están listos para usar el ejecutable.
Recapitulemos lo que hemos aprendido hasta ahora sobre Cargo:
- Podemos construir un proyecto utilizando "cargo build" o "cargo check".
- Podemos construir y ejecutar un proyecto en un solo paso utilizando "cargo run".
- En lugar de guardar el resultado de la compilación en el mismo directorio que nuestro código, Cargo lo almacena en el directorio de /target/debug.
Una ventaja adicional de usar Cargo es que los comandos son los mismos sin importar en qué sistema operativo esté trabajando.
Cuando su proyecto finalmente esté listo para su lanzamiento, puede usar la construcción Cargo de tipo release para compilarlo con optimizaciones. Este comando creará un ejecutable en target/release en lugar de target/debug. Las optimizaciones hacen que su código Rust se ejecute más rápido, pero activarlas alarga el tiempo que tarda su programa en compilarse. Es por eso que hay dos perfiles diferentes: uno para el desarrollo, cuando desea reconstruir rápida y frecuentemente, y otro para construir el programa final que le dará a un usuario que no se reconstruirá repetidamente y que se ejecutará tan rápido como posible.
Con proyectos simples, Cargo no proporciona mucho valor con solo usar rustc, pero demostrará su valor a medida que sus programas se vuelvan más complejos. Con proyectos complejos compuestos de múltiples cajas, es mucho más fácil dejar que Cargo coordine la construcción.
Aunque el proyecto hello_cargo es simple, ahora utilizamos gran parte de las herramientas reales que usará en el resto de su carrera en Rust. De hecho, para trabajar en cualquier proyecto existente, puede usar los siguientes comandos para verificar el código usando Git, cambiar al directorio de ese proyecto y compilar:
$ git clone someurl.com/someproject
$ cd someproject
$ cargo buildm
Y por este post, demasiado...
Dejo link:
https://doc.rust-lang.org/book
