Jak przekazać dane do wszystkich widoków w Laravel 5?

Chcę, aby niektóre domyślne dane były dostępne we wszystkich widokach w mojej aplikacji Laravel 5.

Próbowałem go wyszukać, ale znalazłem tylko wyniki dla Laravel 4. Przeczytałem tutaj dokumentację „Udostępnianie danych ze wszystkimi widokami” , ale nie rozumiem, co robić. Gdzie należy umieścić poniższy kod?

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

Dzięki za pomoc.

Cel ten można osiągnąć różnymi metodami,

1. Korzystanie z BaseController

Sposób, w jaki lubię to konfigurować, BaseControllertworzę klasę, która rozszerza klasę Laravela Controlleri konfiguruję tam różne globalne rzeczy. Wszystkie inne kontrolery następnie pochodzą z kontrolera BaseControllerzamiast 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. Korzystanie z filtra

Jeśli wiesz na pewno, że chcesz coś ustawiać dla widoków na każde żądanie w całej aplikacji, możesz to również zrobić za pomocą filtru, który działa przed żądaniem - tak mam do czynienia z obiektem User w Laravel.

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

LUB

Możesz zdefiniować własny filtr

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

i wywołaj to za pomocą prostego wywołania filtra.

Aktualizacja zgodnie z wersją 5. *

3. Korzystanie z oprogramowania pośredniego

Korzystanie z View::sharewithmiddleware

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



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

4. Korzystanie z programu View Composer

View Composer pomaga również w wiązaniu określonych danych do wyświetlania na różne sposoby. Możesz bezpośrednio powiązać zmienną z określonym widokiem lub wszystkimi widokami. Na przykład możesz utworzyć własny katalog do przechowywania pliku kompozytora widoku zgodnie z wymaganiami. a te widok pliku kompozytora za pośrednictwem usługi zapewniają interakcję z widokiem.

Zobacz metodę kompozytora można użyć w inny sposób, pierwszy przykład może wyglądać podobnie:

Możesz stworzyć App\Http\ViewComposerskatalog.

Dostawca usługi

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

Następnie dodaj tego dostawcę do config / app.php w sekcji „dostawcy”.

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}}

Ta metoda może pomóc tylko w przypadku określonego widoku. Ale jeśli chcesz wyzwolić ViewComposer do wszystkich widoków, musimy zastosować tę pojedynczą zmianę do ServiceProvider.

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

Odniesienie

Dokumentacja Laravel

Dalsze wyjaśnienia - odcinek Laracast

Jeśli nadal coś jest niejasne z mojej strony, daj mi znać.

Możesz utworzyć własnego usługodawcę ( ViewServiceProvidernazwa jest powszechna) lub skorzystać z istniejącego AppServiceProvider.

W wybranym dostawcy umieść kod w metodzie rozruchu.

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

Dzięki temu $datazmienna będzie dostępna we wszystkich widokach.

Jeśli wolisz używać elewacji zamiast pomocnika, zmień view()->ją, View::ale nie zapomnij umieścić jej use View;na początku pliku.

Okazało się, że jest to najłatwiejsze. Utwórz nowego dostawcę i '*'użyj symbolu wieloznacznego, aby dołączyć go do wszystkich widoków. Działa również w 5.3 :-)

<?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()
    {
        //
    }
}

Najlepszym sposobem byłoby udostępnienie zmiennej za pomocą View::share('var', $value);

Problemy z komponowaniem przy użyciu "*":

Rozważ następujące podejście:

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

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

Z przykładowego widoku ostrza:

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

Co się dzieje?

• GlobalComposerKlasy jest tworzony 1000 razy użyciu App::make.
• Wydarzenie composing:some_partial_view_to_display_ijest obsługiwane 1000 razy.
• composeFunkcji wewnątrz GlobalComposerklasy nazywa się 1000 razy.

Ale widok częściowy some_partial_view_to_display_inie ma nic wspólnego ze zmiennymi składającymi się z, GlobalComposerale znacznie wydłuża czas renderowania.

Najlepsze podejście?

Korzystanie View::sharez zgrupowanego oprogramowania pośredniego.

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

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

});

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

Aktualizacja

Jeśli używasz czegoś, co jest obliczane za pośrednictwem potoku oprogramowania pośredniego, możesz po prostu nasłuchiwać odpowiedniego zdarzenia lub umieścić oprogramowanie pośredniczące udziału widoku na ostatnim dole potoku.

W dokumentacji:

Zazwyczaj wywołanie metody udostępniania jest wykonywane w ramach metody rozruchu dostawcy usług. Możesz dodać je do AppServiceProvider lub wygenerować oddzielnego dostawcę usług, aby je pomieścić.

Zgadzam się z Marwellnem, po prostu wstaw to w AppServiceProviderfunkcji rozruchu:

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

Zalecam użycie określonej nazwy zmiennej, aby uniknąć nieporozumień lub błędów z innymi zmiennymi nie „globalnymi”.

Dokumentację słychać https://laravel.com/docs/5.4/views#view-composers, ale ja ją rozbiję

1. Poszukaj katalogu app \ Providers w katalogu głównym swojej aplikacji i utwórz plik ComposerServiceProvider.php, a następnie skopiuj i wklej poniższy tekst do niego i zapisz go.

   <?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. Z katalogu głównego aplikacji otwórz plik Config / app.php i poszukaj sekcji Providers w pliku, a następnie skopiuj i wklej to „App \ Providers \ ComposerServiceProvider” do tablicy.

W ten sposób stworzyliśmy dostawcę usług Composer. Po uruchomieniu aplikacji z widokiem Profil, takim jak http: // twoja_domena / coś / profil , wywoływany jest dostawca usług ComposerServiceProvider, a instancja klasy App \ Http \ ViewComposers \ ProfileComposer jest wywoływana metodą Composer ze względu na poniższy kod w metoda lub funkcja rozruchu.

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

3. Jeśli odświeżysz aplikację, pojawi się błąd, ponieważ klasa App \ Http \ ViewComposers \ ProfileComposer jeszcze nie istnieje. Teraz stwórzmy to.

Przejdź do ścieżki katalogu app / Http

• Utwórz katalog o nazwie ViewComposers

• Utwórz plik 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());
      }
  }
  

Teraz przejdź do swojego widoku lub w tym przypadku Profile.blade.php i dodaj

{{ $count }}

i to pokaże liczbę użytkowników na stronie profilu.

Aby wyświetlić liczbę na wszystkich stronach, zmień

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

Do

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

Myślę, że najlepszym sposobem jest View Composers. Jeśli ktoś tu przyszedł i chce się dowiedzieć, jak to zrobić za pomocą View Composers, przeczytaj moją odpowiedź => Jak udostępnić zmienną we wszystkich widokach?

Dokumentacja jest tutaj https://laravel.com/docs/5.4/views#view-composers, ale ja ją podzielę 1. Poszukaj dostawców katalogów w katalogu głównym i utwórz dla ComposerServiceProvider.php z zawartością

Wewnątrz folderu konfiguracyjnego możesz utworzyć plik php, nazwij go na przykład „zmienna.php” z zawartością poniżej:

<?php

  return [
    'versionNumber' => '122231',
  ];

Teraz we wszystkich widokach możesz to wykorzystać

config('variable.versionNumber')

1) W (app \ Providers \ AppServiceProvider.php)

// in boot function
       view()->composer('*', function ($view) {
            $data = User::messages();
            $view->with('var_messages',$data);
        });

2) w Twoim modelu użytkownika

  public static function messages(){ // this is just example
        $my_id = auth()->user()->id;
        $data= Message::whereTo($my_id)->whereIs_read('0')->get(); 
        return $data; // return is required
    }

3) w Twojej opinii

 {{ $var_messages }}

Metoda Laravel 5.6: https://laravel.com/docs/5.6/views#passing-data-to-views

Przykład z udostępnieniem kolekcji modeli wszystkim widokom (AppServiceProvider.php):

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

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

}

Masz dwie możliwości:

1. udostępnij za pomocą funkcji rozruchu w App \ Providers \ AppServiceProvider

public function boot() { view()->share('key', 'value'); }

I uzyskaj dostęp do zmiennej $ key w dowolnym pliku widoku.

Uwaga: pamiętaj, że nie możesz tutaj uzyskać dostępu do danych bieżącej sesji, uwierzytelnienia i trasy. Ta opcja jest dobra tylko wtedy, gdy chcesz udostępniać dane statyczne. Załóżmy, że chcesz udostępnić pewne dane na podstawie bieżącego użytkownika, trasy lub dowolnej niestandardowej zmiennej sesji, której nie będziesz w stanie z tym zrobić.

2. Użycie klasy pomocniczej Utwórz klasę pomocniczą w dowolnym miejscu aplikacji i zarejestruj ją w tablicy Alias ​​w pliku app.php w folderze konfiguracyjnym.

'aliases' => [ ..., 'Helper' => App\HelperClass\Helper::class, ],

i utwórz plik Helper.php w folderze HelperClass w folderze aplikacji

namespace App\HelperClass;

class Helper
{
    public static function Sample()
    {
        //Your Code Here
    }
}

i uzyskaj do niego dostęp w dowolnym miejscu Helper::Sample()

Nie będziesz tutaj ograniczony do korzystania z Auth, Route, Session ani żadnych innych klas.