Introducción
Los programas de Rust suelen organizarse y ejecutarse con Cargo, la herramienta de Rust para proyectos y compilaciones. En este laboratorio, completará un pequeño proyecto de Cargo en un terminal de Linux. No necesita experiencia previa con terminales, editores ni Rust.
Aprenderá a entrar en una carpeta de proyecto, editar un archivo de código fuente de Rust con nano, pedirle a Cargo que compruebe el código y ejecutar el programa terminado. El laboratorio comprueba tanto el código fuente como la salida exacta del programa.
Entre en el proyecto y edite su código fuente
En este paso, localizará el proyecto preparado y hará su primera modificación pequeña en Rust con nano.
El terminal es el área de texto donde escribe comandos. Un comando es una instrucción para el equipo. Haga clic primero dentro del terminal para activarlo, escriba el siguiente comando y pulse Enter:
pwd
pwd significa print working directory (mostrar el directorio de trabajo). Directorio es otra forma de decir carpeta. La salida muestra la carpeta en la que se encuentra actualmente, normalmente /home/labex.
A continuación, muestre los elementos de esa carpeta:
ls
ls significa list (listar). Debería ver una carpeta llamada project.
Use cd, que significa change directory (cambiar de directorio), para entrar en el proyecto de Rust preparado. La ruta comienza con /, por lo que es una ruta absoluta: indica la ubicación desde la parte superior del sistema de archivos, en lugar de hacerlo desde el directorio actual.
cd /home/labex/project/hello-rust
Normalmente, el terminal no muestra nada cuando cd se ejecuta correctamente. Muestre el contenido del proyecto:
ls
Debería ver Cargo.toml y src. Cargo lee Cargo.toml para conocer el nombre del paquete, la versión, la edición de Rust y las dependencias. El directorio src contiene el código fuente de Rust; este programa comienza en src/main.rs.
Abra el archivo de código fuente en nano, un editor de texto para terminales adecuado para principiantes:
nano src/main.rs
src/main.rs es una ruta relativa. Como no comienza con /, el terminal busca el archivo dentro del directorio actual, /home/labex/project/hello-rust. Por eso es importante entrar primero en el proyecto con cd.
El archivo aparecerá dentro del terminal. Use las teclas de flecha para mover el cursor. Cambie únicamente los cinco caracteres de subrayado para que la línea quede así:
println!("Hello from LabEx!");
En la parte inferior de nano, el símbolo ^ representa la tecla Ctrl. Guarde el archivo con Ctrl+O (mantenga pulsada la tecla Ctrl y pulse O) y, después, pulse Enter para confirmar el nombre del archivo. Salga con Ctrl+X.
Vuelva a abrir el mismo archivo para comprobar que el guardado escribió el cambio en el disco:
nano src/main.rs
Confirme que la línea contiene Hello from LabEx!. No necesita editarla de nuevo; salga con Ctrl+X. Volver a abrir un archivo guardado es una comprobación útil cuando no está seguro de si el cambio realizado en el editor se conservó.
Muestre el archivo guardado sin volver a abrir el editor:
cat src/main.rs
cat muestra el contenido de un archivo en el terminal. A diferencia de nano, solo muestra el archivo y no proporciona una pantalla de edición. Confirme que ve Hello from LabEx! y que no hay subrayados dentro del mensaje.
Añada un mensaje y compruebe el código
En este paso, comprenderá el pequeño programa, añadirá una línea y permitirá que Cargo compruebe si contiene errores.
El terminal debería seguir situado en /home/labex/project/hello-rust. Si no está seguro, pwd muestra el directorio actual. Vuelva a abrir el archivo de código fuente:
nano src/main.rs
El programa contiene varios elementos importantes de Rust:
fn main()define la función principal, donde comienza este programa.- Las llaves de apertura y cierre,
{y}, rodean las instrucciones de la función. println!muestra una línea de texto. El signo!indica queprintln!es una macro de Rust.- El texto situado entre comillas dobles es un literal de cadena.
- El punto y coma
;termina esta instrucción.
Mueva el cursor hasta el final de la línea existente con println!, pulse Enter y añada esta segunda instrucción antes de la llave de cierre:
println!("I am learning Rust with Cargo.");
El archivo completo debería quedar así:
fn main() {
println!("Hello from LabEx!");
println!("I am learning Rust with Cargo.");
}
Guarde el archivo con Ctrl+O, pulse Enter y salga con Ctrl+X.
Ahora pida a Cargo que compruebe si el paquete puede compilarse:
cargo check
cargo check analiza el código e informa de los errores sin producir el programa ejecutable final. La primera comprobación puede tardar un momento. Si el resultado es correcto, termina con una línea que contiene Finished.
Si Cargo informa de un error, compare su archivo con el ejemplo completo. Preste especial atención a las comillas, los paréntesis, los puntos y coma y las llaves. Use nano src/main.rs para corregir el archivo, guárdelo y vuelva a ejecutar cargo check.
Ejecute el programa con Cargo
En este paso, compilará y ejecutará el programa de Rust que ya ha comprobado.
Ejecute el siguiente comando desde /home/labex/project/hello-rust:
cargo run
cargo run realiza dos tareas relacionadas: compila el paquete para crear un programa ejecutable y, después, inicia ese programa. Cargo puede mostrar algunas líneas sobre el estado de la compilación antes de mostrar la salida del programa.
Cerca del final, debería ver estas dos líneas:
Hello from LabEx!
I am learning Rust with Cargo.
Vuelva a ejecutar el programa ocultando los mensajes de estado de Cargo:
cargo run --quiet
La opción --quiet reduce la salida propia de Cargo, por lo que solo deberían aparecer las dos líneas de su programa. Ahora ha completado el flujo de trabajo básico de Cargo: editar, comprobar y ejecutar.
Resumen
Se desplazó por un terminal de Linux, editó y guardó código de Rust con nano, reconoció la función principal y la macro println!, comprobó un paquete de Cargo y lo ejecutó. El ciclo de editar, comprobar y ejecutar que practicó es la base de los siguientes proyectos de Rust.
