Aprendendo Rust: 02 - Hello Cargo
Published: 2020-07-10 15:09:10

E aee jovens, tudo bem com vocês?

Neste post iremos entender um pouco sobre a ferramenta _Cargo_, criar um projeto _Rust_ e entender a estrutura do projeto.

Então, lets'go!!!

## Cargo

Cargo é uma ferramenta que instalamos junto com o _Rustup_, ela é muito completa, pois gerencia ciclo de vida de todo o programa _Rust_, faz a instalação das bibliotecas, de componentes, de programas no sistema operacional, gerencia as dependências, realiza a publicação do programa, gera documentação do sistema, e muitas outras coisas.

Para vermos qual a versão estamos usando executamos a linha abaixo:
```
cargo --version
```

Será retornado algo como:
```
cargo 1.44.1 (88ba85757 2020-06-11)
```

Vamos começar instalando uma ferramenta bem útil executando o comando abaixo no terminal:
```
cargo install cargo-play
```
Na [Postagem passada](https://dev.to/pehdepano/aprendendo-rust-01-hello-world-35p4) criamos um arquivo chamado _hello_world.rs_, compilamos e depois o executamos. Vamos entrar no diretório onde deixamos o arquivo salvo e usar o _cargo-play_ para executarmos de forma mais rápida:
```bash
cd /dev/workspace/rust
cargo play hello_world.rs
```
E pelo prompt de comando no Windows:
```bash
cd  \dev\workspace\rust
cargo play hello_world.rs
```
**Onde o caminho deverá ser alterado para onde vocês deixaram o arquivo salvo

A saída será parecida com a seguinte:
```bash

Compiling p3mafgnxu8ftipvencq6xrvxevha6 v0.1.0 (/tmp/cargo-play.3MafGnxU8fTiPvENCq6XrvXeVhA6)
Finished dev [unoptimized + debuginfo] target(s) in 0.24s
Running `/tmp/cargo-play.3MafGnxU8fTiPvENCq6XrvXeVhA6/target/debug/p3mafgnxu8ftipvencq6xrvxevha6`

Hello World!

```
Desta forma conseguimos testar os arquivos, executar _scripts_ escritos em _Rust_ de um jeito simples.

## Projeto Rust

Para criarmos um projeto, utilizaremos o comando:
```bash
cargo new hello_cargo
```
Se tudo ocorrer bem teremos o retorno:
```bash
Created binary (application) `hello_cargo` package
```
Vamos entrar no diretório criado e logo em seguida abrir ele no VS Code, com o comando:
```bash
cd hello_cargo
code .
```
O projeto será criado com a seguinte estrutura:
```bash
.
├── Cargo.toml
└── src
	└── main.rs
```
Ao olharmos os arquivos criados, teremos o pacote _src_ que é onde o _Cargo_ espera que seus arquivos _Rust_ estejam, automaticamente cria-se pra gente um arquivo _main.rs_ dentro deste pacote, se o abrirmos veremos o seguinte conteúdo:
```rust
fn  main() {
    println!("Hello, world!");
}
```
Como este conteúdo é praticamente igual ao que já vimos, não vou explicar novamente, se tiverem dúvidas por favor acessem esse [link](https://dev.to/pehdepano/aprendendo-rust-01-hello-world-35p4).

Na raiz do projeto também foi criado o arquivo _Cargo.toml_ e ao abrirmos teremos o seguinte conteúdo:
```rust
[package]
name =  "hello_cargo"
version =  "0.1.0"
authors = ["Richard de Jesus <jdr.richard@gmail.com>"]
edition =  "2018"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

```
A extensão _toml_ significa (_Tom’s Obvious, Minimal Language_) e este é o arquivo de configurações do _Cargo_.

A primeira linha `[package]` é um cabeçalho de sessão, onde abaixo temos 4 linhas que por padrão definem as informações de configuração que o _Cargo_ precisa para compilar seu programa:

- O nome do programa
- A versão do programa
- O autor
- A edição do _Rust_

O seu nome e seu e-mail são recuperados do seu ambiente, e pode mudar de acordo com a sua vontade.

A última linha `[dependencies]`é o início de uma seção para você listar qualquer uma das dependências que o seu projeto precise. Na _Rust_, pacotes de código são chamados de _crates_ . Para este exemplo não precisaremos utilizar uma outra _crate_, mas veremos em outra postagem.

## Build e execução do projeto

Podemos utilizar o comando `cargo build` para gerarmos o _build_ da aplicação, este comando gerará um arquivo executável em _target/debug/hello_cargo_ (ou _target\debug\hello_cargo.exe_ no Windows). Se executarmos o arquivo gerado, teremos a seguinte saída:
```bash
Hello, world!
```
Mas, também podemos utilizar o comando `cargo run` para compilarmos e já executarmos o programa em seguida. Se o projeto já tiver sido compilado e não tiver tido nenhuma alteração em algum de seus arquivos, ao executar o comando o sistema rodará mas não será compilado novamente, pois o _Cargo_ é inteligente o bastante para não compilar um arquivo que já foi compilado anteriormente.

Teremos uma saída parecida com a abaixo:
```bash
Compiling hello_cargo v0.1.0 (\dev\workspace\rust\hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 1.99s
     Running `target\debug\hello_cargo.exe`
Hello, world!
```

O _Cargo_ também tem o comando `cargo check`. Este comando checa o código mas não produz um executável. Ele é uma forma rápida de checarmos se está tudo ok.

Para gerar uma versão final do programa usaremos o comando `cargo build --release` pois dessa forma ele será compilado com otimizações, deixando o sistema ainda melhor para ser utilizado em __produção__.

Vou adicionar o fonte desta postagem no _Github_, segue o link: [Aprendendo Rust](https://github.com/RichardJd/aprendendo-rust)

Quaisquer dúvidas ou sugestões para que eu melhore nas postagens deixe um comentário, e continue acompanhando os próximos posts.

# Referencias

[](https://doc.rust-lang.org/book/)[O livro de Rust](https://doc.rust-lang.org/book/)

[](https://www.twitch.tv/codeshow)[CodeShow](https://www.twitch.tv/codeshow)