WEB3DEV

Cover image for Iniciando no Rust: Uma Introdução à Sintaxe
Paulo Gio
Paulo Gio

Posted on

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.

https://miro.medium.com/v2/resize:fit:1100/0*8yeF5qGZZt_v_m8L

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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.");
}
Enter fullscreen mode Exit fullscreen mode

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;
    }
}
Enter fullscreen mode Exit fullscreen mode

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;
}
Enter fullscreen mode Exit fullscreen mode

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);
}
Enter fullscreen mode Exit fullscreen mode

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.
}
Enter fullscreen mode Exit fullscreen mode

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;
}
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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`
}
Enter fullscreen mode Exit fullscreen mode

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.
Enter fullscreen mode Exit fullscreen mode

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. */
Enter fullscreen mode Exit fullscreen mode

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
}
Enter fullscreen mode Exit fullscreen mode

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.

Latest comments (0)