Hva er Rust-ekvivalenten til TypeScripts Array.map med destrukturering?

I TypeScript kan du mappe og destrukturere et delvis sett med data fra et grensesnitt ved å bruke følgende

interface Person {
  name: string;
  address: string;
}

function getName({ name }: Person): Partial<Person> {
  return ({ name });
}

const people: Person[] = [
  {
    name: "Sally",
    address: "1234 E Test St."
  },
  // ...
];

const names = people.map(getName);
// => [{ "name": "Sally" }, ...]

Jeg har lest Rust-dokumentasjonen, og kanskje forstår jeg det bare ikke, men jeg har ikke funnet en 1:1-ekvivalent for hvordan man gjør denne TypeScript-operasjonen i Rust. Er det mulig å utføre denne typen destrukturering i Rust? Kanskje ved å bruke map eller filter_map?

Svar #1

Rust har også destrukturering gjennom mønstermatching:

struct Person {
    name: String,
    address: String,
}

fn get_name(Person { name, .. }: Person) -> String {
    name
}

fn main() {
    let people = vec![Person {
        name: String::from("Sally"),
        address: String::from("1234 E Test St."),
    }];

    let names: Vec<_> = people.into_iter().map(get_name).collect();
    println!("{:?}", names);
}

Du vil vanligvis ikke se folk gjøre denne typen destrukturering i funksjonssignaturer, men. Det eksponerer mer av implementeringen i den automatisk genererte dokumentasjonen. Det er mer vanlig å se det umiddelbart inne i en funksjon:

fn get_name(person: Person) -> String {
    let Person { name, .. } = person;
    name
}

Og folk bruker ikke ofte destrukturering i let-variabler med mindre de henter ut mange verdier. I dette tilfellet er det kortere å bare bruke feltet direkte:

fn get_name(person: Person) -> String {
    person.name
}

Denne spesielle funksjonen er ikke super nyttig, så jeg ville vanligvis også sett på den som en closure:

.map(|p| p.name)

Det er mange ting i din opprinnelige TypeScript som ikke oversettes direkte til Rust:

  1. Konseptet med Partial-typen.
  2. Rust-vektorer implementerer ikke map og lignende — disse operasjonene tilhører iteratorer. Disse er late, noe som gjør at Rust kan være mye mer effektivt enn tilsvarende JS.
  3. Det finnes flere strengtyper.

Hva om jeg ønsket å destrukturere mer enn én egenskap?

Hvis du ønsket en anonym samling av felter, ville du vanligvis bruke en tuple:

fn get_name_things(Person { name, .. }: Person) -> (String, usize) {
    (name, 42)
}

Det finnes ikke noe konsept for engangsstrukturer med navngitte felt.

Relaterte artikler