Operadores em Rust

Operadores são os símbolos que você usa para fazer contas, comparar valores e combinar condições. Se você já usou alguma linguagem parecida com C, a maioria deles vai parecer familiar.

Operadores aritméticos

fn main() {
    let a = 10;
    let b = 3;

    println!("{}", a + b); // 13
    println!("{}", a - b); // 7
    println!("{}", a * b); // 30
    println!("{}", a / b); // 3  (divisão inteira, descarta o resto)
    println!("{}", a % b); // 1  (resto)
}

▶ Experimente você mesmo

Cuidado

a / b com dois inteiros faz uma divisão inteira: 10 / 3 dá 3, e não 3.333.... Se você quer um resultado decimal, pelo menos um dos lados precisa ser float: 10.0 / 3.0.

Operadores de comparação

Eles comparam dois valores e devolvem um bool:

fn main() {
    let a = 5;
    let b = 8;

    println!("{}", a == b); // false
    println!("{}", a != b); // true
    println!("{}", a < b);  // true
    println!("{}", a > b);  // false
    println!("{}", a <= b); // true
    println!("{}", a >= b); // false
}

Você vai usá-los o tempo todo dentro de condições de if, que veremos na página If…Else.

Operadores lógicos

Os operadores lógicos combinam ou invertem valores booleanos:

fn main() {
    let is_logged_in = true;
    let is_admin = false;

    println!("{}", is_logged_in && is_admin); // false: os dois precisam ser true
    println!("{}", is_logged_in || is_admin); // true: pelo menos um é true
    println!("{}", !is_admin);                // true: inverte false para true
}

▶ Experimente você mesmo

• &&: e (and). Só é verdadeiro se os dois lados forem verdadeiros.
• ||: ou (or). É verdadeiro se pelo menos um dos lados for verdadeiro.
• !: não (not). Troca verdadeiro por falso e vice-versa.

Operadores de atribuição

Além do = simples, o Rust tem operadores abreviados que atualizam uma variável com base no valor atual dela:

fn main() {
    let mut score = 10;

    score += 5; // o mesmo que: score = score + 5
    score -= 2; // score = score - 2
    score *= 3; // score = score * 3
    score /= 2; // score = score / 2

    println!("{score}");
}

▶ Experimente você mesmo

Lembre que a variável precisa de mut para qualquer um desses compilar, porque você está mudando o valor dela.

Nota

O Rust não tem os operadores ++ e --. Para somar um a um contador, escreva count += 1. É um caractere a mais, e não deixa nenhuma dúvida sobre o que acontece.

Ordem das operações (precedência)

Quando uma expressão tem vários operadores, o Rust não vai simplesmente da esquerda para a direita. Como na matemática da escola, *, / e % acontecem antes de + e -. Operadores do mesmo nível rodam da esquerda para a direita. Os parênteses sempre vêm primeiro, então use-os sempre que quiser uma ordem diferente.

fn main() {
    let a = 2 + 3 * 4;            // * primeiro: 2 + 12
    let b = (2 + 3) * 4;          // parênteses primeiro: 5 * 4
    let c = 10 - 4 - 3;           // mesmo nível, da esquerda para a direita: (10 - 4) - 3
    let d = 17 % 5 * 2;           // mesmo nível, da esquerda para a direita: (17 % 5) * 2
    let ok = 1 + 1 == 2 && 3 > 2; // contas, depois comparações, depois &&

    println!("{a} {b} {c} {d} {ok}");
}

Saída:

14 20 3 4 true

▶ Experimente você mesmo

A ordem completa, do primeiro ao último, é mais ou menos esta: aritmética (* / %, depois + -), depois comparações (== != < > <= >=), depois &&, depois || e, por fim, os operadores de atribuição (= += -= e companhia). É por isso que 1 + 1 == 2 && 3 > 2 funciona sem nenhum parêntese. Mesmo assim, se você precisar parar para pensar na ordem, coloque parênteses. Eles não custam nada e deixam o código mais fácil de ler.

Cuidado

Não dá para encadear comparações como na matemática. 1 < x < 5 é um erro de compilação (“comparison operators cannot be chained”, ou seja, operadores de comparação não podem ser encadeados). Escreva como duas comparações unidas com &&: 1 < x && x < 5.

Prática

1. Minutos e segundos

Um vídeo tem 125 segundos. Guarde isso em uma variável e depois imprima quantos minutos inteiros e quantos segundos sobram, assim: 2 minutos e 5 segundos. Dica: a divisão inteira / dá os minutos inteiros, e o % dá o que sobra.

Ver solução

fn main() {
    let total_seconds = 125;

    let minutes = total_seconds / 60; // 2 (o resto é descartado)
    let seconds = total_seconds % 60; // 5 (o resto)

    println!("{minutes} minutos e {seconds} segundos");
}

Saída:

2 minutos e 5 segundos

▶ Experimente você mesmo

2. Marcando pontos

Comece a pontuação score de um jogo em 10. Some 25, tire 5 e depois dobre o valor, usando os operadores de atribuição abreviados. Imprima a pontuação, se ela é pelo menos 50 e se ela é pelo menos 50 e par. Dica: um número é par quando score % 2 == 0.

Ver solução

fn main() {
    let mut score = 10;

    score += 25; // 35
    score -= 5;  // 30
    score *= 2;  // 60

    println!("pontuação: {score}");
    println!("passou de fase? {}", score >= 50);
    println!("passou e é par? {}", score >= 50 && score % 2 == 0);
}

Saída:

pontuação: 60
passou de fase? true
passou e é par? true

▶ Experimente você mesmo

Resumo

• Aritméticos: + - * / %. A divisão entre inteiros corta a parte decimal.
• Comparação: == != < > <= >=, todos retornam um bool.
• Lógicos: && (e), || (ou), ! (não).
• Atribuição abreviada: += -= *= /= atualizam uma variável mut no próprio lugar. Não existe ++.
• * / % rodam antes de + -, e as contas rodam antes das comparações e de &&/||. Na dúvida, use parênteses.

Teste o que aprendeu

Teste o que aprendeu

1. Qual é o resultado de 10 / 3 quando os dois lados são inteiros?

3.333... 3 4

2. Que tipo os operadores de comparação, como == e <, sempre retornam?

i32 String bool

3. O que é necessário para score += 5; compilar?

score precisa ser declarada com mut score precisa ser um f64 Nada de especial, sempre compila

Pontuação: 0 / 3

Para saber mais

• B - Operators and Symbols — The Rust Book (em inglês): uma tabela de uma página com todos os operadores do Rust e o que cada um faz.
• Literals and operators — Rust by Example (em inglês): exemplos curtos, que você pode rodar, de operadores aritméticos, lógicos e bit a bit.
• Expression precedence — The Rust Reference (em inglês): a ordem exata em que o Rust avalia os operadores, do primeiro ao último.
• Operator expressions — The Rust Reference (em inglês): as regras precisas de cada operador, incluindo o que acontece no overflow de inteiros.