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

# Trait Dumpable

> Aprende cómo añadir dump() / dd() a cualquier clase con Illuminate\Support\Traits\Dumpable y depurar sin romper la cadena de llamadas.

## Qué es el trait Dumpable

`Illuminate\Support\Traits\Dumpable` es un pequeño trait que añade `dump()` y `dd()` a cualquier clase. Se introdujo en Laravel 10 y se usa en Collection, Eloquent Builder, Request y muchas otras clases del core de Laravel para unificar la experiencia de depuración.

Su propósito es sencillo: inspeccionar objetos con algo equivalente a `var_dump` y, si hace falta, detener la ejecución en ese punto.

```mermaid theme={null}
flowchart TD
    A["Llamas a dump()/dd() sobre el objeto"] --> B{"¿Cuál has llamado?"}
    B -- "dump()" --> C["Muestra $this y los argumentos"]
    C --> D["Continúa la ejecución"]
    B -- "dd()" --> E["Muestra $this y los argumentos"]
    E --> F["Termina la ejecución"]
```

## Revisar la implementación

La implementación es muy sencilla: simplemente llama a `dump($this, ...$args)` y `dd($this, ...$args)`.

```php theme={null}
trait Dumpable
{
    public function dump(...$args): static
    {
        dump($this, ...$args);
        return $this;
    }

    public function dd(...$args): never
    {
        dd($this, ...$args);
    }
}
```

<Info>
  La implementación en Laravel 13 está en `src/Illuminate/Support/Traits/Dumpable.php`. La firma real declara `@return $this` y `@return never` mediante PHPDoc.
</Info>

## Usarlo en tus propias clases

Basta con añadir `use Dumpable;` para tener disponibles `dump()` / `dd()` como métodos de instancia.

```php theme={null}
use Illuminate\Support\Traits\Dumpable;

class UserData
{
    use Dumpable;
    
    public function __construct(
        public readonly string $name,
        public readonly string $email,
    ) {}
}

$user = new UserData('Taro', 'taro@example.com');

$user->dump(); // hace dump y continúa
$user->dd();   // hace dump y termina
```

## Depurar en medio de una cadena

Como `dump()` devuelve `static` (en la práctica, `$this`), se puede usar con seguridad en el medio de un method chain.

```php theme={null}
$result = collect([1, 2, 3])
    ->map(fn ($n) => $n * 2)
    ->dump()  // aquí inspeccionas el contenido
    ->filter(fn ($n) => $n > 2)
    ->values();
```

Si lo cambias por `dd()`, la ejecución se detiene en ese punto, lo cual es útil cuando quieres inspeccionar el estado antes de un procesamiento posterior pesado.

## Uso en el desarrollo de paquetes

Si añades `Dumpable` a tus Value Objects, DTOs o Builders, tus usuarios podrán inspeccionar el estado sin necesidad de herramientas adicionales.

<Steps>
  <Step title="Añádelo a un Value Object / DTO">
    ```php theme={null}
    use Illuminate\Support\Traits\Dumpable;

    final class InvoiceData
    {
        use Dumpable;

        public function __construct(
            public readonly string $number,
            public readonly int $total,
        ) {}
    }
    ```
  </Step>

  <Step title="Inspecciona en medio de un Fluent Builder">
    ```php theme={null}
    $payload = (new PackageRequestBuilder)
        ->forUser($userId)
        ->withLocale('es')
        ->dump('before send')
        ->toArray();
    ```
  </Step>
</Steps>

## Pasar argumentos adicionales

Como `Dumpable` internamente llama a `dump($this, ...$args)` / `dd($this, ...$args)`, puedes imprimir información contextual junto al objeto.

```php theme={null}
$user->dump('Punto de depuración A');
// Muestra $this y 'Punto de depuración A' a la vez
```

Es muy útil cuando usas `dump()` en varios sitios: identificas rápidamente en qué punto se produjo cada salida.

## Traits relacionados

<Columns cols={3}>
  <Card title="Helper tap() / Tappable" icon="hand-point-up" href="/es/advanced/tap">
    Aprende el patrón que intercala efectos colaterales devolviendo el valor.
  </Card>

  <Card title="Trait Conditionable" icon="git-branch" href="/es/advanced/conditionable">
    Aprende cómo diseñar bifurcaciones condicionales manteniendo el encadenamiento.
  </Card>

  <Card title="Trait Macroable" icon="puzzle-piece" href="/es/advanced/macroable">
    Aprende cómo extender clases existentes para añadirles métodos propios.
  </Card>
</Columns>


## Related topics

- [Support Contracts (Arrayable / Jsonable / Htmlable / Responsable)](/es/advanced/support-contracts.md)
- [Trait Conditionable](/es/advanced/conditionable.md)
- [SessionEvent](/es/packages/laravel-copilot-sdk/session-event.md)
- [Trait Macroable](/es/advanced/macroable.md)
- [Eloquent Bootable Traits](/es/advanced/eloquent-bootable-traits.md)