Learn Rust Coding · Lección

use y rutas

Importar elementos

use y rutas es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.

incorporar elementos al ámbito

Escribir rutas completas como std::collections::HashMap en todas partes resulta tedioso. La palabra clave use incorpora un elemento al ámbito para que pueda referirse a él mediante un nombre corto.

un use básico

Después de un use, puede referirse al elemento mediante su nombre final. Aquí importamos HashMap y lo usamos directamente.

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();
    scores.insert("ana", 10);
    println!("{:?}", scores.get("ana"));
}

rutas absolutas y relativas

Una ruta absoluta comienza en crate (la raíz del crate). Una ruta relativa comienza en el módulo actual y puede usar opcionalmente self o super.

mod a {
    pub mod b {
        pub fn hi() { println!("hi from b"); }
    }
    pub fn call_b() {
        crate::a::b::hi();
        self::b::hi();
    }
}

fn main() {
    a::call_b();
}

use dentro de módulos

Un use solo afecta al ámbito en el que aparece. Colóquelo al principio de un módulo para acortar los nombres utilizados en todo ese módulo.

mod work {
    use std::collections::HashSet;
    pub fn run() {
        let mut s = HashSet::new();
        s.insert(1);
        s.insert(1);
        println!("size {}", s.len());
    }
}

fn main() {
    work::run();
}

cambiar nombres con as

Cuando dos elementos comparten un nombre o un nombre es demasiado largo, cambie el nombre al importar mediante as.

use std::collections::HashMap as Map;

fn main() {
    let mut m: Map<&str, i32> = Map::new();
    m.insert("x", 1);
    println!("{:?}", m.get("x"));
}

agrupar importaciones

Importe varios elementos de la misma ruta en una sola línea mediante llaves. Así mantiene ordenado el bloque de importaciones.

use std::collections::{HashMap, HashSet};

fn main() {
    let map: HashMap<i32, i32> = HashMap::new();
    let set: HashSet<i32> = HashSet::new();
    println!("{} {}", map.len(), set.len());
}

grupos anidados y self

Dentro de un grupo, self importa el propio módulo junto con sus elementos. Esto permite usar tanto el nombre del módulo como miembros específicos.

use std::io::{self, Write};

fn main() {
    let _ = io::stdout().write_all(b"hello\n");
}

importaciones glob

El glob * incorpora todo lo público de una ruta. Úselo con moderación: puede ocultar de dónde proceden los nombres, aunque es habitual en preludios y pruebas.

mod colors {
    pub fn red() -> &'static str { "red" }
    pub fn blue() -> &'static str { "blue" }
}

use colors::*;

fn main() {
    println!("{} {}", red(), blue());
}

estilo idiomático de importación

Convención: importe las funciones mediante su módulo principal (use std::cmp; cmp::max(...)), pero importe los tipos por su nombre (use std::collections::HashMap;). Así las llamadas se leen con claridad.

use std::cmp;

fn main() {
    println!("{}", cmp::max(3, 9));
}

rutas a crates externos

En el caso de las dependencias, la ruta comienza con el nombre del crate, por ejemplo rand::thread_rng. Incluya el crate en Cargo.toml y, después, importe los elementos del mismo modo que lo hace para std.

mantener limpias las importaciones

Agrupe las importaciones relacionadas, cambie los nombres para evitar conflictos y prefiera las importaciones explícitas a los globs en el código de la aplicación. Unas importaciones limpias facilitan la revisión de un archivo.

comprobación rápida

Compruebe sus conocimientos sobre rutas.

repaso

Ha aprendido a importar elementos:

use incorpora un elemento al ámbito con un nombre abreviado
Las rutas absolutas comienzan en crate; las rutas relativas usan self/super
as cambia nombres, las llaves agrupan y * usa comodines
Importe los tipos por su nombre y las funciones mediante el módulo padre para mejorar la claridad

Preguntas frecuentes

¿La lección «use y rutas» es gratis?

Sí — el texto completo de «use y rutas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.

¿Qué aprenderé en «use y rutas»?

Importar elementos Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Learn Rust Coding?

No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «use y rutas»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?

Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Learn Rust Coding