Início / coding / Perguntas / 77479225
Accepted
mike rodent
Asked: 2023-11-14 16:45:06 +0800 CST

pular de Vec::retain()?

  • 772

Quero iterar Vecfazendo várias coisas com os objetos nele contidos (o que seria mais complexo que usizes) e, no caso de uma ordem para interromper a iteração, reter apenas os objetos que ainda não foram processados.

fn main() {
    let _ = iterate();
}

fn iterate(){
    let mut objs_for_processing = Vec::new();
    
    for i in 0..10 {
        objs_for_processing.push(i);
    }
    
    let mut n = 0;
    objs_for_processing.retain(|obj| {
        n += 1;
        if n > 3 {
            println!("STOP iteration!...");
            return true // i.e. retain
        }
        println!("iteration, do some business with obj {}", obj);
        false
    });
    println!("objs_for_processing.len() {} {:#?}", objs_for_processing.len(), objs_for_processing);
}

O problema acima, obviamente, é que você precisa completar todas as iterações, mesmo depois de saber que deseja manter todos os outros elementos...

Encontrei esta pergunta e esta pergunta . Este último parecia mais promissor. Mas acontece que você não pode alterar o tipo de retorno do retainfechamento de ' (ou seja, aceitar a Result, para poder retornar an Errque interromperá a iteração), até onde eu sei.

A única solução que encontrei é clonar o Vec, iterar usando um normal for ... ine depois remover itens do clone (chamado depleted_vec) à medida que são processados, usando o bastante complicado

let index = depleted_vec.iter().position(|x| x == obj).unwrap();
depleted_vec.remove(index);

... e depois atribuir objs_for_processinga depleted_vec. Pelo menos desta forma posso usar breakpara interromper a iteração.

Parece uma coisa bastante razoável de se fazer: não existe uma maneira mais elegante de fazer isso?

NB: Eu também me perguntei se poderia haver uma Iteratorsolução baseada em - então tentei com iter().filter(...).collect()... isso produz um Vecof &usize, not usize. Portanto, talvez pudesse ser usado, mas com custo de processamento adicional. Não é bonito: parece que deveria haver algo melhor.

rust

2 respostas

  1. Best Answer

    Então, se bem entendi, você precisa fazer duas coisas:

    • Iterar sobre os elementos do vec, fazendo coisas com os objetos ali (modificando-os?)
    • Em algum momento durante a iteração, algo força você a parar (por exemplo, um buffer está cheio). Neste ponto, você deseja remover todos os itens processados ​​​​do vec, para que possa retomar o trabalho mais tarde, provavelmente.

    Aqui está o loop para fazer isso de forma eficiente:

    let mut n = 0;
for e in &objs_for_processing {
  if must_stop() { break; }
  n += 1;
  process(e);
}
objs_for_processing.drain(0..n);

    Não vejo sentido em sugerir mais nada, embora a extract_ifAPI experimental serviria bem ao seu caso de uso (ainda assim iteraria sobre tudo).

    No entanto , se esta for realmente uma fila de trabalho, é muito melhor usar um VecDeque em primeiro lugar.

    use std::collections::VecDeque;

fn main() {
    let mut objs_for_processing = (0..10).collect::<VecDeque<_>>();

    let mut n = 0;
    while let Some(obj) = objs_for_processing.pop_front() {
        n += 1;
        if n > 3 {
            println!("STOP iteration!...");
            break;
        }
        println!("iteration, do some business with obj {}", obj);
    }
    println!(
        "objs_for_processing.len() {} {:#?}",
        objs_for_processing.len(),
        objs_for_processing
    );
}

    Link para o playground: https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=78468b26d34a29009b090a969fd9d5f3

    • 1

  2. Você não precisa clonar o Vec, você pode apenas iterar usando índices e remover os elementos:

    let mut i = 0;
let mut n = 0;
while i < objs_for_processing.len() {
    if n > 3 {
        println!("STOP iteration!...");
        break;
    }
    
    if true {
        let obj = &objs_for_processing[i];
        println!("iteration, do some business with obj {}", obj);
        
        objs_for_processing.remove(i);
        // Don't increment `i`!
    } else {
        i += 1;
    }
    
    n += 1;
}

    Isso não será tão eficiente quanto retain()(pois pode fazer remoção em massa), mas provavelmente não importa para você.

    • 0

relate perguntas