Aprendendo Rust: 01 - Hello World
Tags: rust, tutorial
Published: 2020-07-03 10:56:16

E aee jovens, tudo bem com vocês?

Neste post iremos montar o ambiente de execução e criar o nosso primeiro programa utilizando _Rust_.

Então, lets'go!!!

## Instalação e ambiente de desenvolvimento

Para Iniciar com _Rust_ temos duas alternativas, ou utilizando o site [](https://play.rust-lang.org/)[Play Rust](https://play.rust-lang.org/) que é mantido pelo core da _Rust_ e é uma ferramenta bem bacaninha e bem completa. Ou baixando a ferramenta [](https://rustup.rs/)[Rustup](https://rustup.rs/) que é o instalador oficial da _Rust_. A instalação vai depender do seu sistema operacional, mas é bem tranquila, no próprio site temos as opções para realiza-la.

Eu utilizarei a instalação, pois temos mais opções, como por exemplo usar a ferramenta _Cargo_ que veremos no próximo post.

Eu vou estar utilizando o  [VS Code](https://code.visualstudio.com/) como editor de código, a instalação é bem fácil, no Windows é um executável, e se estiver usando um sistema baseado em Unix, eu aconselho a baixar pelo [Snap](https://snapcraft.io/code).

Abaixo segue as extensões que no momento tenho instaladas dentro do VS Code:

- [Rust Pack](https://marketplace.visualstudio.com/items?itemName=swellaby.rust-pack) - este pack contem as 3 principais extensões que utilizo.
- [Rust Doc Viewer](https://marketplace.visualstudio.com/items?itemName=JScearcy.rust-doc-viewer) - para facilitar a documentação.

Para estes estudos eu estarei utilizando a versão _stable_ da _Rust_, após a instalação do _Rustup_, rodamos o comando:
```bash
rustup default stable
```
Assim definimos a versão _stable_ como _default_. Além desta, temos a opção de utilizar a _nightly_ que é atualizada mais frequentemente com as ultimas novidades da linguagem.

A versão _stable_ tem uma _release_ a cada 6 meses.

Para realizarmos um _update_ e baixarmos as atualizações da _Rust_, quanto do _Cargo_, e das ferramentas do _Rustup_, rodamos o comando:
```bash
rustup update stable
```
E desta forma temos um ambiente pronto para começarmos a codar.

## Hello World

Em um diretório de sua escolha vamos criar um arquivo chamado _hello_world.rs_ (a extensão .rs é a extensão dos arquivos _Rust_).
Dentro deste arquivo será adicionado o seguinte conteúdo:
```rust
fn main() {
    println!("Hello World!");
}
```
``` fn ```  → palavra reservada da linguagem, toda criação de função dentro da _Rust_ iremos utilizar essa palavra-chave.

``` main() ```  → todo programa binário em _Rust_ tem um _enterpoint_ (ponto de entrada, onde o programa começa a execução), toda vez que executarmos um programa, esse será o ponto de partida. Por padrão essa função não recebe parâmetros e não retorna nada.

``` { } ``` → escopo da função - tudo que estiver entre o par de chaves é o corpo (escopo) desta _função_.

``` println! ``` → é uma _macro_ (iremos ver em outro post especifico o que é uma _macro_), mas em poucas palavras seria meio que um template de código para utilizarmos, e o compilador irá avaliar em uma pré compilação. Tudo o que tiver uma !() no final do comando é uma _macro_. Para melhor legibilidade como podemos observar foi utilizado um recuo de 4 espaços nesta linha,  o estilo _Rust_ é recuar quatro espaços, não uma tabulação.

``` ("Hello World!"); ``` → Toda _string_ dentro da _Rust_ deve ser utilizada dentro de aspas duplas (""), as aspas simples são utilizados apenas nos tipo _character_ (''). Esta linha deve ser finalizada com um ponto e vírgula para indicar que essa expressão terminou e, se tivermos uma próxima, ela estará pronta para começar. A maioria das linhas de código _Rust_ termina com um ponto e vírgula.

### Execução do programa
Antes de executarmos um programa em _Rust_, precisamos compila-lo ou seja, gerarmos um arquivo que o computador saiba executar, para isso vamos pelo terminal no Unix entrar no diretório que criamos o arquivo , executando a seguinte instrução:
```bash
cd /dev/workspace/rust
```

E pelo prompt de comando no Windows:
```bash
cd \dev\workspace\rust
```

Este é o caminho onde eu criei o arquivo, vocês vão alterar essa linha adicionando o caminho que criaram.

Após isso vamos compilar o arquivo executando o comando abaixo no terminal:
```bash
rustc hello_world.rs
```

Dentro do diretório que está o arquivo que criamos será gerado um outro, que será o executável, para Windows será um __hello_world.exe__ e para sistemas Unix um __hello_world.sh__. No Windows também será gerado um arquivo chamado __hello_world.pbd__ este arquivo contem informações de _debugging_.

Para executar o arquivo no Windows, vamos rodar o comando:
```bash
.\hello_world.exe
```

Para executar o arquivo no Unix, vamos rodar o comando:
```bash
./hello_world
```
Na saída teremos algo parecido com:
```bash
Hello World!
```

Para esta postagem não ficar muito grande, deixarei a criação de um projeto Rust para o próximo, onde começaremos a utilizar a ferramenta _Cargo_.

Criei um repositório no _Github_ onde estarei adicionando o fonte de cada postagem, segue o link dele: [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)