Vue

Webman utilise par défaut la syntaxe PHP native comme modèle, offrant les meilleures performances une fois opcache activé. En plus de la syntaxe PHP native, Webman propose également des moteurs de templates tels que Twig, Blade et think-template.

Activer opcache

Lors de l'utilisation des vues, il est fortement recommandé d'activer les options opcache.enable et opcache.enable_cli dans php.ini pour que le moteur de template atteigne les meilleures performances.

Installer Twig

  1. Installation via Composer

composer require twig/twig

  1. Modifier la configuration config/view.php comme suit 
    
<?php
use support\view\Twig;

return [
'handler' => Twig::class
];

> **Conseil**
> D'autres options de configuration peuvent être passées via `options`, par exemple  

```php
return [
    'handler' => Twig::class,
    'options' => [
        'debug' => false,
        'charset' => 'utf-8'
    ]
];

Installer Blade

  1. Installation via Composer
composer require psr/container ^1.1.1 webman/blade
  1. Modifier la configuration config/view.php comme suit 
    
<?php
use support\view\Blade;

return [
'handler' => Blade::class
];


## Installer think-template
1. Installation via Composer

`composer require topthink/think-template`

2. Modifier la configuration `config/view.php` comme suit
```php
<?php
use support\view\ThinkPHP;

return [
    'handler' => ThinkPHP::class,
];

Conseil
D'autres options de configuration peuvent être passées via options, par exemple

return [
    'handler' => ThinkPHP::class,
    'options' => [
        'view_suffix' => 'html',
        'tpl_begin' => '{',
        'tpl_end' => '}'
    ]
];

Exemple de moteur de templates PHP natif

Créer le fichier app/controller/UserController.php comme suit

<?php
namespace app\controller;

use support\Request;

class UserController
{
    public function hello(Request $request)
    {
        return view('user/hello', ['name' => 'webman']);
    }
}

Créer le fichier app/view/user/hello.html comme suit

<!doctype html>
<html>
<head>
    <meta charset="utf-8">
    <title>webman</title>
</head>
<body>
hello <?=htmlspecialchars($name)?>
</body>
</html>

Exemple de moteur de templates Twig

Modifier la configuration config/view.php comme suit

<?php
use support\view\Twig;

return [
    'handler' => Twig::class
];

Le fichier app/controller/UserController.php est comme suit

<?php
namespace app\controller;

use support\Request;

class UserController
{
    public function hello(Request $request)
    {
        return view('user/hello', ['name' => 'webman']);
    }
}

Le fichier app/view/user/hello.html est comme suit

<!doctype html>
<html>
<head>
    <meta charset="utf-8">
    <title>webman</title>
</head>
<body>
hello {{name}}
</body>
</html>

Pour plus de documentation, consultez Twig

Exemple de template Blade

Modifier la configuration config/view.php comme suit

<?php
use support\view\Blade;

return [
    'handler' => Blade::class
];

Le fichier app/controller/UserController.php est comme suit

<?php
namespace app\controller;

use support\Request;

class UserController
{
    public function hello(Request $request)
    {
        return view('user/hello', ['name' => 'webman']);
    }
}

Le fichier app/view/user/hello.blade.php est comme suit

Remarque le suffixe des templates Blade est.blade.php

<!doctype html>
<html>
<head>
    <meta charset="utf-8">
    <title>webman</title>
</head>
<body>
hello {{$name}}
</body>
</html>

Pour plus de documentation, consultez Blade

Exemple de template ThinkPHP

Modifier la configuration config/view.php comme suit

<?php
use support\view\ThinkPHP;

return [
    'handler' => ThinkPHP::class
];

Le fichier app/controller/UserController.php est comme suit

<?php
namespace app\controller;

use support\Request;

class UserController
{
    public function hello(Request $request)
    {
        return view('user/hello', ['name' => 'webman']);
    }
}

Le fichier app/view/user/hello.html est comme suit

<!doctype html>
<html>
<head>
    <meta charset="utf-8">
    <title>webman</title>
</head>
<body>
hello {$name}
</body>
</html>

Pour plus de documentation, consultez think-template

Affectation de valeur aux templates

En plus d'utiliser view(template, variableArray) pour affecter des valeurs aux templates, nous pouvons également le faire à tout moment en appelant View::assign(). Par exemple :

<?php
namespace app\controller;

use support\Request;
use support\View;

class UserController
{
    public function hello(Request $request)
    {
        View::assign([
            'name1' => 'value1',
            'name2'=> 'value2',
        ]);
        View::assign('name3', 'value3');
        return view('user/test', ['name' => 'webman']);
    }
}

View::assign() est très utile dans certaines situations, par exemple lorsqu'une application doit afficher les informations de l'utilisateur connecté dans l'en-tête de chaque page. Si chaque page devait affecter ces informations par view('template', ['user_info' => 'informations de l utilisateur']);, cela deviendrait très compliqué. La solution consiste à obtenir les informations de l'utilisateur dans un middleware, puis à les affecter au template via View::assign().

À propos des chemins de fichiers de vue

Contrôleur

Lorsque le contrôleur appelle view('templateName', []);, les fichiers de vue seront recherchés selon les règles suivantes :

  1. Si le chemin commence par /, il utilise directement ce chemin pour rechercher le fichier de vue
  2. Si cela ne commence pas par / et n'est pas une application multiple, il utilise le fichier de vue correspondant dans app/view/
  3. Si cela ne commence pas par / et est une application multiple, il utilise le fichier de vue correspondant dans app/ApplicationName/view/
  4. Si aucun paramètre de template n'est passé, il recherche automatiquement le fichier de template selon les règles 2 et 3

Exemple :

<?php
namespace app\controller;

use support\Request;

class UserController
{
    public function hello(Request $request)
    {
        // équivalent à return view('user/hello', ['name' => 'webman']);
        // équivalent à return view('/app/view/user/hello', ['name' => 'webman']);
        return view(['name' => 'webman']);
    }
}

Fonction de fermeture

La fonction de fermeture $request->app est vide et n'appartient à aucune application, donc la fonction de fermeture utilise le fichier de vue dans app/view/, par exemple dans config/route.php définir une route

Route::any('/admin/user/get', function (Reqeust $reqeust) {
    return view('user', []);
});

utilisera app/view/user.html comme fichier de template (lors de l'utilisation de templates Blade, le fichier de template sera app/view/user.blade.php).

Application spécifique

Pour que les templates puissent être réutilisés en mode d'application multiple, view($template, $data, $app = null) fournit un troisième paramètre $app, qui peut être utilisé pour spécifier quel répertoire d'application utiliser pour le template. Par exemple view('user', [], 'admin'); forcera l'utilisation du fichier de vue dans app/admin/view/.

Paramètre de template omis

Dans un contrôleur de classe, le paramètre de template peut être omis, par exemple

<?php
namespace app\controller;

use support\Request;

class UserController
{
    public function hello(Request $request)
    {
        // équivalent à return view('user/hello', ['name' => 'webman']);
        // équivalent à return view('/app/view/user/hello', ['name' => 'webman']);
        return view(['name' => 'webman']);
    }
}

Étendre Twig

Nous pouvons étendre l'instance de vue Twig en passant un rappel à la configuration view.extension, par exemple config/view.php comme suit

<?php
use support\view\Twig;
return [
    'handler' => Twig::class,
    'extension' => function (\Twig\Environment $twig) {
        $twig->addExtension(new your\namespace\YourExtension()); // Ajouter une extension
        $twig->addFilter(new \Twig\TwigFilter('rot13', 'str_rot13')); // Ajouter un filtre
        $twig->addFunction(new \Twig\TwigFunction('function_name', function () {})); // Ajouter une fonction
    }
];

Étendre Blade

De même, nous pouvons étendre l'instance de vue Blade en passant un rappel à la configuration view.extension, par exemple config/view.php comme suit

<?php
use support\view\Blade;
return [
    'handler' => Blade::class,
    'extension' => function (Jenssegers\Blade\Blade $blade) {
        // Ajouter une directive à Blade
        $blade->directive('mydate', function ($timestamp) {
            return "<?php echo date('Y-m-d H:i:s', $timestamp); ?>";
        });
    }
];

Utiliser des composants dans Blade

Supposons que nous ayons besoin d'ajouter un composant Alert

Créer app/view/components/Alert.php

<?php

namespace app\view\components;

use Illuminate\View\Component;

class Alert extends Component
{

    public function __construct()
    {

    }

    public function render()
    {
        return view('components/alert')->rawBody();
    }
}

Créer app/view/components/alert.blade.php

<div>
    <b style="color: red">hello blade component</b>
</div>

Le fichier /config/view.php ressemblera à quelque chose comme ceci

<?php
use support\view\Blade;
return [
    'handler' => Blade::class,
    'extension' => function (Jenssegers\Blade\Blade $blade) {
        $blade->component('alert', app\view\components\Alert::class);
    }
];

Ainsi, le composant Blade Alert est configuré, lors de l'utilisation dans le template, cela ressemblera à ceci

<!doctype html>
<html>
<head>
    <meta charset="utf-8">
    <title>webman</title>
</head>
<body>

<x-alert/>

</body>
</html>

Étendre think-template

think-template utilise view.options.taglib_pre_load pour étendre la bibliothèque de tags, par exemple

<?php
use support\view\ThinkPHP;
return [
    'handler' => ThinkPHP::class,
    'options' => [
        'taglib_pre_load' => your\namespace\Taglib::class,
    ]
];

Pour plus de détails, consultez extension de tags think-template