Início / coding / Perguntas / 78747775
Accepted
Pioneer_11
Asked: 2024-07-15 09:31:55 +0800 CST

ferrugem `split` dividido antes da correspondência do padrão

  • 772

Estou tentando dividir a Stringretenção de cada correspondência de padrão, mas com a parte correspondente retida como o início da próxima substring, em vez do terminador da última.

Implementação atual:

let s = String::from("AaaBbCc");
for block in s.split_inclusive(|c: char| c.is_uppercase()) {
    println!("{block}")
}

Saída atual

A
aaB
bC
c

Saída desejada

Aaa
Bb
Cc

Como isso pode ser alcançado?

rust

2 respostas

  1. Best Answer

    Não acho que a biblioteca padrão possa ajudá-lo (embora exista um milhão de métodos String, posso estar errado). Mas é um iterador simples o suficiente para você mesmo escrever, se você realmente precisar de preguiça:

    struct CamelCaseSplit<'a> {
    char_indices: std::str::CharIndices<'a>,
    chunk_start: usize,
    s: &'a str
}

impl<'a> CamelCaseSplit<'a> {
    pub fn new(s: &'a str) -> Self {
        let mut char_indices = s.char_indices();
        // We'll never want to split before the first char, so skip it.
        char_indices.next();
        Self {
            char_indices,
            chunk_start: 0,
            s,
        }
    }
}

impl<'a> Iterator for CamelCaseSplit<'a> {
    type Item = &'a str;
    
    fn next(&mut self) -> Option<Self::Item> {
        // The input is exhausted
        if self.chunk_start == self.s.len() {
            return None;
        }
        // Find the next uppercase letter position OR the end of the string
        let chunk_end = if let Some((chunk_end, _)) = self.char_indices.by_ref().skip_while(|(_, c)| !c.is_uppercase()).next() {
            chunk_end
        } else {
            self.s.len()
        };
        let chunk = &self.s[self.chunk_start..chunk_end];
        self.chunk_start = chunk_end;
        return Some(chunk);
    }
}

fn main() {
    let split = CamelCaseSplit::new("AaaBbCc");
    for c in split {
        println!("{c}");
        // Aaa
        // Bb
        // Cc
    }
}
    • 2

  2. Eu acreditava que isso não poderia ser alcançado através de um único método no String. Mas há uma solução alternativa como segue:

    let s = String::from("AaaBbCc");
let s_reversed = s.chars().rev().collect::<String>();
let blocks = s_reversed
    .split_inclusive(|c: char| c.is_uppercase())
    // reverse each block in the iterator...
    .map(|block| block.chars().rev().collect::<String>())
    // and then reverse the whole iterator
    .rev();
for block in blocks {
    println!("{}", block)
}
    • 1

relate perguntas