🚀 Olá Mundo! e Gerenciamento de Projetos com Cargo

Bem-vindo(a) à sua primeira aula prática no Curso gratuito de Rust: A linguagem mais amada! 🎉

Nesta aula, daremos os primeiros passos com Rust, criando o clássico programa "Olá Mundo!". Mais importante ainda, aprenderemos a utilizar o Cargo, a ferramenta essencial de gerenciamento de projetos e pacotes de Rust. O Cargo será seu melhor amigo ao longo de sua jornada com Rust, então preste bastante atenção!

🎯 Objetivos da Aula

Ao final desta aula, você será capaz de:

• Escrever e executar um programa "Olá Mundo!" em Rust.
• Compreender a estrutura básica de um programa Rust.
• Criar novos projetos Rust usando cargo new.
• Compilar e executar projetos Rust usando cargo build e cargo run.
• Entender o papel do arquivo Cargo.toml.
• Utilizar comandos básicos do Cargo para gerenciar seu projeto.

Vamos começar! 🚀

1. 👋 Olá Mundo! em Rust

Todo programador começa com um "Olá Mundo!". Em Rust, isso não é diferente. É a maneira perfeita de verificar se sua instalação está funcionando e para se familiarizar com a sintaxe básica.

1.1. O Código Básico

O programa "Olá Mundo!" em Rust é surpreendentemente conciso.

Primeiro, vamos criar um arquivo chamado main.rs (a extensão .rs é para arquivos Rust).

// src/main.rs
fn main() {
    println!("Olá, mundo!");
}

1.2. Entendendo o Código

• fn main(): Esta linha declara uma função chamada main. A função main é especial: ela é sempre a primeira a ser executada em qualquer programa Rust. O fn é a palavra-chave para "function" (função).
• {}: As chaves delimitam o corpo da função, ou seja, o código que será executado.
• println!: Esta é uma macro em Rust. Macros são como funções, mas com algumas diferenças sintáticas e capacidades mais poderosas. O ! indica que estamos chamando uma macro, não uma função regular. A macro println! imprime texto na tela.
• "Olá, mundo!": Esta é a string (texto) que queremos imprimir.
• ;: Cada instrução em Rust termina com um ponto e vírgula.

1.3. Compilando e Executando (o jeito "manual")

Embora usaremos o Cargo na maior parte do tempo, é útil saber como compilar e executar um arquivo Rust diretamente.

1. Compile o arquivo: Abra seu terminal ou prompt de comando, navegue até o diretório onde você salvou main.rs e execute:

   rustc main.rs

   Se tudo correr bem, este comando não produzirá nenhuma saída, mas criará um arquivo executável no mesmo diretório (por exemplo, main no Linux/macOS ou main.exe no Windows).

2. Execute o programa:

   ./main # No Linux/macOS
   .\main.exe # No Windows

   Você deverá ver a saída:

   Olá, mundo!
   

   Parabéns! Você acabou de compilar e executar seu primeiro programa Rust! 🎉

2. 📦 Gerenciamento de Projetos com Cargo

Agora, vamos apresentar o Cargo, a ferramenta que tornará sua vida muito mais fácil ao trabalhar com Rust.

2.1. O Que é Cargo?

Cargo é o sistema de build e gerenciador de pacotes do Rust. Ele cuida de muitas tarefas para você:

• Criação de Projetos: Inicializa novos projetos Rust com uma estrutura padrão.
• Gerenciamento de Dependências: Baixa e compila as bibliotecas (crates) que seu projeto precisa.
• Compilação: Compila seu código Rust e suas dependências.
• Execução: Executa seu programa.
• Testes: Roda os testes do seu projeto.
• Documentação: Gera a documentação do seu código.

É a ferramenta central para a maioria dos desenvolvedores Rust. Se você instalou Rust usando rustup, o Cargo já está instalado!

2.2. Criando um Novo Projeto com Cargo

Em vez de criar arquivos manualmente, vamos usar o Cargo para iniciar um novo projeto.

1. Abra seu terminal e execute:

   cargo new hello_cargo

   Você verá uma saída similar a:

   Created binary (application) `hello_cargo` package
   

   Este comando criou um novo diretório chamado hello_cargo com a estrutura básica de um projeto Rust.

2. Explore a estrutura do projeto:

   Navegue para o novo diretório:

   cd hello_cargo

   E observe a estrutura:

   hello_cargo/
   ├── Cargo.toml
   └── src/
       └── main.rs
   

   • Cargo.toml: Este é o arquivo de manifesto do Cargo. Ele contém metadados sobre seu projeto (nome, versão, autores) e lista suas dependências.
   • src/main.rs: Este é o arquivo onde seu código-fonte principal reside. O Cargo espera que seus arquivos-fonte estejam dentro do diretório src.

2.3. O Arquivo Cargo.toml

Abra o arquivo Cargo.toml dentro do seu projeto hello_cargo. Ele deve se parecer com isto:

# hello_cargo/Cargo.toml
[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2021" # Ou a edição mais recente
 
[dependencies]

• [package]: Esta seção define metadados sobre seu pacote (crate).
  • name: O nome do seu projeto.
  • version: A versão atual do seu projeto.
  • edition: A edição do Rust que seu projeto usa. As edições permitem que Rust evolua sem quebrar o código existente. A edição 2021 (ou a mais recente) é a padrão para novos projetos.
• [dependencies]: Esta seção é onde você listaria quaisquer bibliotecas externas (crates) que seu projeto precise. Por enquanto, está vazia.

2.4. Compilando e Executando com Cargo

Agora, vamos usar o Cargo para compilar e executar o "Olá Mundo!" que ele gerou para nós.

1. Compile o projeto: Certifique-se de estar no diretório hello_cargo e execute:

   cargo build

   Você verá uma saída detalhada, incluindo algo como:

      Compiling hello_cargo v0.1.0 (~/hello_cargo)
       Finished dev [unoptimized + debuginfo] target(s) in 0.X.X.s
   

   Este comando compila seu projeto e suas dependências. O executável será colocado no diretório target/debug/.

2. Execute o projeto:

   cargo run

   Você verá:

      Compiling hello_cargo v0.1.0 (~/hello_cargo)
       Finished dev [unoptimized + debuginfo] target(s) in 0.X.X.s
       Running `target/debug/hello_cargo`
   Olá, mundo!
   

   Perceba que cargo run primeiro compila (se houver mudanças) e depois executa. É a forma mais comum de testar seu programa durante o desenvolvimento.

2.5. Outros Comandos Úteis do Cargo

• cargo check: Verifica seu código quanto a erros sem realmente compilar o executável. É muito mais rápido que cargo build e útil para feedback rápido.

  cargo check

• cargo build --release: Compila seu projeto com otimizações para produção. O executável resultante será mais rápido, mas a compilação levará mais tempo. O executável estará em target/release/.

  cargo build --release

• cargo doc: Gera a documentação HTML para seu projeto e suas dependências.

  cargo doc --open # Abre a documentação no seu navegador

• cargo test: Roda os testes do seu projeto. (Veremos isso em aulas futuras!)

📝 Exercícios/Desafios Práticos

É hora de colocar a mão na massa! Use o que você aprendeu para completar os desafios abaixo.

Desafio 1: Modificar o "Olá Mundo!" ✍️

Altere o programa "Olá Mundo!" para imprimir uma mensagem diferente.

• Navegue até o diretório hello_cargo.
• Abra o arquivo src/main.rs.
• Modifique a string dentro de println! para Olá, Rustacean!.
• Salve o arquivo.
• Execute o programa usando cargo run.
• Verifique se a nova mensagem é exibida.

Desafio 2: Criar um Segundo Projeto 🌱

Crie um novo projeto com o Cargo e adicione uma linha de código extra.

• No seu terminal, volte um diretório (cd ..) para não estar dentro de hello_cargo.
• Crie um novo projeto chamado meu_primeiro_app usando cargo new.
• Navegue para o diretório meu_primeiro_app.
• Abra src/main.rs.
• Adicione uma segunda linha println! para imprimir seu nome, por exemplo: println!("Meu nome é [Seu Nome]!");.
• Salve o arquivo.
• Execute o projeto usando cargo run.
• Verifique se ambas as mensagens são exibidas.

Desafio 3: Explorar Comandos Cargo 🔍

Use diferentes comandos do Cargo para entender seus efeitos.

• No diretório meu_primeiro_app, execute cargo check. Observe a velocidade em comparação com cargo run.
• Execute cargo build --release.
• Navegue até o diretório target/release.
• Execute o executável diretamente (por exemplo, ./meu_primeiro_app ou .\meu_primeiro_app.exe).
• Compare o tamanho do arquivo executável em target/debug com o de target/release. (O release geralmente é menor e otimizado).

Desafio 4: Adicionar uma Função Simples ➕

Vamos introduzir uma função muito simples para ver como Rust organiza o código.

• No projeto meu_primeiro_app, abra src/main.rs.

• Crie uma nova função abaixo de main que apenas imprime uma mensagem.

  // src/main.rs
  fn main() {
      println!("Olá, mundo!");
      println!("Meu nome é [Seu Nome]!");
      saudacao_personalizada(); // Chamando a nova função
  }
   
  fn saudacao_personalizada() {
      println!("Seja bem-vindo(a) ao mundo Rust!");
  }

• Chame a nova função dentro de main().

• Salve o arquivo.

• Execute o projeto com cargo run.

• Verifique se a mensagem da nova função é exibida.

📝 Resumo e Próximos Passos

Parabéns por completar sua primeira aula prática em Rust! Você deu um grande passo.

Nesta aula, aprendemos a:

• Escrever e executar um programa "Olá Mundo!" em Rust.
• Entender a sintaxe básica de uma função main e a macro println!.
• Utilizar o Cargo para criar, compilar e executar projetos Rust.
• Explorar a estrutura de um projeto Cargo e o arquivo Cargo.toml.
• Dominar comandos essenciais do Cargo como new, build, run, check e build --release.

O Cargo é uma ferramenta poderosa e você a usará constantemente. Acostume-se com ela!

Na próxima aula, mergulharemos mais fundo nos fundamentos da linguagem, explorando Variáveis e Tipos de Dados. Prepare-se para aprender como Rust lida com informações!

Até a próxima aula! 👋