php - comentar - ejemplos de plantillas blade

¿Hay alguna forma de compilar una plantilla blade desde una cadena?

Question

¿Cómo puedo compilar una plantilla blade desde una cadena en lugar de un archivo de vista, como el código a continuación:

<?php
$string = ''<h2>{{ $name }}</h2>'';
echo Blade::compile($string, array(''name'' => ''John Doe'')); 
?>

http://paste.laravel.com/ujL

Answer 1

¡Me acabo de encontrar el mismo requisito! Para mí, tuve que buscar una plantilla blade almacenada en la base de datos y renderizarla para enviar notificaciones por correo electrónico.

Hice esto en la versión 5.8 mediante la clase de Extending /Illuminate/View/View . Así que, básicamente, creé la siguiente clase y lo llamé StringBlade (no pude encontrar un mejor nombre atm: /)

<?php

namespace App/Central/Libraries/Blade;

use Illuminate/Filesystem/Filesystem;

class StringBlade implements StringBladeContract
{
    /**
     * @var Filesystem
    */
    protected $file;

    /**
     * @var /Illuminate/View/View|/Illuminate/Contracts/View/Factory
    */
    protected $viewer;

    /**
     * StringBlade constructor.
     *
     * @param Filesystem $file
     */
    public function __construct(Filesystem $file)
    {
        $this->file = $file;
        $this->viewer = view();
    }

    /**
     * Get Blade File path.
     *
     * @param $bladeString
     * @return bool|string
     */
    protected function getBlade($bladeString)
    {
        $bladePath = $this->generateBladePath();

        $content = /Blade::compileString($bladeString);

        return $this->file->put($bladePath, $content)
            ? $bladePath
            : false;
    }

    /**
     * Get the rendered HTML.
     *
     * @param $bladeString
     * @param array $data
     * @return bool|string
     */
    public function render($bladeString, $data = [])
    {
        // Put the php version of blade String to *.php temp file & returns the temp file path
        $bladePath = $this->getBlade($bladeString);

        if (!$bladePath) {
            return false;
        }

        // Render the php temp file & return the HTML content
        $content = $this->viewer->file($bladePath, $data)->render();

        // Delete the php temp file.
        $this->file->delete($bladePath);

        return $content;
    }

    /**
     * Generate a blade file path.
     *
     * @return string
     */
    protected function generateBladePath()
    {
        $cachePath = rtrim(config(''cache.stores.file.path''), ''/'');
        $tempFileName = sha1(''string-blade'' . microtime());
        $directory = "{$cachePath}/string-blades";

        if (!is_dir($directory)) {
            mkdir($directory, 0777);
        }

        return "{$directory}/{$tempFileName}.php";
    }
}

Como ya puede ver en lo anterior, a continuación se muestran los pasos que se siguen:

1. Primero convirtió la cadena de blade al equivalente de php usando /Blade::compileString($bladeString) .
2. Ahora tenemos que almacenarlo en un archivo físico . Para este almacenamiento, se utiliza el directorio de caché de frameworks - storage/framework/cache/data/string-blades/
3. Ahora podemos pedir a /Illuminate/View/Factory método nativo ''file ()'' para compilar y renderizar este archivo.
4. Elimine el archivo temporal de inmediato (en mi caso no necesito mantener el archivo equivalente de php, probablemente también lo sea para usted)

Y finalmente, creé una fachada en un archivo auto cargado de un compositor para un uso fácil como el siguiente:

<?php

if (! function_exists(''string_blade'')) {

    /**
     * Get StringBlade Instance or returns the HTML after rendering the blade string with the given data.
     *
     * @param string $html
     * @param array $data
     * @return StringBladeContract|bool|string
     */
    function string_blade(string $html, $data = [])
    {
        return !empty($html)
            ? app(StringBladeContract::class)->render($html, $data)
            : app(StringBladeContract::class);
    }
}

Ahora puedo llamarlo desde cualquier lugar como abajo:

<?php

$html = string_blade(''<span>My Name is {{ $name }}</span>'', [''name'' => ''Nikhil'']);

// Outputs HTML
// <span>My Name is Nikhil</span>

Espero que esto ayude a alguien o al menos tal vez inspire a alguien a reescribir de una mejor manera.

¡Aclamaciones!

Answer 2

Encontré la solución extendiendo BladeCompiler.

<?php namespace Laravel/Enhanced;

use Illuminate/View/Compilers/BladeCompiler as LaravelBladeCompiler;

class BladeCompiler extends LaravelBladeCompiler {

    /**
     * Compile blade template with passing arguments.
     *
     * @param string $value HTML-code including blade
     * @param array $args Array of values used in blade
     * @return string
     */
    public function compileWiths($value, array $args = array())
    {
        $generated = parent::compileString($value);

        ob_start() and extract($args, EXTR_SKIP);

        // We''ll include the view contents for parsing within a catcher
        // so we can avoid any WSOD errors. If an exception occurs we
        // will throw it out to the exception handler.
        try
        {
            eval(''?>''.$generated);
        }

        // If we caught an exception, we''ll silently flush the output
        // buffer so that no partially rendered views get thrown out
        // to the client and confuse the user with junk.
        catch (/Exception $e)
        {
            ob_get_clean(); throw $e;
        }

        $content = ob_get_clean();

        return $content;
    }

}

Answer 3

Es una vieja pregunta. Pero encontré un paquete que facilita el trabajo.

Laravel Blade String Compiler representa las plantillas de blade del valor de cadena. Consulte la documentación sobre cómo instalar el paquete.

Aquí hay un ejemplo:

$template = ''<h1>{{ $name }}</h1>'';  // string blade template

return view ([''template'' => $template], [''name'' => ''John Doe'']);

Nota: Este paquete no es compatible con el Laravel 5.7.

Answer 4

No estoy usando blade de esta manera, pero pensé que el método de compilación solo acepta una vista como argumento.

Quizás estés buscando:

Blade::compileString()

Answer 5

Pequeña modificación al script anterior. Puede usar esta función dentro de cualquier clase sin extender la clase BladeCompiler.

public function bladeCompile($value, array $args = array())
{
    $generated = /Blade::compileString($value);

    ob_start() and extract($args, EXTR_SKIP);

    // We''ll include the view contents for parsing within a catcher
    // so we can avoid any WSOD errors. If an exception occurs we
    // will throw it out to the exception handler.
    try
    {
        eval(''?>''.$generated);
    }

    // If we caught an exception, we''ll silently flush the output
    // buffer so that no partially rendered views get thrown out
    // to the client and confuse the user with junk.
    catch (/Exception $e)
    {
        ob_get_clean(); throw $e;
    }

    $content = ob_get_clean();

    return $content;
}