Introdução
Os programas em Rust normalmente são organizados e executados com o Cargo, a ferramenta de projetos e compilação do Rust. Neste laboratório, você concluirá um pequeno projeto Cargo em um terminal Linux. Não é necessário ter experiência anterior com terminal, editor ou Rust.
Você aprenderá a entrar em uma pasta de projeto, editar um arquivo de código-fonte Rust com o nano, pedir ao Cargo que verifique o código e executar o programa concluído. O laboratório verifica tanto o código-fonte quanto a saída exata do programa.
Entre no projeto e edite o código-fonte
Nesta etapa, você localizará o projeto preparado e fará sua primeira pequena alteração em Rust usando o nano.
O terminal é a área de texto em que você digita comandos. Um comando é uma instrução para o computador. Primeiro, clique dentro do terminal para que ele receba o foco do teclado, digite o comando a seguir e pressione Enter:
pwd
pwd significa print working directory. Um diretório é outro nome para uma pasta. A saída mostra a pasta em que você está no momento, normalmente /home/labex.
Em seguida, liste os itens dessa pasta:
ls
ls significa list. Você deverá ver uma pasta chamada project.
Use cd, que significa change directory, para entrar no projeto Rust preparado. O caminho começa com /, portanto é um caminho absoluto: ele indica a localização a partir do topo do sistema de arquivos, e não a partir do diretório atual.
cd /home/labex/project/hello-rust
Normalmente, o terminal não exibe nada quando cd é executado com sucesso. Liste o conteúdo do projeto:
ls
Você deverá ver Cargo.toml e src. O Cargo lê Cargo.toml para conhecer o nome do pacote, a versão, a edição do Rust e as dependências. O diretório src contém o código-fonte Rust; este programa começa em src/main.rs.
Abra o arquivo de código-fonte no nano, um editor de texto de terminal adequado para iniciantes:
nano src/main.rs
src/main.rs é um caminho relativo. Como ele não começa com /, o terminal procura esse caminho dentro do diretório atual, /home/labex/project/hello-rust. Por isso é importante entrar primeiro no projeto com cd.
O arquivo aparecerá dentro do terminal. Use as teclas de seta para mover o cursor. Altere somente os cinco caracteres de sublinhado para que a linha fique assim:
println!("Hello from LabEx!");
Na parte inferior do nano, o símbolo ^ representa a tecla Ctrl. Salve o arquivo com Ctrl+O (mantenha Ctrl pressionada e pressione O) e pressione Enter para confirmar o nome do arquivo. Saia com Ctrl+X.
Abra novamente o mesmo arquivo para confirmar que o salvamento gravou a alteração no disco:
nano src/main.rs
Confirme que a linha contém Hello from LabEx!. Você não precisa editá-la novamente; saia com Ctrl+X. Reabrir um arquivo salvo é uma verificação útil sempre que você não tiver certeza se uma alteração feita no editor foi preservada.
Exiba o arquivo salvo sem abrir o editor novamente:
cat src/main.rs
cat imprime o conteúdo de um arquivo no terminal. Diferentemente do nano, ele apenas exibe o arquivo e não fornece uma tela de edição. Confirme que você vê Hello from LabEx! e que não há sublinhados dentro da mensagem.
Adicione uma mensagem e verifique o código
Nesta etapa, você entenderá o pequeno programa, adicionará uma linha e deixará o Cargo verificar se há erros.
Seu terminal ainda deve estar em /home/labex/project/hello-rust. Se não tiver certeza, pwd mostra o diretório atual. Abra novamente o arquivo de código-fonte:
nano src/main.rs
O programa contém alguns elementos importantes do Rust:
fn main()define a função principal, onde este programa começa.- As chaves de abertura e fechamento,
{e}, delimitam as instruções da função. println!exibe uma linha de texto. O!indica queprintln!é uma macro do Rust.- O texto entre aspas duplas é um literal de string.
- O ponto e vírgula
;encerra esta instrução.
Mova o cursor até o final da linha println! existente, pressione Enter e adicione esta segunda instrução antes da chave de fechamento:
println!("I am learning Rust with Cargo.");
Agora, o arquivo completo deverá estar assim:
fn main() {
println!("Hello from LabEx!");
println!("I am learning Rust with Cargo.");
}
Salve com Ctrl+O, pressione Enter e saia com Ctrl+X.
Agora peça ao Cargo para verificar se o pacote pode ser compilado:
cargo check
cargo check analisa o código e informa os erros sem produzir o programa executável final. A primeira verificação pode levar alguns instantes. Quando tudo dá certo, o resultado termina com uma linha que contém Finished.
Se o Cargo informar um erro, compare seu arquivo com o exemplo completo. Preste atenção especial às aspas, aos parênteses, aos pontos e vírgulas e às chaves. Use nano src/main.rs para corrigir o arquivo, salve-o e execute cargo check novamente.
Execute o programa com o Cargo
Nesta etapa, você compilará e executará o programa Rust que verificou.
Execute o comando a seguir em /home/labex/project/hello-rust:
cargo run
cargo run realiza duas tarefas relacionadas: compila o pacote em um programa executável e depois inicia esse programa. O Cargo pode exibir algumas linhas de status da compilação antes da saída do seu programa.
Perto do final, você deverá ver estas duas linhas:
Hello from LabEx!
I am learning Rust with Cargo.
Execute o programa mais uma vez, ocultando as mensagens de status do Cargo:
cargo run --quiet
A opção --quiet reduz a saída do próprio Cargo, portanto somente as duas linhas do seu programa deverão aparecer. Agora você concluiu o fluxo básico do Cargo: editar, verificar e executar.
Resumo
Você navegou por um terminal Linux, editou e salvou código Rust com o nano, reconheceu a função principal e a macro println!, verificou um pacote Cargo e o executou. O ciclo de editar, verificar e executar que você praticou é a base dos próximos projetos em Rust.
