Rust (Português)

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-bin
AUR
[
link quebrado
: package not found]
para binários genéricos pré-construídos ou
rust-git
AUR
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.
Install
mingw-w64-gcc
Run
rustup target add $ARCH-pc-windows-gnu
para instalar a biblioteca padrão rust para sua arquitetura.
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-bin
AUR
[
link quebrado
: package not found]
. 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-git
AUR
.
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-git
AUR
ou
rust-nightly-src
AUR
[
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-racer
AUR
).
$ 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)