`mem::take` în Rust

std::mem: mutare, înlocuire, dimensiuni Rust 1.40

Mută valoarea afară dintr-un loc mutabil și lasă în loc valoarea implicită a tipului (text gol, vector gol, 0).

Sintaxă

pub fn take<T: Default>(dest: &mut T) -> T

Ce face `mem::take`

mem::take(&mut loc) este mem::replace(&mut loc, T::default()): returnează valoarea și lasă în urmă una „goală”. Merge cu orice tip care are Default: String, Vec, HashMap, numere, Option (rămâne None).

Este foarte practic pentru a „goli” un buffer și a-i procesa conținutul fără clonare.

Parametri

Parametru	Descriere
`dest`	Locul din care iei valoarea, prin `&mut`.

Ce returnează

Valoarea care era în dest.

Exemple

Exemplul 1: Golirea unui buffer de mesaje

use std::mem;

struct Jurnal {
    in_asteptare: Vec<String>,
}

impl Jurnal {
    fn scrie(&mut self, m: &str) {
        self.in_asteptare.push(m.to_string());
    }
    fn trimite(&mut self) -> Vec<String> {
        mem::take(&mut self.in_asteptare)
    }
}

fn main() {
    let mut j = Jurnal { in_asteptare: Vec::new() };
    j.scrie("utilizator conectat");
    j.scrie("comandă plasată");

    let trimise = j.trimite();
    println!("trimise: {trimise:?}");
    println!("rămase: {:?}", j.in_asteptare);
}

Rezultat

trimise: ["utilizator conectat", "comandă plasată"]
rămase: []

Exemplul 2: Valori implicite rămase în urmă

use std::mem;

fn main() {
    let mut text = String::from("Bună dimineața");
    let mut total: u32 = 250;
    let mut oras: Option<&str> = Some("Iași");

    println!("{:?} -> rămâne {:?}", mem::take(&mut text), text);
    println!("{} -> rămâne {}", mem::take(&mut total), total);
    println!("{:?} -> rămâne {:?}", mem::take(&mut oras), oras);
}