Iniciando no Rust: Uma Introdução à Sintaxe

Rust, uma linguagem de programação de código aberto desenvolvida pela Mozilla, é projetada com segurança, velocidade e programação concorrente em mente. Sua sintaxe difere das linguagens de programação tradicionais, mas é intuitiva e fácil de aprender quando você compreende os conceitos básicos. Neste artigo, exploraremos os tipos básicos de dados, variáveis e mutabilidade, fluxo de controle, funções e comentários do Rust.

Foto de Jay Heike no Unsplash

Tipos de Dados Básicos

O Rust é uma linguagem de tipagem estática, o que significa que o tipo de cada variável deve ser conhecido em tempo de compilação. O Rust fornece vários tipos básicos de dados, incluindo:

Inteiros

O Rust tem duas categorias principais de inteiros: signed (com sinal) e unsigned (sem sinal). Cada categoria pode ter 8, 16, 32, 64 ou 128 bits de comprimento. Além disso, o Rust tem tipos isize e usize, que dependem da arquitetura da máquina. Por exemplo:

let x: u8 = 255; // inteiro sem sinal de 8 bits
let y: i64 = -5000; // inteiro com sinal de 64 bits

Booleanos

No Rust, booleanos são declarados usando a palavra-chave bool. Eles podem ser verdadeiros (true) ou falsos (false). Por exemplo:

let is_true: bool = true; // verdadeiro
let is_false: bool = false; // falso

Strings

Existem dois tipos de strings em Rust: String e &str. String é uma estrutura de dados proprietária alocada no heap (monte), mutável, que pode crescer, enquanto &str é uma string imutável de comprimento fixo em algum lugar na memória. Por exemplo:

let mut s: String = "Hello".to_string(); // string mutável
let t: &str = "World"; // fatia de string imutável

Variáveis e Mutabilidade

Por padrão, as variáveis em Rust são imutáveis. Isso é parte fundamental da busca do Rust por segurança e fácil simultaneidade. Para declarar uma variável mutável, você precisa usar a palavra-chave mut. Por exemplo:

let x = 5; // x é imutável
let mut y = 6; // y é mutável
y = 7; // isso é válido
// x = 8; // isso causaria um erro

Fluxo de Controle

O Rust fornece várias construções de fluxo de controle, incluindo if, loop, while e for.

If

A palavra-chave if permite a execução condicional de código. Por exemplo:

let number = 6;
if number % 2 == 0 {
    println!("O número é par.");
} else {
    println!("O número é ímpar.");
}

Loop

A palavra-chave loop permite loops infinitos. Você pode usar break para sair do loop. Por exemplo:

let mut counter = 0;
loop {
    counter += 1;
    if counter == 10 {
        break;
    }
}

While

A palavra-chave while permite loops que executam enquanto uma condição for verdadeira. Por exemplo:

let mut number = 5;
while number != 0 {
    println!("{}", number);
    number -= 1;
}

For

A palavra-chave for permite iterar sobre elementos de uma coleção, como arrays e vetores. Por exemplo:

let numbers = [1, 2, 3, 4, 5];
for number in numbers.iter() {
    println!("{}", number);
}

Funções

As funções são os blocos de construção de um programa Rust. Elas agrupam código que executa uma tarefa específica, o que melhora a reutilização e a legibilidade.

Definição de Função

Em Rust, você declara funções com a palavra-chave fn. Aqui está a sintaxe:

fn function_name(parameters) -> return_type {
    // Corpo da função.
}

function_name é o nome da função, parameters são as entradas para a função, e return_type é o tipo do valor de saída.

Por exemplo, a seguinte função add recebe dois inteiros i32 como parâmetros e retorna a soma deles, também um inteiro i32:

fn add(x: i32, y: i32) -> i32 {
    return x + y;
}

Invocação de Função

Você pode invocar uma função usando seu nome seguido por um conjunto de parênteses que engloba quaisquer argumentos. Veja como podemos chamar a função add:

let sum = add(5, 6);
println!("A soma é: {}", sum); // A soma é: 11

Declarações e Expressões em Funções

No Rust, uma função é composta por declarações e expressões. Declarações realizam alguma ação e não retornam um valor, enquanto expressões avaliam um valor. Nos corpos das funções, a última expressão é implicitamente retornada:

fn add(x: i32, y: i32) -> i32 {
    x + y // não há necessidade da palavra-chave `return`
}

Comentários

Comentários são notas explicativas que você adiciona ao seu código para humanos lerem; eles são ignorados pelo compilador Rust. Os comentários são cruciais para tornar seu código compreensível para os outros e para que você se lembre do que seu código faz.

Comentários de Linha Única

Comentários de linha única começam com //. O Rust ignora tudo o que vem depois de // na mesma linha:

// Este é um comentário de linha única.

Comentários de Múltiplas Linhas

Para comentários que abrangem várias linhas, você usa /* para iniciar o comentário e */ para terminar o comentário:

/* Este é um comentário de várias linhas.
Ele se estende por várias linhas. */

Comentários de Documentação

O Rust também suporta um tipo especial de comentário para documentação. Eles começam com /// para comentários de linha ou /** ... */ para comentários de bloco. Ao executar o comando cargo doc, o Rust gera documentação baseada nestes comentários:

/// Esta função adiciona dois inteiros.
///
/// # Exemplos
///
///
/// let sum = add(5, 7);
/// assert_eq!(sum, 12);
/// 
fn add(x: i32, y: i32) -> i32 {
    x + y
}

Nesta introdução, abordamos os fundamentos das funções e comentários em Rust. À medida que você continua sua jornada com Rust, encontrará casos de uso de função mais complexos, como funções com parâmetros genéricos, funções associadas e expressões de fechamento. Da mesma forma, para comentários, você aprenderá a escrever comentários de documentação mais eficazes usando a sintaxe de marcação Markdown.

Obrigado por ler este artigo!

Em nossa jornada coletiva para o futuro, seus pensamentos e contribuições são inestimáveis. Para mais conversas envolventes sobre blockchain, IA, programação e biohacking, vamos manter a conexão nestas plataformas:

• Leia mais dos meus artigos no Medium 📚
• Siga-me no Twitter 🐦 para pensamentos e discussões sobre IA, biohacking e blockchain.
• Confira meus projetos e contribua no GitHub 👩‍💻.
• E junte-se a mim no YouTube 🎥 para conversas mais aprofundadas.

Vamos continuar moldando o futuro juntos, uma criação de cada vez. 🚀

Artigo original escrito por Aurora Poppyseed. Traduzido por Paulinho Giovannini.