Começando na linguagem de programação Rust

Vamos começar sua jornada Rust! Há muito o que aprender, mas toda jornada começa em algum lugar. Neste capítulo, discutiremos:

• Instalando o Rust no Linux, macOS e Windows.
• Escrever um programa que imprime Hello, world!
• Usando cargo, o gerenciador de pacotes e sistema de compilação do Rust.

Instalação

O primeiro passo é instalar o Rust. Faremos o download do Rust através do rustup, uma ferramenta de linha de comando para gerenciar versões do Rust e ferramentas associadas. Você precisará de uma conexão com a Internet para fazer o download.

Nota: Se você preferir não usar rustup por algum motivo, consulte a página de instalação do Rust para outras opções.

As etapas a seguir instalam a versão estável mais recente do compilador Rust. As garantias de estabilidade do Rust garantem que todos os exemplos no livro que compilam continuarão a compilar com as versões mais recentes do Rust. A saída pode ser um pouco diferente entre as versões, porque o Rust geralmente melhora as mensagens de erro e avisos. Em outras palavras, qualquer versão mais recente e estável do Rust que você instalar usando essas etapas deve funcionar conforme o esperado com o conteúdo deste livro.

Notação de linha de comando

Neste capítulo e em todo o livro, mostraremos alguns comandos usados no terminal. Todas as linhas que você deve inserir em um terminal começam $. Você não precisa digitar o caractere $; Esse caracter indica o início de cada comando. As linhas que não começam com $ normalmente mostram a saída do comando anterior. Além disso, exemplos específicos do PowerShell usarão > em vez de $.

Instalando rustup em Linux ou macOS

Se você estiver usando Linux ou macOS, abra um terminal e digite o seguinte comando:

$ curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh

O comando baixa um script e inicia a instalação da ferramenta rustup, que instala a versão estável mais recente do Rust. Sua senha pode ser solicitada. Se a instalação for bem-sucedida, a seguinte linha aparecerá:

Rust is installed now. Great!

Além disso, você precisará de algum tipo de vinculador (linker). É provável que um já esteja instalado, mas quando você tenta compilar um programa Rust e obtém erros indicando que um linker não pôde ser executado, isso significa que um linker não está instalado em seu sistema e você precisará instalá-lo manualmente. Os compiladores C geralmente vêm com o linker correto. Verifique a documentação da sua plataforma para saber como instalar um compilador C. Além disso, alguns pacotes Rust comuns dependem do código C e precisarão de um compilador C. Portanto, pode valer a pena instalar um agora.

Instalando rustup no Windows

No Windows, vá para https://www.rust-lang.org/tools/install e siga as instruções para instalar o Rust. Em algum ponto da instalação, você receberá uma mensagem explicando que também precisará das ferramentas de compilação C++ para Visual Studio 2013 ou posterior. A maneira mais fácil de adquirir as ferramentas de compilação é instalar as Ferramentas de Compilação para Visual Studio 2019. Quando questionado sobre quais pacotes de trabalho instalar, certifique-se de que "Ferramentas de compilação C++" esteja selecionado e que o SDK do Windows 10 e os componentes do pacote do idioma inglês estejam incluídos.

O restante deste livro usa comandos que funcionam em cmd.exe e PowerShell. Se houver diferenças específicas, explicaremos quais usar.

Atualizando e desinstalando

Depois de instalar o Rust via rustup, atualizar para a versão mais recente é fácil. Em seu shell, execute o seguinte script de atualização:

$ rustup update

Para desinstalar o Rust e rustup, execute o seguinte script de desinstalação em seu shell:

$ rustup self uninstall

Solução de problemas

Para verificar se você instalou o Rust corretamente, abra um shell e digite esta linha:

$ rustc --version

Você deve ver o número da versão, o hash do commit e a data do commit para a versão estável mais recente que foi lançada no seguinte formato:

rustc x.y.z (abcabcabc yyyy-mm-dd)

Se você vir esta informação, você instalou o Rust com sucesso! Se você não vir essas informações e estiver no Windows, verifique se Rust está na variável do sistema %PATH%. Se tudo estiver correto e o Rust ainda não estiver funcionando, há vários lugares onde você pode obter ajuda. O mais fácil é o canal #beginners no Rust Discord oficial. Lá, você pode conversar com outros Rustáceos (um apelido bobo que demos a nós mesmos) que podem ajudá-lo. Outros excelentes recursos incluem o fórum de usuários e o Stack Overflow.

Documentação Local

A instalação do Rust também inclui uma cópia da documentação localmente, para que você possa lê-la offline. Execute rustup doc para abrir a documentação local em seu navegador.

Sempre que um tipo ou função é fornecido pela biblioteca padrão e você não tem certeza do que ele faz ou como usá-lo, use a documentação da interface de programação de aplicativo (API) para descobrir!

Hello, World!

Agora que você instalou o Rust, vamos escrever seu primeiro programa Rust. É tradicional, ao aprender uma nova linguagem de programação, escrever um pequeno programa que imprima o texto Hello, world! na tela, então faremos o mesmo aqui!

Nota: este livro pressupõe familiaridade básica com a linha de comando. O Rust não faz exigências específicas sobre sua edição ou conjunto de ferramentas ou onde seu código reside, portanto, se você preferir usar um ambiente de desenvolvimento integrado (IDE) em vez da linha de comando, sinta-se à vontade para usar a sua IDE favorita. Muitas IDEs agora têm algum grau de suporte a Rust; verifique a documentação da IDE para obter detalhes. Recentemente, a equipe Rust tem se concentrado em habilitar um ótimo suporte de IDE, e o progresso tem sido feito rapidamente nessa frente!

Criação de um diretório de projeto

Você começará criando um diretório para armazenar seu código Rust. Não importa para Rust onde seu código reside, mas para os exercícios e projetos neste livro, sugerimos criar um diretório de projetos em seu diretório inicial e manter todos os seus projetos lá.

Abra um terminal e digite os seguintes comandos para criar um diretório projects e um diretório para o Hello, world! dentro do diretório projects.

Para Linux, macOS e PowerShell no Windows, digite:

$ mkdir ~/projects
$ cd ~/projects
$ mkdir hello_world
$ cd hello_world

Para Windows CMD, insira o seguinte:

> mkdir "%USERPROFILE%\projects"
> cd /d "%USERPROFILE%\projects"
> mkdir hello_world
> cd hello_world

Escrevendo e executando um programa Rust

Em seguida, faça um novo arquivo fonte e chame-o de main.rs. Os arquivos Rust sempre terminam com a extensão .rs. Se você estiver usando mais de uma palavra no nome do arquivo, use um sublinhado para separá-los. Por exemplo, use hello_world.rs em vez de helloworld.rs.

Agora abra o arquivo main.rs que você acabou de criar e insira o código na Listagem 1-1.

Nome do arquivo: main.rs

fn main() {
    println!("Hello, world!");
}

Listagem 1-1: Um programa que imprime Hello, world!

Salve o arquivo e volte para a janela do terminal. No Linux ou macOS, digite os seguintes comandos para compilar e executar o arquivo:

$ rustc main.rs
$ ./main
Hello, world!

No Windows, digite o comando em .\main.exe vez de ./main:

> rustc main.rs
> .\main.exe
Hello, world!

Independentemente do seu sistema operacional, a string Hello, world! deve ser impressa no terminal. Se você não vir esta saída, consulte a seção “Solução de problemas” da seção Instalação para obter ajuda.

Se imprimiu Hello, world!, parabéns! Você escreveu oficialmente um programa Rust. Isso faz de você um programador Rust - bem-vindo!

Anatomia de um programa Rust

Vamos revisar em detalhes o que acabou de acontecer em seu programa "Hello, world!". Esta é a primeira peça do quebra-cabeça:

fn main() {

}

Essas linhas definem uma função em Rust. A função main é especial: é sempre o primeiro código a ser executado em cada programa executável Rust. A primeira linha declara uma função chamada main que não possui parâmetros e não retorna nada. Se houver parâmetros, eles ficarão entre parênteses ().

Além disso, observe que o corpo da função está entre colchetes {}. Rust requer isso em todos os corpos funcionais. É um bom estilo colocar o colchete de abertura na mesma linha da declaração da função, adicionando um espaço no meio.

Se você deseja manter um estilo padrão nos projetos Rust, pode usar uma ferramenta de formatação automática chamada rustfmt para formatar seu código em um estilo específico. A equipe Rust incluiu esta ferramenta com a distribuição padrão do Rust, como rustc, ela já deve estar instalada no seu computador! Verifique a documentação online para mais detalhes.

Dentro da função main está o seguinte código:

println!("Hello, world!");

Esta linha faz todo o trabalho neste pequeno programa: imprime texto na tela. Existem quatro detalhes importantes a serem observados aqui.

Primeiro, o estilo Rust é recuar com quatro espaços, não uma tabulação.

Em segundo lugar, println! chama uma macro Rust. Se, em vez disso, chamasse uma função, seria inserido como println (sem o !). Discutiremos as macros Rust com mais detalhes no Capítulo 19. Por enquanto, você só precisa saber que usar um ! significa que você está chamando uma macro em vez de uma função normal.

Terceiro, você vê a string "Hello, world!". Passamos essa string como um argumento para println! e a string é impressa na tela.

Em quarto lugar, terminamos a linha com um ponto-e-vírgula (;), o que indica que essa expressão acabou e a próxima está pronta para começar. A maioria das linhas do código Rust termina com um ponto e vírgula.

Compilar e executar são etapas separadas

Você acabou de executar um programa recém-criado, então vamos examinar cada etapa do processo.

Antes de executar um programa Rust, você deve compilá-lo usando o compilador Rust, digitando o comando rustc e passando o nome de seu arquivo de origem, como este:

$ rustc main.rs

Se você tiver experiência em C ou C++, notará que é semelhante a gcc ou clang. Depois de compilar com sucesso, o Rust gera um executável binário.

No Linux, macOS e PowerShell no Windows, você pode ver o executável digitando o comando ls em seu shell. No Linux e no macOS, você verá dois arquivos. Com o PowerShell no Windows, você verá os mesmos três arquivos que veria usando o CMD.

$ ls
main  main.rs

Com o CMD no Windows, você deve inserir o seguinte:

> dir /B %= the /B option says to only show the file names =%
main.exe
main.pdb
main.rs

Mostra o arquivo de código-fonte com a extensão .rs, o arquivo executável (main.exe no Windows, mas main em todas as outras plataformas) e, ao usar o Windows, um arquivo contendo informações de depuração com a extensão .pdb. A partir daqui, você executa o arquivo main ou main.exe, assim:

$ ./main # ou .\main.exe no Windows

Se main.rs fosse o seu programa Hello, World!, esta linha seria impressa em seu terminal: Hello, world!.

Se você está mais familiarizado com uma linguagem dinâmica, como Ruby, Python ou JavaScript, pode não estar acostumado a compilar e executar um programa como etapas separadas. Rust é uma linguagem compilada antecipadamente, o que significa que você pode compilar um programa e fornecer o executável para outra pessoa, e eles podem executá-lo mesmo sem ter o Rust instalado. Se você der a alguém um arquivo .rb, .py ou .js, eles precisam ter uma implementação Ruby, Python ou JavaScript instalada (respectivamente). Mas nessas linguagens, você só precisa de um comando para compilar e executar seu programa. Tudo é uma troca no design da linguagem.

Apenas compilar com rustc é bom para programas simples, mas conforme seu projeto cresce, você deseja gerenciar todas as opções e facilitar o compartilhamento de seu código. A seguir, apresentaremos a ferramenta Cargo, que o ajudará a escrever programas Rust do mundo real.

Olá, Cargo!

Cargo é o sistema de construção e gerenciador de pacotes do Rust. A maioria dos Rustáceos usa essa ferramenta para gerenciar seus projetos Rust porque o Cargo lida com muitas tarefas para você, como construir seu código, baixar as bibliotecas das quais seu código depende e construir essas bibliotecas. (Chamamos de bibliotecas suas dependências de código.)

Os programas Rust mais simples, como o que escrevemos até agora, não têm dependências. Então, se tivéssemos construído o projeto Hello, world! com o Cargo, ele usaria apenas a parte do Cargo que lida com a construção de seu código. Conforme você escreve programas Rust mais complexos, você adicionará dependências e, se iniciar um projeto usando Cargo, adicionar dependências será muito mais fácil de fazer.

Como a grande maioria dos projetos do Rust usa Cargo, o restante deste livro pressupõe que você também esteja usando Cargo. O Cargo vem instalado com o Rust se você usou os instaladores oficiais discutidos na seção “Instalação”. Se você instalou o Rust por algum outro meio, verifique se o Cargo está instalado inserindo o seguinte em seu terminal:

$ cargo --version

Se você vir um número de versão, você o tem! Se você vir um erro, como command not found, consulte a documentação do seu método de instalação para determinar como instalar o Cargo separadamente.

Criando um Projeto com Cargo

Vamos criar um novo projeto usando Cargo e ver como ele difere do nosso projeto original “Hello, world!”. Navegue de volta ao diretório de seus projetos (ou onde quer que você decidiu armazenar seu código). Em seguida, em qualquer sistema operacional, execute o seguinte:

$ cargo new hello_cargo
$ cd hello_cargo

O primeiro comando cria um novo diretório chamado hello_cargo. Chamamos nosso projeto de hello_cargo e Cargo cria seus arquivos em um diretório com o mesmo nome.

Vá para o diretório hello_cargo e liste os arquivos. Você verá que o Cargo gerou dois arquivos e um diretório para nós: um arquivo Cargo.toml e um diretório src com um arquivo main.rs dentro.

Ele também inicializou um novo repositório Git junto com um arquivo .gitignore. Os arquivos Git não serão gerados se você executar cargo new em um repositório Git existente; você pode substituir esse comportamento usando cargo new --vcs=git.

Nota: Git é um sistema de controle de versão comum. Você pode mudar cargo new para usar um sistema de controle de versão diferente ou nenhum sistema de controle de versão usando o sinalizador --vcs. Execute cargo new --help para ver as opções disponíveis.

Abra Cargo.toml no editor de texto de sua escolha. Deve ser semelhante ao código da Listagem 1-2.

Nome do arquivo: Cargo.toml

[package]
name = "hello_cargo"
version = "0.1.0"
authors = ["Your Name <you@example.com>"]
edition = "2018"

[dependencies]

Listagem 1-2: Conteúdo de Cargo.toml gerado por cargo new

Este arquivo está no formato TOML (Tom's Obvious, Minimal Language), que é o formato de configuração do Cargo.

A primeira linha, [package] é um título de seção que indica que as instruções a seguir estão configurando um pacote. À medida que adicionarmos mais informações a este arquivo, adicionaremos outras seções.

As próximas quatro linhas definem as informações de configuração de que o Cargo precisa para compilar seu programa: o nome, a versão, quem o escreveu e a edição do Rust a ser usada. O Cargo obtém seu nome e informações de e-mail de seu ambiente, então se essas informações não estiverem corretas, corrija as informações agora e salve o arquivo. Falaremos sobre a chave de edition no Apêndice E.

A última linha, [dependencies] é o início de uma seção para você listar qualquer uma das dependências do seu projeto. No Rust, os pacotes de código são chamados de crates. Não precisaremos de nenhum outro crates para este projeto, mas iremos no primeiro projeto no Capítulo 2, então usaremos esta seção de dependências.

Agora abra src/main.rs e dê uma olhada:

Nome do arquivo: src/main.rs

fn main() {
    println!("Hello, world!");
}

Cargo gerou um programa Hello, world! para você, assim como o que escrevemos na Listagem 1-1! Até agora, as diferenças entre nosso projeto anterior e o projeto que o Cargo gera é que o Cargo colocou o código no diretório src, e temos um arquivo de configuração Cargo.toml no diretório superior.

O Cargo espera que seus arquivos de origem residam no diretório src. O diretório do projeto de nível superior é apenas para arquivos README, informações de licença, arquivos de configuração e qualquer outra coisa não relacionada ao seu código. Usar o Cargo ajuda a organizar seus projetos. Há um lugar para tudo e tudo está em seu lugar.

Se você iniciou um projeto que não usa Cargo, como fizemos com o projeto Hello, world!, você pode convertê-lo em um projeto que use Cargo. Mova o código do projeto para o diretório src e crie um arquivo Cargo.toml apropriado.

Construindo e executando um projeto Cargo

Agora vamos ver o que é diferente quando construímos e executamos o programa “Hello, world!” com Cargo! A partir do seu diretório hello_cargo, construir o seu projeto, digitando o seguinte comando:

$ cargo build
    Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
        Finished dev [unoptimized + debuginfo] target(s) in 2.85 secs

Este comando cria um arquivo executável em target/debug/hello_cargo (ou target\debug\hello_cargo.exe no Windows) em vez de em seu diretório atual. Você pode executar o executável com este comando:

$ ./target/debug/hello_cargo # or .\target\debug\hello_cargo.exe on Windows
Hello, world!

Se tudo correr bem, Hello, world! deve ser imprisso no terminal. A execução de cargo build pela primeira vez também faz com que Cargo crie um novo arquivo no nível superior: Cargo.lock. Este arquivo controla as versões exatas das dependências em seu projeto. Este projeto não tem dependências, então o arquivo é um pouco esparso. Você nunca precisará alterar este arquivo manualmente; Cargo gerencia seu conteúdo para você.

Acabamos de construir um projeto cargo build e executá-lo ./target/debug/hello_cargo, mas também podemos usar cargo run para compilar o código e, em seguida, executar o executável resultante em um único comando:

$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
     Running `target/debug/hello_cargo`
Hello, world!

Observe que, desta vez, não vimos uma saída indicando que o Cargo estava compilando hello_cargo. Cargo descobriu que os arquivos não haviam mudado, então apenas executou o binário. Se você tivesse modificado seu código-fonte, o Cargo teria reconstruído o projeto antes de executá-lo e você teria visto esta saída:

$ cargo run
Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
 Finished dev [unoptimized + debuginfo] target(s) in 0.33 secs
  Running `target/debug/hello_cargo`
Hello, world!

Cargo também fornece um comando chamado cargo check. Este comando verifica rapidamente seu código para garantir que ele compila, mas não produz um executável:

$ cargo check
 Checking hello_cargo v0.1.0 (file:///projects/hello_cargo)
  Finished dev [unoptimized + debuginfo] target(s) in 0.32 secs

Por que você não quer um executável? Frequentemente, cargo check é muito mais rápido do que cargo build, porque pula a etapa de produção de um executável. Se você está verificando continuamente o seu trabalho enquanto escreve o código, usar cargo check irá acelerar o processo! Como tal, muitos Rustáceos executam cargo check periodicamente enquanto escrevem seu programa para garantir que ele seja compilado. Em seguida, eles executam cargo build quando estão prontos para usar o executável.

Vamos recapitular o que aprendemos até agora sobre o Cargo:

• Podemos construir um projeto usando cargo build.
• Podemos construir e executar um projeto em uma etapa usando cargo run.
• Podemos construir um projeto sem produzir um binário para verificar se há erros usando cargo check.
• Em vez de salvar o resultado da construção no mesmo diretório do nosso código, o Cargo o armazena no diretório de destino/debug.

Uma vantagem adicional de usar o Cargo é que os comandos são os mesmos, não importa em qual sistema operacional você está trabalhando. Portanto, neste ponto, não forneceremos mais instruções específicas para Linux e macOS versus Windows.

Construindo para Lançamento

Quando seu projeto estiver finalmente pronto para lançamento, você pode usar cargo build --release para compilá-lo com otimizações. Este comando criará um executável em target/release em vez de target/debug. As otimizações tornam o código do Rust mais rápido, mas ativá-las prolonga o tempo de compilação do programa. É por isso que existem dois perfis diferentes: um para o desenvolvimento, quando você deseja reconstruir rápida e frequentemente, e outro para construir o programa final que você dará a um usuário que não será reconstruído repetidamente e que será executado tão rápido quanto possível. Se você estiver comparando o tempo de execução do seu código, certifique-se de executar cargo build --release e avaliar com o executável no destino/release.

Cargo como Convenção

Com projetos simples, o Cargo não fornece muito valor em relação ao rustc, mas provará seu valor à medida que seus programas se tornam mais complexos. Com projetos complexos compostos de vários crates, é muito mais fácil deixar o Cargo coordenar a construção.

Embora o projeto hello_cargo seja simples, agora ele usa muitas das ferramentas reais que você usará no resto de sua carreira no Rust. Na verdade, para trabalhar em qualquer projeto existente, você pode usar os seguintes comandos para verificar o código usando Git, mudar para o diretório desse projeto e compilar:

$ git clone someurl.com/someproject
$ cd someproject
$ cargo build

Para mais informações sobre o Cargo, verifique sua documentação.

Resumo

Você já começou bem sua jornada com Rust! Neste capítulo, você aprendeu como:

• Instale a última versão estável do Rust usando rustup.
• Atualize para uma versão mais recente do Rust.
• Abrir a documentação instalada localmente.
• Escrever e executar um programa "Hello, Wold!" usando rustc diretamente.
• Criar e execute um novo projeto usando as convenções do Cargo.

Traduzido por Acervo Lima. O original pode ser acessado aqui.

Licença

• Apache License, Version 2.0
• MIT license

<< Anterior Próximo >>