Jump to content

# Rust (Português)

4 languages

- English
- 日本語
- Русский
- 中文（简体）

From ArchWiki
Status de tradução: Esse artigo é uma tradução de Rust. Data da última tradução: 2022-12-18. Você pode ajudar a sincronizar a tradução, se houver alterações na versão em inglês.

Artigos relacionados

- Rust package guidelines

Da Wikipedia:

  Rust é uma linguagem de programação multi paradigma, de propósito geral, compilada e patrocinada pela Mozilla Research. Rust enfatiza a performance, a segurança de tipos(desencoraja ou previne erros de tipo), a concorrência(concurrency, capacidade de um sistema realizar operações simultaneamente) e a praticidade. Rust reforça a segurança da memória(memory-safe) — isto é, que todas as referencias apontem para uma memória válida — sem exigir uso de um garbage collection ou de contagem de referencia(reference counting) presentes em outras linguagens que implementam memory-safe. Rust é popular para programação de sistemas, mas também oferece recursos de alto nível, como algumas estruturas de programação funcional, programação imperativa e orientação a objetos.

## Núcleo da linguagem

### Biblioteca do Núcleo Rust

A Biblioteca do Núcleo Rust (Core Library) é a base livre de dependências da Biblioteca padrão do Rust. Ela interage diretamente com as primitivas LLVM, o que perrmite que o Rust seja independente de plataforma e hardware. É essa integração com o LLVM que permite ao Rust obter maior desempenho do que aplicativos C equivalentes compilados com Clang, tornando o software Rust projetado com libcore de nível inferior ao C. Ele contém apenas tipos básicos independentes de plataforma, como `Option`, `Result`, and `Iterator`. Os desenvolvedores que procuram software de destino para plataformas incorporadas(embedded) podem renunciar à biblioteca padrão `#![no_std]` para usar exclusivamente a biblioteca do núcleo sem baterias incluídas, binários em tamanhos menores e performance aprimorada. No entanto, usando `#![no_std]` limita a quantidade de suporte de software que você pode obter da maior comunidade Rust, pois a maioria das bibliotecas requer a biblioteca padrão.

### Biblioteca Padrão Rust

A Biblioteca Padrão Rust (Standard Library) fornece convenientes abstrações de alto nível com as quais a maioria dos software portáteis Rust são criados. Fornece recursos convenientes como tipos `Vec` e `String`; uma vasta quantidade de métodos para linguagens primitivas; um grande número de macros padrão; E/S e suporte multi threading; alocações de pilha(heap) com `Box`; e muitos outros recursos de alto nível não disponíveis na biblioteca do núcleo.

### Ciclo de Lançamento

Rust segue um ciclo de lançamento regular de seis semanas, semelhante ao ciclo de lançamento do Firefox. A cada novo lançamento, as bibliotecas do núcleo e a biblioteca padrão são aprimoradas para suportar mais plataformas, melhorar a performance, e estabilizar novas recursos para uso com o Rust estável.

## Instalação

As duas principais formas para instalar Rust são:

- A instalação Nativa, recomendada se você apenas usa rust para executar ou instalar software feitos com Rust
- A instalação Rustup, recomendada se você pretende programar algo em Rust

### Instalação Nativa

Para install a ultima versão estável do Rust a partir do repositório oficial de software do Arch Linux, install o pacote rust. Isto irá instalar o compilador `rustc` e Cargo(gerenciador de pacotes Rust).

Há também uma versão de desenvolvimento do compilador Rust disponível no AUR. Use rust-nightly-binAUR para binários genéricos pré-construídos ou rust-gitAUR para construí o compilador com a biblioteca do sistema.

### Rustup

O método oficial e recomendado de instalação Rust para propósito de desenvolvimento de software é usa o gerenciador de ferramentas Rustup, escrito em Rust.

Os benefícios de usar o gerenciador de ferramentas Rustup ao invés do Rust pré-empacotado no repositório de software é a capacidade de instalar múltiplas ferramentas (stable, beta, nightly) para múltiplas plataformas (windows, mac, android) e arquiteturas (x86, x86_64, arm).

Existem duas opções para instalar Rustup, a primeira é suportada pelo Arch Linux via pacman, e a segunda é oficialmente suportada pelo Rust via seu script de instalação.

#### Pacote Arch Linux

rustup está disponível no repositório de software do Arch Linux. Note que `rustup self update` não not funcionar quando instalado desta forma, o pacote precisa ser atualizado pelo pacman.

Este pacote tem a vantagem que os vários executáveis Rust estarão em `/usr/bin`, ao invés de `~/.cargo/bin`, removendo a necessidade de adicionar outra diretório ao seu `PATH`.

Note: O pacote rustup não instala uma cadeia de ferramentas por padrão. Ele fornece links simbólicos entre `/usr/bin/rustup` para os binários comuns como `/usr/bin/rustc` e `/usr/bin/cargo`. Como mencionado anteriormente, o usuário precisar instalar uma cadeia de ferramentas manualmente para que os comando Rust façam algo.

Para instalar a cadeia de ferramentas, você precisa informar ao rustup qual versão usar: `stable` ou `nightly`.

Exemplo:

    $ rustup default stable

#### Instalação pelo Script Upstream

Rustup está também disponível para download e instalação manual via pagina oficial rustup.

Baixe o arquivo com `curl --proto '=https' --tlsv1.3 -sSf https://sh.rustup.rs -o rust.sh`, visualize-o com: `less ./rust.sh`, e execute o script `./rust.sh` para iniciar a instalação do rustup. O script faz mudanças no PATH apenas para arquivos de configuração de login do shell. Você precisa fazer `source ~/.cargo/env` até você sair e logar de volta no sistema. para update rustup posteriormente, execute `rustup self update`.

O script instala e ativa a cadeia de ferramentas padrão (usada pelo pacote rust), portanto, não há necessidade de instalar manualmente para começar usar o Rust.

Warning: Executar `curl alguma-url | sh`, como a documentação do Rust sugere, é considerada como um risco de segurança, porque ele executa código desconhecido, que pode ser corrompido durante o download. Por isto é recomendado fazer o download manualmente do script e checar ele antes de executa-lo.
Note: Por favor certifique-se que `~/.cargo/bin` esteja em seu `PATH` quando você executar `rustup`.

#### Uso

Você pode precisar instalar manualmente uma cadeia de ferramentas(toolchain), e.g. `stable`, `beta`, `nightly` ou `1.58.0`. Você também precisará fazer isto se você quiser usar/testa outras toolchain.

    $ rustup toolchain install toolchain

Você agora pode executar comandos Rust executando, `rustup run toolchain command`. No entanto, para usar estes comandos diretamente, você precisa ativar o toolchain:

    $ rustup default toolchain

Verifique a versão da instalação Rust usando `rustc -V`:

    $ rustc -V

    rustc 1.58.0 (02072b482 2022-01-11)

Note:

Rust não faz sua própria vinculação(linking), e você precisará ter um linker instalado. você pode usar gcc, de outra forma Rust irá gerar o seguinte `erro: linker `cc` not found.`

### Teste sua instalação

verifique se Rust está corretamente instalado construindo um programa simples, como o seguinte:

    ~/hello.rs

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

Você pode compilar isto com `rustc`, executando isto:

    $ rustc hello.rs && ./hello

    Hello, World!

## Compilação Cruzada (Cross compiling)

### Usando rustup

Você pode facilmente realizar compilação cruzada usando Rustup. Rustup suporta muitos alvos de compilação cruzada. Uma lista completa pode ser encontrada executando `rustup target list`.

Por exemplo, se você quiser instalar rust usando o canal estável para Windows, usando o compilador GNU, você irá precisar fazer:

    $ rustup toolchain install stable-x86_64-pc-windows-gnu

Isto irá apenas instalar rust e suas ferramentas para sua arquitetura alvo, mas algumas ferramentas adicionais poderão ser necessárias para compilação cruzada.

### Windows

Nesta seção, `$ARCH` é a arquitetura alvo (qualquer `x86_64` ou `i686`). Isto irá explicar como fazer compilação cruzada usando rustup.

1. Install mingw-w64-gcc
2. Run `rustup target add $ARCH-pc-windows-gnu` para instalar a biblioteca padrão rust para sua arquitetura.
3. Finalmente, informe ao cargo onde procurar a MinGW-w64 gcc/ar adicionado o seguinte ao seu `~/.cargo/config`:

    ~/.cargo/config

    [target.$ARCH-pc-windows-gnu]
    linker = "/usr/bin/$ARCH-w64-mingw32-gcc"
    ar = "/usr/bin/$ARCH-w64-mingw32-ar"

Finalmente, você pode fazer compilação cruzada para windows passando `--target $ARCH-pc-windows-gnu` para o cargo:

    $ # Build
    $ cargo build --release --target "$ARCH-pc-windows-gnu"
    $ # Run unit tests under wine
    $ cargo test --target "$ARCH-pc-windows-gnu"

Atualmente a construção de execultaveis usando MinGW 6 e toolchains instalados por rustup estão quebrados. para corrigir isto, execute:

    for lib in crt2.o dllcrt2.o libmsvcrt.a; do cp -v /usr/x86_64-w64-mingw32/lib/$lib $HOME/.rustup/toolchains/$CHANNEL-x86_64-unknown-linux-gnu/lib/rustlib/x86_64-pc-windows-gnu/lib/; done

Onde `CHANNEL` é o canal de atualização (`stable`, `beta` ou `nightly`)

### Pacotes não oficiais

No repositório não oficial archlinuxcn está rust-nightly e a biblioteca padrão Rust para i686, ARM, ARMv7, Windows 32 e 64 para que você possa instalar o que deseja e aproveitar a compilação cruzada. No entanto, você tem que procurar um ARM toolchain por você mesmo. para alvos Windows 32bit, você irá precisar pegar uma libgcc_s_dw2-1.dll (fornecida por mingw-w64-gcc) pra construir e executar.

## Cargo

Cargo, é o gerenciador de pacote Rust, é parte do pacote rust. O nightly version está disponível no AUR como parte de rust-nightly-binAUR. Se você usa rustup, ele já inclui o cargo.

Cargo é uma ferramenta que permite projetos Rust declarar suas varias dependências, e garante que você irá sempre pegar uma build replicável. Você será encorajado a ler o guia oficial.

### Uso

Para criar um novo projeto usando Cargo:

    $ cargo new hello_world

Isto criar um diretório com uma arquivo `Cargo.toml` padrão, definido para construir um executável.

Note: Cargo usa este `Cargo.toml` como um manifesto contendo todos os metadados requeridos para compilar seu projeto.

    Cargo.toml

    [package]
    name = "hello_world"
    version = "0.1.0"
    edition = "2021"

    [dependencies]

### Otimizando para plataformas nativas da CPU

Para instruir o Cargo a sempre compilar o código otimizado para sua plataforma da CPU, você pode alcançar isto adicionando uma flag para `~/.cargo/config`. Esteja ciente que o binário resultante pode não ser distribuído para uso em outros computadores, e pode sempre falhar em seu sistema se você decide mudar sua CPU no futuro.

Procure qual plataforma alvo é usada por padrão em sua instalação:

    $ rustup toolchain list

    stable-x86_64-unknown-linux-gnu (default)

Neste exemplo, nos estamos usando rust `stable` na plataforma `x86_64-unknown-linux-gnu`.

Instruir Cargo a sempre compilar o código otimizado para a plataforma nativa da CPU:

    ~/.cargo/config

    [target.x86_64-unknown-linux-gnu]
    rustflags = ["-C", "target-cpu=native"]

### sccache

O tempo de compilação pode ser muito reduzido usando o pacote sccache (sccache). Isto irá manter um cache local do artefatos do compilador, eliminado a necessidade para recompilar o código que não mudou desde a ultima vez que foi compilado.

Para ativar sccache, você pode usar `RUSTC_WRAPPER` environment variable:

    export RUSTC_WRAPPER=sccache
    cargo build

ou

    RUSTC_WRAPPER=sccache cargo construtor

Alternativamente, adicionar a seguinte configuração para `~/.cargo/config`:

    ~/.cargo/config

    [build]
    rustc-wrapper = "sccache"

## Suporte a IDE

### Ferramentas

Veja https://www.rust-lang.org/tools para as ferramentas recomendadas do projeto Rust.

#### RLS

This article or section is being considered for removal.

Reason: RLS está deprecated desde rust 1.65 em favor de rust-analyzer e não deve ser utilizado. (Discuss in Talk:Rust#Deprecated language servers)

RLS usado para fornecer uma Language Server Protocol implementação para Rust, fornecer IDEs, editores, e outras ferramentas com informações sobre programas Rust. Ele é suporta funcionalidades como 'definição goto', pesquisa de simbolos, reformatação, complementação de código, ativar renome e refatoração.

RLS está incluído no pacote rust. para instalar RLS use rustup:

    $ rustup component add rls rust-analysis rust-src

#### rust-analyzer

rust-analyzer é uma implementação experimental de um Language Server Protocol para Rust an experimental Language Server Protocol implementation for Rust feito para substituir o RSL.

Ele está disponível como o pacote rust-analyzer, e a ultima versão do Git está disponível como rust-analyzer-gitAUR.

rust-analyzer necessita do source code da biblioteca padrão. Se ela não está presente, rust-analyzer irá tentar fazer a instalação automaticamente usando rustup. Para instalar o source code manualmente usando rustup, execute o seguinte comando:

    $ rustup component add rust-src

#### Racer

This article or section is out of date.

Reason: RLS and deprecated (Discuss in Talk:Rust (Português))

Racer fornece suporte a complementação de código para editores e IDEs. Eles está sendo It has been suplantado por (que usa Racer como um substituto).

Ele requer que você também instale uma cópia do Rust source code, que você pode obter em uma destas fontes:

- Com rustup: `rustup component add rust-src`
- Do AUR: rust-src-gitAUR ou rust-nightly-srcAUR[link quebrado: package not found], neste caso você deve definir a variável de ambiente `RUST_SRC_PATH`.

Depois de instalar o source code, você pode usar qualquer `Cargo` para instalar racer ou obtê-lo deste repositório (rust-racerAUR).

    $ cargo +nightly install racer

#### Clippy

Clippy Leva vantagem do plugin de suporte do compilador por fornecer um grande número de lints adicionais para detectar e alertar sobre uma grande variedade de erros e compiler plugin support to provide a large number of additional lints for detecting and warning about a larger variety of errors and Rust não idiomático.

Clippy está incluído no pacote rust. para instalar ele com rustup use:

    $ rustup component add clippy

#### Rustfmt

Rustfmt é uma ferramenta para formatar código Rust de acordo com os guias de estilo oficiais.

Rustfmt está incluso no pacote rust. para instalar ele com rustup use:

    $ rustup component add rustfmt

### Editores

#### IntelliJ IDEA

IntelliJ IDEA tem um plugin Rust . O mesmo plugin também trabalha com CLion.

Se usar rustup, use rustup para download o source (`rustup component add rust-src`), e então selecione `~/.rustup/toolchains/<your toolchain>/bin` como a localização do toolchain.

Se usar Rust do repositório de software oficial do Arch Linux, selecione `/usr/bin` como a localização do toolchain e `/usr/lib/rustlib/src/rust/library/` coma a stdlib localização das fontes.

#### Visual Studio Code

Visual Studio Code suporte para Rust pode ser obtido via extensão rust-lang.rls (requer rustup). Se usa rust-analyzer, use a extensão matklad.rust-analyzer.

#### Vim

Vim suporte para Rust pode ser obtido via o oficial plugin rust.vim plugin, que fornece detecção de arquivo, destaque de sintaxe, formatação e suporte para plugin de checagem de sintaxe Syntastic. Muitas engines de complementação tem suporte para Rust, como coc (via o plugin coc.rls) e o YouCompleteMe.

#### Emacs

Emacs suporte para Rust pode ser obtido via o oficial plugin rust-mode.

#### Kate

Kate suporte para Rust é obtido usando Language Server Protocol. Ele usa rust-analyzer por padrão; tudo que você precisa para fazer esta instalação está junto com a fonte do Rust.

#### GNOME Builder

GNOME Builder suporte para Rust é obtido usando Language Server Protocol. Eles usa rust-analyzer por padrão; tudo o que você precisa para fazer a instalação está junto com a fonte do Rust.

## Vejá também

- Official website of the Rust Programming Language
- Rust Documentation
- Official Rust Book
- Standard Library API Lookup
- Examples with small descriptions
- Page listing of Rust tutorials
- Libraries(crates) available through Cargo
- This Week in Rust
- The Rust Programming Language Blog
- The Rust Users Forum
- The Rust Internals Forum
- Awesome Rust: A curated list of Rust libraries and resources
- Wikipedia:Rust (programming language)

Category:

- Programming languages (Português)

Hidden categories:

- Sections flagged with Template:Remove
- Pages or sections flagged with Template:Out of date
- Pages with broken package links