Learn Rust Coding · Aula

API de entrada e valores padrão

Atualize valores de forma prática.

API de entrada e valores padrão é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.

Por que usar a API Entry?

Muitas vezes, você quer atualizar um valor se uma chave existir ou inserir um valor padrão se ela não existir.

Fazer isso com get e depois insert é trabalhoso. A API entry faz isso de forma simples, em uma única etapa.

entry retorna um espaço

Chamar entry(key) fornece um identificador para o espaço dessa chave no mapa.

A partir desse identificador, você decide o que fazer: preenchê-lo com um valor padrão ou modificar o que já estiver ali.

use std::collections::HashMap;

fn main() {
    let mut m: HashMap<&str, i32> = HashMap::new();
    m.entry("a").or_insert(0);
    println!("{}", m["a"]);
}

or_insert

or_insert(default) insere o valor padrão somente se a chave estiver ausente e então retorna uma referência mutável para o valor.

Se a chave já existir, o valor padrão será ignorado e você obterá o valor existente.

use std::collections::HashMap;

fn main() {
    let mut m = HashMap::new();
    m.insert("a", 10);
    m.entry("a").or_insert(99);
    m.entry("b").or_insert(99);
    println!("a={}, b={}", m["a"], m["b"]);
}

Modificando por meio da referência

Como or_insert retorna uma referência mutável, você pode alterar o valor imediatamente.

Desreferencie-a com * para atualizar o valor no próprio lugar. Esse é o princípio fundamental da contagem.

use std::collections::HashMap;

fn main() {
    let mut m = HashMap::new();
    let count = m.entry("hits").or_insert(0);
    *count += 1;
    *count += 1;
    println!("hits = {}", m["hits"]);
}

Contando em um loop

O padrão clássico: para cada item, obtenha seu espaço, use zero como valor padrão e incremente.

Assim, você contabiliza as ocorrências usando apenas uma linha de lógica por item.

use std::collections::HashMap;

fn main() {
    let mut counts = HashMap::new();
    for c in "hello".chars() {
        *counts.entry(c).or_insert(0) += 1;
    }
    println!("l appears {} times", counts[&'l']);
}

or_insert_with

Quando for caro criar o valor padrão, use or_insert_with. Ele recebe uma closure que é executada somente se a chave estiver ausente.

Isso evita construir um valor de que talvez você nunca precise.

use std::collections::HashMap;

fn main() {
    let mut m: HashMap<&str, Vec<i32>> = HashMap::new();
    m.entry("nums").or_insert_with(Vec::new).push(1);
    m.entry("nums").or_insert_with(Vec::new).push(2);
    println!("{:?}", m["nums"]);
}

and_modify

and_modify executa uma closure sobre o valor somente se a chave já existir.

Combine-o com or_insert para tratar os dois casos: modificar se estiver presente; caso contrário, inserir um valor inicial.

use std::collections::HashMap;

fn main() {
    let mut m = HashMap::new();
    m.insert("x", 5);
    m.entry("x").and_modify(|v| *v += 10).or_insert(0);
    m.entry("y").and_modify(|v| *v += 10).or_insert(1);
    println!("x={}, y={}", m["x"], m["y"]);
}

or_default

Se o tipo do valor tiver um Default (como 0 para inteiros ou uma Vec vazia), or_default o utilizará.

É uma forma abreviada de or_insert(Default::default()).

use std::collections::HashMap;

fn main() {
    let mut m: HashMap<&str, i32> = HashMap::new();
    *m.entry("score").or_default() += 7;
    println!("score = {}", m["score"]);
}

Criando listas por chave

A API entry é especialmente útil para agrupar itens em vetores.

Para cada chave, use um Vec vazio como padrão na primeira vez e depois use push no vetor que estiver ali.

use std::collections::HashMap;

fn main() {
    let mut groups: HashMap<bool, Vec<i32>> = HashMap::new();
    for n in [1, 2, 3, 4] {
        groups.entry(n % 2 == 0).or_default().push(n);
    }
    println!("evens: {:?}", groups[&true]);
}

Por que não usar get + insert?

Fazer um get separado e depois um insert consulta a chave duas vezes e entra em conflito com o verificador de empréstimos.

A API entry faz uma única consulta e fornece exatamente uma referência segura, sendo mais rápida e organizada.

Reunindo tudo

Aqui, a contagem e um valor padrão se combinam para descobrir quantas palavras distintas começam com cada letra.

Observe o padrão de contabilização em uma linha funcionando.

use std::collections::HashMap;

fn main() {
    let words = ["ant", "art", "bee"];
    let mut by_first: HashMap<char, i32> = HashMap::new();
    for w in words {
        *by_first.entry(w.chars().next().unwrap()).or_insert(0) += 1;
    }
    println!("a: {}", by_first[&'a']);
}

Verificação rápida

Você quer contar chars fazendo uma única consulta por char.

Recapitulação

A API entry permite inserir ou atualizar com uma única consulta.

Você usou or_insert, or_insert_with, or_default e and_modify para contar itens e criar listas por chave de forma organizada.

Perguntas Frequentes

A aula “API de entrada e valores padrão” é grátis?

Sim — o texto completo de “API de entrada e valores padrão” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.

O que vou aprender em “API de entrada e valores padrão”?

Atualize valores de forma prática. Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “API de entrada e valores padrão”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Learn Rust Coding