# Vistas

# Creando vistas

TIP

Para buscar más información sobre ¿Cómo escribir plantillas de Blade? Revisa la documentación de Blade completa para comenzar.

Las vistas contienen el HTML servido por tu aplicación y separa la lógica de tu controlador/aplicación de la lógica de presentación. Las vistas son almacenadas en el directorio resources/views. Una vista sencilla podría lucir de esta forma:

<!-- View stored in resources/views/greeting.blade.php -->

<html>
    <body>
        <h1>Hello, {{ $name }}</h1>
    </body>
</html>

Ya que esta vista es almacenada en resources/views/greeting.blade.php, podemos devolverla usando el helper global view, de la siguiente forma:

Route::get('/', function () {
    return view('greeting', ['name' => 'James']);
});

Como puedes ver, el primer argumento pasado al helper view corresponde al nombre del archivo de la vista en el directorio resources/views. El segundo argumento es un arreglo de datos que debería estar disponible para la vista. En este caso, estamos pasando la variable name, la cual es mostrada en la vista usando la sintaxis de Blade.

Las vistas también pueden estar anidadas dentro de sub-directorios del directorio resources/views. La notación de "Punto" puede ser usada para referenciar vistas anidadas. Por ejemplo, si tu vista está almacenada en resources/views/admin/profile.blade.php, puedes hacer referencia a esta de la siguiente forma:

return view('admin.profile', $data);

# Determinando si una vista existe

Si necesitas determinar si una vista existe, puedes usar la clase facade View. El método exists devolverá true si la vista existe:

use Illuminate\Support\Facades\View;

if (View::exists('emails.customer')) {
    //
}

# Creando la primera vista disponible

Usando el método first, puedes crear la primera vista que existe en un arreglo de vistas dado. Esto es útil si tu aplicación o paquete permite que las vistas sean personalizadas o sobrescritas:

return view()->first(['custom.admin', 'admin'], $data);

También puedes ejecutar este método por medio de la clase facade View:

use Illuminate\Support\Facades\View;

return View::first(['custom.admin', 'admin'], $data);

# Pasando datos a las vistas

Como viste en los ejemplos previos, puedes pasar un arreglo de datos a las vistas:

return view('greetings', ['name' => 'Victoria']);

Al momento de pasar información de esta manera, los datos deberían ser un arreglo con pares clave / valor. Dentro de tu vista, entonces puedes acceder a cada valor usando su clave correspondiente, tal como <?php echo $key; ?>. Como una alternativa a pasar un arreglo completo de datos a la función helper view, puedes usar el método with para agregar partes individuales de datos a la vista:

return view('greeting')->with('name', 'Victoria');

# Compartiendo datos con todas las vistas

Ocasionalmente, puedes necesitar compartir una pieza de datos con todas las vistas que son renderizadas por tu aplicación. Puedes hacer eso usando el método share de la clase facade View. Típicamente, deberías colocar las ejecuciones a share dentro del método boot de un proveedor de servicio. Eres libre de agregarlos al AppServiceProvider o generar un proveedor de servicio diferente para alojarlos:

<?php

namespace App\Providers;

use Illuminate\Support\Facades\View;

class AppServiceProvider extends ServiceProvider
{
    /**
    * Bootstrap any application services.
    *
    * @return void
    */
    public function boot()
    {
        View::share('key', 'value');
    }

    /**
    * Register the service provider.
    *
    * @return void
    */
    public function register()
    {
        //
    }
}

# View Composers

Los view composers son funciones de retorno o métodos de clase que son ejecutados cuando una vista es renderizada. Si tienes datos que quieres que estén enlazados a una vista cada vez que la vista es renderizada, un view composer puede ayudarte a organizar esa lógica dentro de una sola ubicación.

Para este ejemplo, vamos a registrar los View Composers dentro de un proveedor de servicio. Usaremos la clase facade View para acceder a la implementación de contrato Illuminate\Contracts\View\Factory subyacente. Recuerda, Laravel no incluye un directorio predeterminado para los View Composers. Eres libre de organizarlos del modo que desees. Por ejemplo, podrías crear un directorio app/Http/View/Composers:

<?php

namespace App\Providers;

use Illuminate\Support\Facades\View;
use Illuminate\Support\ServiceProvider;

class ComposerServiceProvider extends ServiceProvider
{
    /**
    * Register bindings in the container.
    *
    * @return void
    */
    public function boot()
    {
        // Using class based composers...
        View::composer(
            'profile', 'App\Http\View\Composers\ProfileComposer'
        );

        // Using Closure based composers...
        View::composer('dashboard', function ($view) {
            //
        });
    }

    /**
    * Register the service provider.
    *
    * @return void
    */
    public function register()
    {
        //
    }
}

Nota

Recuerda, si creas un nuevo proveedor de servicio para contener tus registros de View Composers, necesitarás agregar el proveedor de servicio al arreglo providers en el archivo de configuración config/app.php.

Ahora que hemos registrado el Composer, el método ProfileComposer@compose será ejecutado cada vez que la vista profile esté siendo renderizada. Así que, vamos a definir la clase composer:

<?php

namespace App\Http\View\Composers;

use App\Repositories\UserRepository;
use Illuminate\View\View;

class ProfileComposer
{
    /**
    * The user repository implementation.
    *
    * @var UserRepository
    */
    protected $users;

    /**
    * Create a new profile composer.
    *
    * @param  UserRepository  $users
    * @return void
    */
    public function __construct(UserRepository $users)
    {
        // Dependencies automatically resolved by service container...
        $this->users = $users;
    }

    /**
    * Bind data to the view.
    *
    * @param  View  $view
    * @return void
    */
    public function compose(View $view)
    {
        $view->with('count', $this->users->count());
    }
}

Justo antes de que la vista sea renderizada, el método compose del Composer es ejecutado con la instancia Illuminate\View\View. Puedes usar el método with para enlazar datos a la vista.

TIP

Todos los View Composers son resueltos por medio del contenedor de servicio, de modo que puedas colocar la referencia a cualquiera de las dependencias que necesites dentro de un constructor del Composer.

# Adjuntando un composer a múltiples vistas

Puedes adjuntar un View Composer a múltiples vistas de una vez al pasar un arreglo de vistas como primer argumento del método composer:

View::composer(
    ['profile', 'dashboard'],
    'App\Http\View\Composers\MyViewComposer'
);

El método composer también acepta el caracter * como un comodín, permitiendo que adjuntes un Composer a todas las vistas:

View::composer('*', function ($view) {
    //
});

# View Creators

View Creators (creadores de vistas) son muy similares a los View Composers; sin embargo, son ejecutados inmediatamente después de que la vista sea instanciada en lugar de esperar hasta que la vista sea renderizada. Para registrar un View Creator, usa el método creator:

View::creator('profile', 'App\Http\View\Creators\ProfileCreator');