Rust es un lenguaje de programación multiparadigma como la sintaxis de C++ que fue diseñado para el rendimiento y la seguridad, especialmente la concurrencia segura mediante el uso de un verificador de préstamos y la propiedad para validar las referencias. Las palabras clave self y super proporcionadas por Rust se pueden usar en la ruta para eliminar la ambigüedad al acceder a elementos como funciones.
Ejemplo:
Rust
// Rust program for Super & Self Keywords fn function_with_same_name() { println!("called `function_with_same_name()` which is in the outermost scope"); } mod cool_mod { pub fn function_with_same_name() { println!("called `cool_mod::function_with_same_name()` which is inside the `cool_mod` module in the outermost scope"); } } mod my_mod { fn function_with_same_name() { println!("called `my_mod::function_with_same_name()` which is inside the `my_mod` module"); } mod cool_mod { pub fn function_with_same_name() { println!("called `my_mod::cool_mod:: function_with_same_name()` which is inside the `cool_mod` module which is in turn inside `my_mod` module"); } } pub fn indirect_call() { // Let's access all the functions named //`function_with_same_name` from this scope! print!("called `my_mod::indirect_call()`, that\n> "); // The `self` keyword refers to the current module // scope - in this case `my_mod`. // Calling `self::function_with_same_name()` and // calling `function_with_same_name()` directly both give // the same result, because they refer to the same function. self::function_with_same_name(); function_with_same_name(); // We can also use `self` to access // another module inside `my_mod`: // We have `cool_mod` module inside `my_mod` // module which contains `function_with_same_name` self::cool_mod::function_with_same_name(); // The `super` keyword refers to the parent scope // (outside the `my_mod` module). super::function_with_same_name(); } } fn main() { my_mod::indirect_call(); }
Producción:
Explicación:
- Comenzamos creando una función llamada ‘función_con_mismo_nombre’ (elegimos este nombre para que sea más fácil de entender que estamos usando el mismo nombre para todas las funciones).
- Luego creamos un módulo llamado ‘cool_mod’ que contiene una función pública también llamada ‘function_with_same_name’.
- Después de eso, creamos otro módulo llamado ‘my_mod’ que también contiene un módulo llamado ‘cool_mod’ que a su vez también contiene una función pública llamada ‘function_with_same_name’.
- ‘my_mod’ también contiene una función llamada ‘function_with_same_name’ y una función llamada ‘indirect_call’.
- Ahora veremos qué sucede dentro de la función ‘indirect_call’. La palabra clave ‘self’ se refiere al alcance del módulo actual; en este caso, ‘my_mod’, lo que significa que cuando llamamos a ‘function_with_same_name()’ usando la palabra clave self, llama al ‘function_with_same_name()’ que está presente en el módulo ‘my_mod’.
- Después de eso, cuando llamamos a ‘function_with_same_name()’ sin usar la palabra clave self, el resultado sigue siendo el mismo porque se refieren a la misma función en este ámbito.
- Ahora llamamos a ‘function_with_same_name()’ del módulo ‘cool_mod’ usando la palabra clave self.
- Ahora, al usar la palabra clave super, llamamos a ‘function_with_same_name()’, que llama a la función denominada ‘function_with_same_name’ en el ámbito principal.
- Como puede ver, las palabras clave propias y súper facilitan nuestro trabajo.
Publicación traducida automáticamente
Artículo escrito por mrityunjayshukla411 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA