MVC development mode and the use of Smarty template engine

Linux global installation composer

Switch the directory to the / usr/local/bin / directory
    cd /usr/local/bin/
Download composer in bin directory
    curl -sS https://getcomposer.org/installer | php
 View composer through composer.phar -v
 Change to Chinese image
    composer.phar config -g repo.packagist composer https://packagist.phpcomposer.com
 Finally, I copied composer.phar and renamed it composer
 You can use composer directly in the future

MVC architecture mode
Controller - responsible for forwarding and processing requests
View - graphic interface design by Interface Designer
Model - the function that the programmer should have to write the program (to realize the algorithm, etc.), the database expert to manage the data and design the database (to realize the specific function)

Implement simple template engine:

composer.json

    {
      // Automatic loading
      // Can be in composer.json Of autoload Field find the one to add its own autoloader
      "autoload": {
        "psr-4": {
          "App\\Controllers\\": "Controllers/",
          "App\\Models\\": "Models/",
          "Tools\\": "Tools/"
        }
      }
    }

Models/Users.php

    <?php
    // model Operation demonstration of layer database
    namespace App\Models;

    class Users
    {
        // Data storage database demonstration
        public function store()
        {
            echo 'store into database';
        }

        // Query database presentation
        public function getUsername()
        {
            // query data base
            return 'test-data';
        }
    }

Controllers/UserController.php

    <?php
    namespace App\Controllers;

    use Tools\Tpl;
    use App\Models\Users;

    class UserController extends Tpl
    {
        public function create()
        {
            echo 'User create';
        }

        public function getUser()
        {
            // adopt Model Query data
            $userModel = new Users;
            $username = $userModel->getUsername();

            // take $username Display in the corresponding one HTML In the document, and display
            // Presentation layer user/user.html
            // Send variables to template( html Document)
            $this->assign('username', $username);
            $this->assign('age', 20);
            // Display template
            $this->display('user/user.html');
        }
    }

Views/user/user.html

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
        <h2>
            {$username}
        </h2>
        <h3>
            {$age}
        </h3>
    </body>
    </html>

Tools/Tpl.php

    <?php
    // Distribution variables
    // Send variables to template
    namespace Tools;

    class Tpl
    {
        protected $assign_vars = [];

        public function assign($tpl_var_name, $val)
        {
            $this->assign_vars[$tpl_var_name] = $val;
        }

        public function display($tpl_name)
        {
            // Views/user/$tpl_name
            $className = get_called_class(); // App\Controllers\UserController
            $dirName = strtolower(substr(substr($className, 16), 0, -10)); // user
            $dir = dirname(__DIR__) . '/Views/' . $dirName . '/' . $tpl_name;
            // file_get_contents
            $content = file_get_contents($dir);
            // preg_replace
            foreach ($this->assign_vars as $tpl_var_name => $val) {
                $content = preg_replace('/\{\$' . $tpl_var_name . '\}/', '<?php echo $this->assign_vars["' . $tpl_var_name . '"]; ?>', $content);
            }
            // compile
            $compile = dirname(__DIR__) . '/runtime/Compile/' . md5($tpl_name) . '.php';
            file_put_contents($compile, $content);
            // include
            include $compile;
        }
    }

Smarty template engine usage

Demonstration of server development
Smarty engine installation
Variable assignment and loading display template
Extend Smarty as a plug-in
Cache control technology

smarty.php

    <?php
    /**
     * Created by PhpStorm.
     */
    session_start();
    require './libs/Smarty.class.php';

    $smarty = new Smarty();

    // Simple configuration initialization settings
    $smarty->setTemplateDir('./Views');
    $smarty->setCompileDir('./runtime/Compile');
    $smarty->setConfigDir('./Config');
    $smarty->addPluginsDir('./Plugins');
    $smarty->setCacheDir('./runtime/Cache');

    $smarty->caching = 1;//Open cache
    $smarty->setCacheLifetime(60*60*24);
    $smarty->left_delimiter = '{';
    $smarty->right_delimiter = '}';

    // Cache mechanism
    if (!$smarty->isCached('extends.html', $_SERVER['REQUEST_URI'])) {

        // Database query
        $data = [[]];

        // Use 
        $smarty->assign([
            'username' => 'test-data',
            'age' => 20
        ]);

        // array
        $smarty->assign('arr1', [1, 2, 3]);
        $smarty->assign('arr2', ['id' => 1, 'username' => 'zhangsan', 'age' => 30]);
        $smarty->assign('users', [
            ['id' => 1, 'username' => 'zhangsan', 'age' => 30],
            ['id' => 2, 'username' => 'lisi', 'age' => 40]
        ]);

        $smarty->assign('hobby_ids', [1, 2, 3]);
        $smarty->assign('hobby_output', ['Read a Book', 'Knock code', 'Watch videos']);
        $smarty->assign('options', [
            1 => 'Read a Book',
            2 => 'Knock code',
            3 => 'Watch videos'
        ]);

        // register function
        $smarty->registerPlugin('function', 'font', function ($attributes) {
           $text = $attributes['text'];
           $color = $attributes['color'] ?? 'black';
           return '<span style="color: ' . $color . '">' . $text . '</span>';
        });

        // Register variable modifier
        $smarty->registerPlugin('modifier', 'link', function ($text, $href, $isCapitalize = false) {
           $return = '<a href="' . $href . '">' . $text . '</a>';
           if ($isCapitalize) {
               return ucwords($return);
           }
           return $return;
        });
        
        // Register block function
        $smarty->registerPlugin('block', 'link', function ($attributes, $text) {
           $href = $attributes['href'];
           if (!is_null($text)) {
               return '<a href="' . $href . '">' . $text . '</a>';
           }
        });

        // object
        $smarty->assign('obj', $smarty);

        $smarty->assign('text', 'This is a paragraph!');

        $smarty->display('smarty.html');
        $smarty->display('loop.html');
        $smarty->display('single_tag_func.html');
        $smarty->display('modifier.html');
        $smarty->display('block_func.html');
        $smarty->display('plugins.html');
        $smarty->assign('users', $data);
    }
    $smarty->clearCache('extends.html', $_SERVER['REQUEST_URI']);
    $smarty->clearAllCache();
    $smarty->display('extends.html', $_SERVER['REQUEST_URI']);

Demonstration of front end development

Use of comments and variables smart.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h2>
        <!-- Template comments are*Surrounded by asterisks, the asterisks on both sides are surrounded by delimiters -->
        {*$username*}
        {$username}
    </h2>
    <h3>
        <!-- variable -->
        {$age}
    </h3>
    <hr>
        <!-- Index array -->
        arr1:
        {$arr1[1]}
    <hr>
        <!-- Associative array -->
        arr2:
        {$arr2['username']}
        {$arr2.username}
    <hr>
        <!-- object -->
        Object:
        {var_dump($obj->getTemplateDir())}
    <hr>
        <!-- Variable operation -->
        {$var = 100}
        {$var}
        {$foo = $var + 200}
        {$foo}
    <hr>
        {$foo}
    <hr>
        <!-- Use of reserved variables -->
        $_GET:
        {var_dump($smarty.get)}
    <hr>
        $_POST:
        {var_dump($smarty.post)}
    <hr>
        $_REQUEST:
        {var_dump($smarty.request)}
    <hr>
        COOKIE:
        {var_dump($smarty.cookies)}
    <hr>
        SESSION:
        {var_dump($smarty.session)}
    <hr>
        SERVER:
        {var_dump($smarty.server)}
    <hr>
        ENV:
        {var_dump($smarty.env)}
    <hr>
        {time()}
        {$smarty.now}
    <hr>
        <!-- After loading the configuration file, the variables in the configuration file need to use two well numbers“#"Surround or smarty Reserved variables for $smarty.config.To invoke -->
        {config_load file='base.conf'}
        {#FONT_SIZE#}
        {$smarty.config.FONT_COLOR}
</body>
</html>

Using loop.html for process control

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Process control</title>
</head>
<body>
   <!--  Use{if}Processing branch structure -->
    {$number = 200}
    {if $number === 100}
        gt
    {else if $number == 200}
        This number is 200
    {else}
        This number is not 100
    {/if}

    {$bool = false}
    {if not $bool}
        not
    {/if}

    {if $number is not even}
        odd
    {/if}

    {if $number is not odd}
        even
    {/if}

    {if $number mod 2 == 0}
        even
    {/if}

    {if $number is not odd by 3}
        odd
    {/if}

    <!-- Use{for}Processing cycle -->
    {for $i = 5 to 4 step 2}
        {$i}
    {forelse}
        no loop
    {/for}

    <!-- Use{while}Processing cycle -->
    {while $number > 195}
        {$number--}
    {/while}

    <!-- Use{foreach}Traversing array -->
    {foreach $arr2 as $key => $val}
        {if $val@first}
            {*break*}
            {continue}
        {/if}
        {$key}:{$val}
        {$val@key}
        {$val@index}
        {$val@iteration}
        {$val@first}
        {$val@last}
        {$val@show}
        {$val@total}
    {foreachelse}
        data does not exist
    {/foreach}

    <!-- Use{section}Traversing array -->
    {section name=key loop=$arr1}
        {$arr1[key]}
    {/section}

    {section name=key loop=$users2 step=-1 max=2}
        id: {$users[key].id}
        username: {$users[key].username}
        age: {$users[key].age}
        {$smarty.section.key.index}
        {$smarty.section.key.iteration}
        {$smarty.section.key.rownum}
        {$smarty.section.key.index_prev}
        {$smarty.section.key.index_next}
    {sectionelse}
        no loop
    {/section}

</body>
</html>

Use of common tag functions single tag func.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Use of common label functions</title>
</head>
<body>
    {assign var="name" value="Jason"}
    {assign "name" "Jason Lee"}
    {$name}

    {append var="arr1" value=4 index="3"}
    {var_dump($arr1)}

    {ldelim}$name{rdelim}

    {html_checkboxes name="hobby" values=$hobby_ids output=$hobby_output selected=$hobby_ids}
    {html_checkboxes name="hobby" options=$options selected=$hobby_ids}
    {html_image width="50" height="50" alt="Google" href="http://www.google.com" file="https://www.google.com/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png"}
    {html_options name="hobby" values=$hobby_ids output=$hobby_output selected=2}
    {html_options name="hobby" options=$options selected=2}
    {html_radios name="hobby" options=$options selected=2}
    {html_select_date}
    {html_select_time}
    {html_table loop=$arr1 cols=2 rows=3}
    {mailto address="86267659@qq.com" subject="test" text="Email me" cc="123123@qq.com"}
    {math equation="x + y" x = 100 y = 200}
</body>
</html>

Using variable modifier.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Use of variable modifiers</title>
</head>
<body>
    {$str="123123\nthIs is string."}
    <hr>
    {$str|capitalize:true:true}
    <hr>
    {$str|capitalize:true:true|cat:'.'}
    <hr>
    {$str|count_characters}
    <hr>
    {$str|count_paragraphs}
    <hr>
    {$str|count_sentences}
    <hr>
    {$str|count_words}
    <hr>
    {$str2|default:'Not Data Yet'}
    <hr>
    {time()|date_format:'%Y-%m-%d %H:%M:%S'}
    <hr>
    {$chinese = 'Chinese'}
    {$chinese|from_charset:'utf-8'|to_charset:'gb2312'}
    <hr>
    {$str|indent:10:'---'}
    <hr>
    {$str|lower|upper}
    <hr>
    {$str2="This is p1.\nThis is p2."}
    {$str2|nl2br}
    <hr>
    {$str|regex_replace:'/\d+/':' '}
    <hr>
    {$str|replace:'123123':'000'}
    <hr>
    {$str|spacify:'-'}
    <hr>
    {$float='10.0020398475'}
    {$float|string_format:'%.2f'}
    <hr>
    {$str3='a     b     c'}
    {$str3|strip:'-'}
    <hr>
    {$tag='<b>Font</b>'}
    {$tag|strip_tags}
    <hr>
    {$bigstr='123123123123123123ahjfdashfksdhfkjsdhjkfshfjkhsd'}
    {$bigstr|truncate:10:'---':true:true}
    <hr>
    {$tag|escape|unescape}
    <hr>
    {$bigstr|wordwrap:10:"\n":true}
</body>
</html>

Block func.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Use of block functions</title>
</head>
<body>
    {textformat indent='4' indent_first='10' indent_char='-' wrap='10' wrap_char='<hr>' wrap_cut=true assign='var'}
    aaaaaaaaaaaaaaa
    aaaaaaaaaaaaaaa
    aaaaaaaaaaaaaaa
    aaaaaaaaaaaaaaa
    aaaaaaaaaaaaaaa
    aaaaaaaaaaaaaaa
    aaaaaaaaaaaaaaa
    {/textformat}

    {*$var*}

    {nocache}
        {time()}
    {/nocache}
    <hr>
    {time()}
</body>
</html>

Plug in development plugins.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    {font text=$text color='#123123'}
    {$text|link:'http://www.baidu.com'}
    {link href='http://www.baidu.com'}
        aaaaaaaaaaaaaaaaa
        aaaaaaaaaaaaaaaaa
        aaaaaaaaaaaaaaaaa
        aaaaaaaaaaaaaaaaa
        aaaaaaaaaaaaaaaaa
        aaaaaaaaaaaaaaaaa
        aaaaaaaaaaaaaaaaa
    {/link}
</body>
</html>

Smarty template engine plug in development:
1. Using the registerPlugin() method to extend the plug-in format

2. Create function plug-in file in libs/plugins / directory of smart template

block.link.php

function smarty_block_link($attributes, $text)
{
    $href = $attributes['href'];
    if (!is_null($text)) {
        return '<a href="' . $href . '">' . $text . '</a>';
    }
}

function.font.php

function smarty_function_font($attributes)
{
    $text = $attributes['text'];
    $color = $attributes['color'] ?? 'black';
    return '<span style="color: ' . $color . '">' . $text . '</span>';
}

modifier.link.php

function smarty_modifier_link($text, $href, $isCapitalize = false)
{
    $return = '<a href="' . $href . '">' . $text . '</a>';
    if ($isCapitalize) {
        return ucwords($return);
    }
    return $return;
}

Use of template inheritance
extends.html

!-- Use{extends}Function implementation template inheritance
//Merge the {block} label content of child and parent templates -- >

{extends file="layout.html"}
{block name="title"}
    Article {$smarty.block.parent}
{/block}

{block name="content"}
    Article List
    {$smarty.get.page}
    {*nocache*}
        {time()}
    {*/nocache*}
    {time()|date_format:'%H:%M:%S' nocache}
{/block}

layout.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>{block name="title"} - Imooc{/block}</title>
</head>
<body>
    <header>
        menu
    </header>
    {block name="content"}{/block}
    <footer>
        copyright
    </footer>
</body>
</html>

Cache mechanism
Open cache
　　$smarty -> caching = 1|2|0;
　　$smarty -> setCacheDir("./cache");
$smart - > setcachelifetime (300); / / 5 minutes in seconds, - 1 never expires
　　$smarty -> display('index.tpl');
　　$smarty -> display('index.tpl', $_SERVER['REQUEST_URI']);

correlation function
　　isCached()
　　clearCache()
　　clearAllCache()

Posted by pbs on Thu, 16 Jan 2020 00:22:31 -0800

Programmer Group

MVC development mode and the use of Smarty template engine

Hot Keywords