php - variable - ¿Cómo pasar datos a todas las vistas en Laravel 5?

return view laravel

Question

Quiero tener algunos datos predeterminados accesibles en todas las vistas en mi aplicación Laravel 5.

He intentado buscarlo, pero solo he encontrado resultados para Laravel 4. He leído la documentación "Compartir datos con todas las vistas" here pero no puedo entender qué hacer. ¿Dónde se debe colocar el siguiente código?

View::share(''data'', [1, 2, 3]);

Gracias por tu ayuda.

Answer 1

Creo que la mejor manera es con View Composers . Si alguien vino aquí y quiere saber cómo hacerlo con View Composers, lea mi respuesta => ¿Cómo compartir una variable en todas las vistas?

Answer 2

Dentro de su carpeta de configuración puede crear un nombre de archivo php, por ejemplo "variable.php" con el contenido a continuación:

use Illuminate/Support/Facades/View;
use App/Product;

public function boot()
{
    $products = Product::all();
    View::share(''products'', $products);

}

Ahora dentro de todas las vistas puedes usarlo como

config(''variable.versionNumber'')

Answer 3

En la documentación:

Normalmente, realizaría llamadas al método compartido dentro del método de arranque de un proveedor de servicios. Puede agregarlos al AppServiceProvider o generar un proveedor de servicios independiente para alojarlos.

Estoy de acuerdo con Marwelln, solo póngalo en AppServiceProvider en la función de arranque:

public function boot() {
    View::share(''youVarName'', [1, 2, 3]);
}

Recomiendo usar un nombre específico para la variable, para evitar confusiones o errores con otras variables no ''globales''.

Answer 4

Encontré que este es el más fácil. Cree un nuevo proveedor y use el comodín ''*'' para adjuntarlo a todas las vistas. Funciona en 5.3 también :-)

<?php

namespace App/Providers;

use Illuminate/Http/Request;
use Illuminate/Support/ServiceProvider;

class ViewServiceProvider extends ServiceProvider
{
    /**
     * Bootstrap the application services.
     * @return void
     */
    public function boot()
    {
        view()->composer(''*'', function ($view)
        {
            $user = request()->user();

            $view->with(''user'', $user);
        });
    }

    /**
     * Register the application services.
     *
     * @return void
     */
    public function register()
    {
        //
    }
}

Answer 5

Este objetivo se puede lograr a través de diferentes métodos,

1. Usando BaseController

De la forma en que me gusta configurar las cosas, creo una clase BaseController que extiende el propio Controller Laravel y configuro varias cosas globales allí. Todos los demás controladores se extienden desde BaseController lugar del Controlador de Laravel.

class BaseController extends Controller
{
  public function __construct()
  {
    //its just a dummy data object.
    $user = User::all();

    // Sharing is caring
    View::share(''user'', $user);
  }
}

2. Usando filtro

Si sabe con certeza que desea configurar algo para las vistas en cada solicitud en toda la aplicación, también puede hacerlo a través de un filtro que se ejecuta antes de la solicitud; así es como trato con el objeto Usuario en Laravel.

App::before(function($request)
{
  // Set up global user object for views
  View::share(''user'', User::all());
});

O

Puedes definir tu propio filtro

Route::filter(''user-filter'', function() {
    View::share(''user'', User::all());
});

y llamarlo a través de una simple llamada de filtro.

Actualización según la versión 5. *

3. Usando Middleware

Uso de la View::share con middleware

Route::group([''middleware'' => ''SomeMiddleware''], function(){
  // routes
});



class SomeMiddleware {
  public function handle($request)
  {
    /View::share(''user'', auth()->user());
  }
}

4. Usando View Composer

View Composer también ayuda a enlazar datos específicos para ver de diferentes maneras. Puede vincular directamente la variable a una vista específica o a todas las vistas. Por ejemplo, puede crear su propio directorio para almacenar su archivo de composición de vista de acuerdo con los requisitos. y estos archivos del compositor de vistas a través del Servicio proporcionan interactuar con la vista.

El método de ver compositor puede usarse de manera diferente. El primer ejemplo puede parecerse:

Puede crear un directorio App/Http/ViewComposers .

Proveedor de servicio

namespace App/Providers;
use Illuminate/Support/ServiceProvider;
class ViewComposerServiceProvider extends ServiceProvider {
    public function boot() {
        view()->composer("ViewName","App/Http/ViewComposers/TestViewComposer");
    }
}

Después de eso, agregue este proveedor a config / app.php en la sección "proveedores".

TestViewComposer

namespace App/Http/ViewComposers;

use Illuminate/Contracts/View/View;

class TestViewComposer {

    public function compose(View $view) {
        $view->with(''ViewComposerTestVariable'', "Calling with View Composer Provider");
    }
}

ViewName.blade.php

Here you are... {{$ViewComposerTestVariable}}

Este método podría ayudar solo para una vista específica. Pero si desea activar ViewComposer en todas las vistas, tenemos que aplicar este cambio único a ServiceProvider.

namespace App/Providers;
use Illuminate/Support/ServiceProvider;
class ViewComposerServiceProvider extends ServiceProvider {
    public function boot() {
        view()->composer(''*'',"App/Http/ViewComposers/TestViewComposer");
    }
}

Referencia

Documentación Laravel

Para más aclaraciones Episodio de Laracast

Si todavía hay algo poco claro de mi parte, avíseme.

Answer 6

La documentación es escuchar https://laravel.com/docs/5.4/views#view-composers pero lo desglosaré

1. Busque la aplicación de directorio / Proveedores en el directorio raíz de su aplicación y cree el archivo ComposerServiceProvider.php y copie y pegue el siguiente texto en él y guárdelo.

   <?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/ViewComposers/ProfileComposer''
           );
   
           // Using Closure based composers...
           View::composer(''dashboard'', function ($view) {
               //
           });
       }
   
       /**
       * Register the service provider.
       *
       * @return void
       */
       public function register()
       {
           //
       }
   }

2. Desde la raíz de su aplicación, abra Config / app.php y busque la sección Proveedores en el archivo y copie y pegue esta ''Aplicación / Proveedores / ComposerServiceProvider'', a la matriz.

Al hacer esto, hemos creado el proveedor de servicios Composer. Cuando ejecuta su aplicación con la vista Perfil como http://yourdomain/something/profile , se llama al proveedor de servicios ComposerServiceProvider y se instancia la clase App / Http / ViewComposers / ProfileComposer llamando al método Composer debido al código siguiente dentro del Método de arranque o función.

 // Using class based composers...
 View::composer(
   ''profile'', ''App/Http/ViewComposers/ProfileComposer''
 );

3. Si actualiza su aplicación, obtendrá un error porque la clase App / Http / ViewComposers / ProfileComposer aún no existe. Ahora vamos a crearlo.

Vaya a la aplicación de ruta de directorio / Http

• Cree el directorio llamado ViewComposers

• Cree el archivo ProfileComposer.php .

  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());
      }
  }

Ahora ve a tu vista o en este caso Profile.blade.php y agrega

{{ $count }}

y eso mostrará el recuento de usuarios en la página de perfil.

Para mostrar el recuento en todas las páginas cambie

// Using class based composers...
View::composer(
    ''profile'', ''App/Http/ViewComposers/ProfileComposer''
);

A

// Using class based composers...
View::composer(
    ''*'', ''App/Http/ViewComposers/ProfileComposer''
);

Answer 7

La documentación está aquí https://laravel.com/docs/5.4/views#view-composers pero la desglosaré 1. Busque el directorio Proveedores en su directorio raíz y cree el ComposerServiceProvider.php con contenido

Answer 8

La mejor manera sería compartir la variable usando View::share(''var'', $value);

Problemas al componer usando "*" :

Considere el siguiente enfoque:

<?php
// from AppServiceProvider::boot()
$viewFactory = $this->app->make(Factory::class);

$viewFacrory->compose(''*'', GlobalComposer::class);

Desde una vista de hoja de ejemplo:

  @for($i = 0; $i<1000; $i++)
    @include(''some_partial_view_to_display_i'', [''toDisplay'' => $i])
  @endfor

¿Lo que pasa?

• La clase GlobalComposer se instancia 1000 veces usando App::make .
• La composing:some_partial_view_to_display_i evento composing:some_partial_view_to_display_i se maneja 1000 veces.
• La función de compose dentro de la clase GlobalComposer se llama 1000 veces.

Pero la vista parcial some_partial_view_to_display_i no tiene nada que ver con las variables compuestas por GlobalComposer pero aumenta considerablemente el tiempo de renderizado.

Mejor enfoque?

Usando View::share largo de un middleware agrupado.

Route::group([''middleware'' => ''WebMiddleware''], function(){
  // Web routes
});

Route::group([''prefix'' => ''api''], function (){

});

class WebMiddleware {
  public function handle($request)
  {
    /View::share(''user'', auth()->user());
  }
}

Actualizar

Si está utilizando algo que se calcula a través de la tubería de middleware, simplemente puede escuchar el evento adecuado o colocar el middleware de vista compartida en la última parte inferior de la tubería.

Answer 9

Método Laravel 5.6: https://laravel.com/docs/5.6/views#passing-data-to-views

Ejemplo, al compartir una colección de modelos con todas las vistas (AppServiceProvider.php):

use Illuminate/Support/Facades/View; use App/Product; public function boot() { $products = Product::all(); View::share(''products'', $products); }

Answer 10

Puede crear su propio proveedor de servicios (el nombre de ViewServiceProvider es común) o puede usar el AppServiceProvider existente.

En su proveedor seleccionado, ponga su código en el método de arranque.

public function boot() {
    view()->share(''data'', [1, 2, 3]);
}

Esto hará que una variable $data accesible en todas sus vistas.

Si prefiere usar la fachada en lugar del ayudante, cambie view()-> a View:: pero no olvide use View; en la parte superior de tu archivo.