Laravel: Fonctions d'appel définies dans base_controller from view

En utilisant le framework laravel, comment puis-je appeler une fonction définie dans base_controller, dans une vue. Pour exacmple:

class Base_Controller extends Controller {

    public static function format_something()
    {
         return something;
    }
}

Comment puis-je appeler format_something() dans un fichier de vue?

Généralement l'erreur que je reçois ressemble à quelque chose comme ceci:
Méthode [link_to_action] n'est pas définie sur la classe de la Vue.

Probablement une question stupide, mais merci d'avance!

Modifier

D'accord! D'abord le bon endroit pour faire quelque chose comme ce qui est dans le dossier libraries.
Deuxièmement, le problème est que votre classe ne peut pas avoir des traits de soulignement.

Donc dans l'application/les bibliothèques j'ai fait fichier AppHelper.php avec la classe

class AppHelper {

    public static function format_something()
    {
        return something;
    }
}

Et peut l'appeler comme:

$formated = AppHelper::format_something;

Merci pour l'aide et le bon forum trouver Boofus McGoofus.

source d'informationauteur Jim

  1. 10

    Cette réponse a été écrit pour Laravel 3. Pour Laravel 4 et après, Lajdák de Marek réponse à l'aide du Compositeur de l'autochargeur est mieux.

    Fonctions comme format_something() n'appartiennent pas dans le contrôleur. Le contrôleur doit être juste au sujet de la collecte de données provenant de diverses sources et en passant à la vue. C'est le travail est principalement de routage.

    J'ai créé un dossier appelé "aides" dans le dossier de l'application pour tous mes petits helpery fonctions. Assurez-vous que tous mes contrôleurs, les vues, et les modèles ont accès à eux, j'ai inclus les éléments suivants dans mon start.php fichier:

    foreach(glob(path('app').'helpers/*.php') as $filename) {
    include $filename;
}

    Je soupçonne qu'il y a une meilleure façon de le faire, mais jusqu'à présent, il a travaillé pour moi.

  2. 20

    Pour moi est de travail:

    De créer un répertoire "aides" ou quoi que ce soit et fichier:

    //app/helpers/AppHelper.php

class AppHelper {

    public static function format_something()
    {
        return something;
    }
}

    Ajouter un chemin d'accès au compositeur.json

    //composer.json

    "autoload": {
        "classmap": [
                    "app/helpers"   //<-------- add this line
        ]
    },

    Exécuter: (recharger l'autoload)

    composer dump-autoload

    Maintenant, vous pouvez appeler le: 

    $formated = AppHelper::format_something();
  3. 2

    Vous pouvez vous inspirez-vous de Laravel cadre lui-même.

    Je vais prendre l'exemple d'un module de formatage et de se référer à url aide dans Laravel Cadre.

    Commencez par créer votre propre helpers.php fichier:

    <?php

if (! function_exists('format_that')) {
    /**
     * Generate something
     *
     * @param  string  $text
     * @return string
     */
    function format_that($text)
    {
        return app('formatter')->format_that($text);
    }
}

    Et ajouter à votre composer.json fichier:

    "autoload": {
      "files": [
          "app/helpers/helpers.php"
      ]
}

    Exécutez cette commande pour recréer l'autoload fichier php:

    $ composer dumpautoload

    Créer votre prestataire de services app/Providers/FormatterServiceProvider.php:

    <?php

namespace Illuminate\Routing;

use Illuminate\Support\ServiceProvider;
use App\Helpers\FormatGenerator;

class FormatterServiceProvider extends ServiceProvider
{
    /**
     * Register the service provider.
     *
     * @return void
     */
    public function register()
    {
        $this->app['formatter'] = $this->app->share(function ($app) {
            return new FormatGenerator($app['request']);
        });
    }
}

    Registre votre fournisseur de services. Laravel cadre invoque register méthode, mais vous avez seulement besoin de l'ajouter à votre application fichier config config/app.php:

     'providers' => [


      /*
       * Application Service Providers...
       */
      App\Providers\AppServiceProvider::class,
      //other providers...
      App\Providers\FormatterServiceProvider::class,

 ]

    Enfin, créez votre réel générateur de classe app/Helpers/FormatGenerator.php

    <?php

namespace App\Helpers;

use Illuminate\Http\Request;

class FormatGenerator
{

    protected $request;

    /**
     * Create a new URL Generator instance.
     *
     * @param  \Illuminate\Routing\RouteCollection  $routes
     * @param  \Illuminate\Http\Request  $request
     * @return void
     */
    public function __construct(Request $request)
    {
        $this->request = $request;
    }

    public function format_that($text){
        if ($request->path() == "home"){
            return mb_strtoupper($text);
        }
        else{
            return $text;
        }
    }

}

    Vous pouvez éventuellement créer une Façade app/Facade/Formatter.phppour être en mesure de faire Formatter::format_that($text):

    <?php

namespace App\Facades;

use Illuminate\Support\Facades\Facade;

/**
 * @see \App\Helpers\FormatGenerator
 */

class Formatter extends Facade
{
    protected static function getFacadeAccessor() { return 'formatter'; }
}

    Vous pourriez vous demander:

    • Pourquoi la façade? Vous pouvez réutiliser le composant ailleurs en appelant simplement Formatter::format_that($text) au lieu de app('formatter')->format_that($text). Sucre syntaxe vraiment.
    • Pourquoi le prestataire de Service? La dépendance des injections. Si vous avez besoin d'utiliser Request ou si vous voulez construire un objet complexe, le prestataire prendra en charge pour vous les rendre disponibles dans votre $app objet.