> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Solicitudes HTTP

> Explicamos cómo obtener datos de una solicitud HTTP mediante el objeto Illuminate\Http\Request de Laravel.

## ¿Qué es el objeto Request?

`Illuminate\Http\Request` es una clase para manejar de forma orientada a objetos las solicitudes HTTP que recibe la aplicación.
Da acceso a todo lo que contiene la solicitud: datos de formulario, query string, archivos, cabeceras, etc.

## Inyección de la solicitud en controladores

Al tipar `Illuminate\Http\Request` en un método del controlador, el contenedor de servicios de Laravel inyecta automáticamente la instancia.

```php theme={null}
<?php

namespace App\Http\Controllers;

use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;

class UserController extends Controller
{
    public function store(Request $request): RedirectResponse
    {
        $name = $request->input('name');

        // Guardar el usuario...

        return redirect('/users');
    }
}
```

Se puede tipar del mismo modo en closures de ruta.

```php theme={null}
use Illuminate\Http\Request;

Route::get('/', function (Request $request) {
    // ...
});
```

### Combinación con parámetros de ruta

Si el método también recibe parámetros de ruta, colócalos después de `Request`.

```php theme={null}
use App\Http\Controllers\UserController;

Route::put('/user/{id}', [UserController::class, 'update']);
```

```php theme={null}
public function update(Request $request, string $id): RedirectResponse
{
    // Con $request accedes a los datos de la solicitud y con $id al parámetro de ruta

    return redirect('/users');
}
```

## Obtener datos de la solicitud

### Obtener todos los datos

`all` devuelve todos los datos como array.
Funciona tanto con formularios HTML como con solicitudes XHR.

```php theme={null}
$input = $request->all();
```

### Obtener un campo concreto

`input` obtiene el valor del payload completo (incluida la query string), independientemente del método HTTP.

```php theme={null}
$name = $request->input('name');
```

Puedes pasar un valor por defecto como segundo argumento.

```php theme={null}
$name = $request->input('name', 'Sally');
```

Para entradas en array, usa notación de puntos.

```php theme={null}
$name = $request->input('products.0.name');

$names = $request->input('products.*.name');
```

### Obtener query string

`query` obtiene el valor solo de la query string (lo que va después de `?`).

```php theme={null}
$name = $request->query('name');

$name = $request->query('name', 'Helen');

// Toda la query string como array
$query = $request->query();
```

<Info>
  `input` mira tanto el cuerpo de la solicitud como la query string, mientras que `query` mira solo la query string.
  Usa `query` si necesitas distinguir entre los datos POST del formulario y los parámetros de la URL.
</Info>

### Obtención tipada

Además de `input`, hay métodos específicos para obtener valores con un tipo concreto.

```php theme={null}
// Como string (instancia de Stringable)
$name = $request->string('name')->trim();

// Como entero
$perPage = $request->integer('per_page');

// Como booleano ("1", "true", "on", "yes" → true)
$archived = $request->boolean('archived');

// Como array
$versions = $request->array('versions');

// Fecha como instancia de Carbon
$birthday = $request->date('birthday');
```

### Propiedades dinámicas

También puedes acceder a los campos como propiedades.

```php theme={null}
$name = $request->name;
```

<Tip>
  Con las propiedades dinámicas, primero se busca en el payload y, si no se encuentra, en los parámetros de ruta.
</Tip>

### Obtener un subconjunto

Con `only` y `except` obtienes un subconjunto de los datos.

```php theme={null}
$input = $request->only(['username', 'password']);

$input = $request->except(['credit_card']);
```

## Comprobar la presencia de datos

`has` comprueba si el valor está en la solicitud.

```php theme={null}
if ($request->has('name')) {
    // ...
}

// Comprueba si están presentes todas las claves
if ($request->has(['name', 'email'])) {
    // ...
}
```

Para asegurarte de que además no está vacío, usa `filled`.

```php theme={null}
if ($request->filled('name')) {
    // ...
}
```

Para el caso contrario (no existe o cadena vacía), usa `isNotFilled`.

```php theme={null}
if ($request->isNotFilled('name')) {
    // ...
}
```

## Comprobación de la ruta y el método

### Ruta

```php theme={null}
// Devuelve la ruta (por ejemplo "foo/bar")
$uri = $request->path();

// Comprueba si coincide con un patrón (admite comodín *)
if ($request->is('admin/*')) {
    // ...
}

// Comprueba si coincide con una ruta con nombre
if ($request->routeIs('admin.*')) {
    // ...
}
```

### URL

```php theme={null}
// URL sin query string
$url = $request->url();

// URL con query string
$urlWithQueryString = $request->fullUrl();
```

### Método HTTP

Con `isMethod` puedes comprobar el método HTTP.

```php theme={null}
$method = $request->method();

if ($request->isMethod('post')) {
    // Solo procesa POST
}
```

## Subida de archivos

### Obtener archivos subidos

Obtén los archivos subidos con `file`.
Devuelve una instancia de `Illuminate\Http\UploadedFile`.

```php theme={null}
$file = $request->file('photo');

// También con la propiedad dinámica
$file = $request->photo;
```

Para comprobar si hay archivo, usa `hasFile`.

```php theme={null}
if ($request->hasFile('photo')) {
    // ...
}
```

### Guardar el archivo

Con `store` guardas el archivo en el almacenamiento.
El nombre se genera automáticamente.

```php theme={null}
// Guarda en el directorio "images" del disco por defecto
$path = $request->photo->store('images');

// Guarda en S3
$path = $request->photo->store('images', 's3');
```

Para indicar el nombre, usa `storeAs`.

```php theme={null}
$path = $request->photo->storeAs('images', 'filename.jpg');
```

<Warning>
  Cuando aceptes archivos, valida siempre el tipo y el tamaño.
  Es recomendable usar la validación para procesarlos con seguridad.
</Warning>

## Ejemplo: recepción de datos de formulario

Ejemplo de cómo recibir en el controlador los datos de un formulario de registro.

```php theme={null}
<?php

namespace App\Http\Controllers;

use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;

class RegisterController extends Controller
{
    public function store(Request $request): RedirectResponse
    {
        // Obtiene los datos del formulario
        $name = $request->input('name');
        $email = $request->input('email');
        $password = $request->input('password');

        // Obtiene solo los datos necesarios
        $data = $request->only(['name', 'email', 'password']);

        // Crear el usuario...

        return redirect('/dashboard');
    }
}
```

Define la ruta correspondiente.

```php theme={null}
use App\Http\Controllers\RegisterController;

Route::post('/register', [RegisterController::class, 'store']);
```

## Próximos pasos

<Card title="Middleware" icon="shield" href="/es/middleware">
  Repasa el uso de middleware para filtrar solicitudes.
</Card>


## Related topics

- [Solicitudes de permiso](/es/packages/laravel-copilot-sdk/permission-request.md)
- [Sesión](/es/session.md)
- [Validación](/es/validation.md)
- [Middleware](/es/middleware.md)
- [Controladores](/es/controllers.md)