Super y Self

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, exploramos el uso de las palabras clave super y self en Rust para eliminar la ambigüedad y evitar rutas codificadas manualmente al acceder a elementos.

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


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL rust(("Rust")) -.-> rust/DataTypesGroup(["Data Types"]) rust(("Rust")) -.-> rust/FunctionsandClosuresGroup(["Functions and Closures"]) rust(("Rust")) -.-> rust/MemorySafetyandManagementGroup(["Memory Safety and Management"]) rust(("Rust")) -.-> rust/DataStructuresandEnumsGroup(["Data Structures and Enums"]) 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") subgraph Lab Skills rust/type_casting -.-> lab-99335{{"Super y Self"}} rust/function_syntax -.-> lab-99335{{"Super y Self"}} rust/expressions_statements -.-> lab-99335{{"Super y Self"}} rust/lifetime_specifiers -.-> lab-99335{{"Super y Self"}} rust/method_syntax -.-> lab-99335{{"Super y Self"}} end

super y self

Las palabras clave super y self se pueden usar en la ruta para eliminar la ambigüedad al acceder a elementos y evitar la codificación manual innecesaria de rutas.

fn function() {
    println!("llamado `function()`");
}

mod cool {
    pub fn function() {
        println!("llamado `cool::function()`");
    }
}

mod my {
    fn function() {
        println!("llamado `my::function()`");
    }

    mod cool {
        pub fn function() {
            println!("llamado `my::cool::function()`");
        }
    }

    pub fn indirect_call() {
        // Vamos a acceder a todas las funciones llamadas `function` a partir de este ámbito!
        print!("llamado `my::indirect_call()`, que\n> ");

        // La palabra clave `self` se refiere al ámbito del módulo actual - en este caso `my`.
        // Llamar `self::function()` y llamar `function()` directamente ambos dan
        // el mismo resultado, porque se refieren a la misma función.
        self::function();
        function();

        // También podemos usar `self` para acceder a otro módulo dentro de `my`:
        self::cool::function();

        // La palabra clave `super` se refiere al ámbito padre (fuera del módulo `my`).
        super::function();

        // Esto se vinculará a la `cool::function` en el ámbito del *crate*.
        // En este caso el ámbito del crate es el ámbito más externo.
        {
            use crate::cool::function as root_function;
            root_function();
        }
    }
}

fn main() {
    my::indirect_call();
}

Resumen

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