Learn Rust Coding · Lección

Extractores

Analizar solicitudes

Extractores es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 2 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.

¿Qué es un extractor?

Un extractor es un parámetro del handler que extrae por usted una parte de la solicitud. Axum inspecciona los tipos de los parámetros y los completa.

No es necesario analizar manualmente la solicitud
Se basa en tipos y es componible

Extractor Path

Path captura segmentos dinámicos de la URL. El tipo incluido determina cómo se analiza el segmento.

use axum::extract::Path;

async fn user(Path(id): Path<u32>) -> String {
    format!("user {}", id)
}

Varios parámetros de ruta

Capture varios segmentos extrayendo una tupla. El orden coincide con el patrón de la ruta.

use axum::extract::Path;

async fn item(Path((cat, id)): Path<(String, u32)>) -> String {
    format!("{} / {}", cat, id)
}

Extractor Query

Query deserializa la cadena de consulta de la URL en una estructura mediante serde. Es ideal para filtros y paginación.

use axum::extract::Query;
use serde::Deserialize;

#[derive(Deserialize)]
struct Page { page: u32 }

async fn list(Query(p): Query<Page>) -> String {
    format!("page {}", p.page)
}

Extractor del cuerpo JSON

Json deserializa el cuerpo de una solicitud en una estructura. La estructura debe derivar Deserialize.

use axum::Json;
use serde::Deserialize;

#[derive(Deserialize)]
struct NewUser { name: String }

async fn create(Json(u): Json<NewUser>) -> String {
    format!("created {}", u.name)
}

Extractor de cabeceras

Acceda a las cabeceras con el extractor HeaderMap o con extractores de cabeceras tipados. Es útil para los tokens de autenticación.

use axum::http::HeaderMap;

async fn show(headers: HeaderMap) -> String {
    match headers.get("x-api-key") {
        Some(v) => format!("key: {:?}", v),
        None => "no key".to_string(),
    }
}

El orden de los extractores importa

Los extractores que consumen el cuerpo, como Json, deben ir al final de la lista de parámetros, porque el cuerpo solo puede leerse una vez.

use axum::{Json, extract::Path};
use serde::Deserialize;

#[derive(Deserialize)]
struct Body { value: i32 }

async fn h(Path(id): Path<u32>, Json(b): Json<Body>) -> String {
    format!("{} {}", id, b.value)
}

Modelar la extracción en Rust puro

Extraer consiste simplemente en analizar datos tipados de una solicitud. Aquí deserializamos una cadena similar a una consulta en números.

fn parse_query(q: &str) -> Option<u32> {
    q.strip_prefix("page=")?.parse().ok()
}

fn main() {
    println!("{:?}", parse_query("page=3"));
    println!("{:?}", parse_query("bad"));
}

Extracción opcional

Envuelva un extractor en Option para que no sea fatal. Si falta un valor o no es válido, se obtiene None en lugar de una respuesta de error.

use axum::extract::Query;
use serde::Deserialize;

#[derive(Deserialize)]
struct Filter { q: String }

async fn search(filter: Option<Query<Filter>>) -> String {
    match filter {
        Some(Query(f)) => f.q,
        None => "no filter".to_string(),
    }
}

Rechazos

Cuando falla un extractor, devuelve un rechazo que se convierte en una respuesta de error HTTP. Por ejemplo, un JSON no válido produce automáticamente un 422.

use axum::extract::rejection::JsonRejection;
use axum::Json;

async fn create(body: Result<Json<i32>, JsonRejection>) -> String {
    match body {
        Ok(Json(n)) => format!("ok {}", n),
        Err(_) => "bad body".to_string(),
    }
}

Combinar extractores

Un handler puede usar varios extractores a la vez. Axum completa cada uno con la parte correspondiente de la solicitud.

use axum::{Json, extract::{Path, Query}};
use serde::Deserialize;

#[derive(Deserialize)]
struct Q { sort: String }
#[derive(Deserialize)]
struct B { name: String }

async fn h(Path(id): Path<u32>, Query(q): Query<Q>, Json(b): Json<B>) -> String {
    format!("{} {} {}", id, q.sort, b.name)
}

Comprobación rápida

Compruebe su comprensión de los extractores.

Resumen

Ha aprendido a analizar solicitudes con extractores:

Path para los segmentos de la URL y Query para la cadena de consulta
Json para el cuerpo (debe ir al final)
HeaderMap para las cabeceras
Option y Result gestionan los errores de forma controlada

A continuación: estado compartido y respuestas JSON.

Preguntas frecuentes

¿La lección «Extractores» es gratis?

Sí — el texto completo de «Extractores» 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 «Extractores»?

Analizar solicitudes 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 2 de 4.

¿Cuánto tiempo toma la lección «Extractores»?

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