Desestructuración con Movimiento Parcial en Rust

RustRustBeginner
Practicar Ahora

This tutorial is from open-source community. Access the source code

💡 Este tutorial está traducido por IA desde la versión en inglés. Para ver la versión original, puedes hacer clic aquí

Introducción

En este laboratorio, aprendemos sobre los movimientos parciales dentro de la desestructuración de una variable única, donde se pueden utilizar simultáneamente los enlaces de patrón by-move y by-reference. Esto da lugar a un movimiento parcial de la variable, lo que permite que algunas partes se muevan mientras que otras todavía se pueden referenciar. Si una variable padre se mueve parcialmente, no se puede utilizar como un todo después, pero las partes que solo se refieren y no se mueven todavía se pueden utilizar.

Nota: Si el laboratorio no especifica un nombre de archivo, puede utilizar cualquier nombre de archivo que desee. Por ejemplo, puede utilizar main.rs, compilar y ejecutarlo con rustc main.rs &&./main.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL rust(("Rust")) -.-> rust/FunctionsandClosuresGroup(["Functions and Closures"]) rust(("Rust")) -.-> rust/MemorySafetyandManagementGroup(["Memory Safety and Management"]) rust(("Rust")) -.-> rust/DataStructuresandEnumsGroup(["Data Structures and Enums"]) rust(("Rust")) -.-> rust/AdvancedTopicsGroup(["Advanced Topics"]) rust(("Rust")) -.-> rust/BasicConceptsGroup(["Basic Concepts"]) rust(("Rust")) -.-> rust/DataTypesGroup(["Data Types"]) rust/BasicConceptsGroup -.-> rust/variable_declarations("Variable Declarations") rust/DataTypesGroup -.-> rust/integer_types("Integer Types") rust/DataTypesGroup -.-> rust/string_type("String Type") rust/DataTypesGroup -.-> rust/type_casting("Type Conversion and Casting") rust/FunctionsandClosuresGroup -.-> rust/function_syntax("Function Syntax") rust/FunctionsandClosuresGroup -.-> rust/expressions_statements("Expressions and Statements") rust/MemorySafetyandManagementGroup -.-> rust/lifetime_specifiers("Lifetime Specifiers") rust/DataStructuresandEnumsGroup -.-> rust/method_syntax("Method Syntax") rust/AdvancedTopicsGroup -.-> rust/operator_overloading("Traits for Operator Overloading") subgraph Lab Skills rust/variable_declarations -.-> lab-99197{{"Desestructuración con Movimiento Parcial en Rust"}} rust/integer_types -.-> lab-99197{{"Desestructuración con Movimiento Parcial en Rust"}} rust/string_type -.-> lab-99197{{"Desestructuración con Movimiento Parcial en Rust"}} rust/type_casting -.-> lab-99197{{"Desestructuración con Movimiento Parcial en Rust"}} rust/function_syntax -.-> lab-99197{{"Desestructuración con Movimiento Parcial en Rust"}} rust/expressions_statements -.-> lab-99197{{"Desestructuración con Movimiento Parcial en Rust"}} rust/lifetime_specifiers -.-> lab-99197{{"Desestructuración con Movimiento Parcial en Rust"}} rust/method_syntax -.-> lab-99197{{"Desestructuración con Movimiento Parcial en Rust"}} rust/operator_overloading -.-> lab-99197{{"Desestructuración con Movimiento Parcial en Rust"}} end

Movimientos parciales

Dentro de la [desestructuración] de una variable única, se pueden utilizar enlaces de patrón by-move y by-reference al mismo tiempo. Hacer esto resultará en un movimiento parcial de la variable, lo que significa que partes de la variable se moverán mientras que otras partes permanecerán. En tal caso, la variable padre no se puede utilizar después como un todo, sin embargo las partes que solo se refieren (y no se mueven) todavía se pueden utilizar.

fn main() {
    #[derive(Debug)]
    struct Person {
        name: String,
        age: Box<u8>,
    }

    let person = Person {
        name: String::from("Alice"),
        age: Box::new(20),
    };

    // `name` se mueve fuera de person, pero `age` se referencia
    let Person { name, ref age } = person;

    println!("La edad de la persona es {}", age);

    println!("El nombre de la persona es {}", name);

    // Error! préstamo de valor parcialmente movido: `person` se produce un movimiento parcial
    //println!("La estructura de persona es {:?}", person);

    // `person` no se puede utilizar pero `person.age` se puede utilizar ya que no se mueve
    println!("La edad de la persona de la estructura de persona es {}", person.age);
}

(En este ejemplo, almacenamos la variable age en el montón para ilustrar el movimiento parcial: eliminar ref en el código anterior generaría un error ya que la propiedad de person.age se movería a la variable age. Si Person.age se almacenara en la pila, no se requeriría ref ya que la definición de age copiaría los datos de person.age sin moverlos.)

Resumen

¡Felicitaciones! Has completado el laboratorio de Movimientos Parciales. Puedes practicar más laboratorios en LabEx para mejorar tus habilidades.