摘要：在上篇文章中我們的模板引擎實現(xiàn)了對和對支持，同時在文章的最后我給大家留了一個問題如何實現(xiàn)支持和的標(biāo)簽功能。在本篇文章中我們將一起來動手實現(xiàn)這兩個功能。

在 上篇文章 中我們的模板引擎實現(xiàn)了對 if 和 for 對支持，同時在文章的最后我給大家留了一個 問題：如何實現(xiàn)支持 include 和 extends 的標(biāo)簽功能。

在本篇文章中我們將一起來動手實現(xiàn)這兩個功能。

include 標(biāo)簽對語法是這樣的：假設(shè)有一個 item.html 模板文件，它的內(nèi)容如下:

{{ item }}

還有一個我們要渲染的模板 list.html 內(nèi)容如下:

  {% for item in items %}
    {% include "item.html" %}
  {% endfor %}

渲染 list.html 后的結(jié)果類似:

  
item1
  
item2
  
item3

從上面可以看出來 include 標(biāo)簽的作用類似使用 include 所在位置的名字空間 渲染另一個模板然后再使用渲染后的結(jié)果。所以我們可以將 include 的模板文件 當(dāng)作普通的模板文件來處理，用解析那個模板生成后的代碼替換 include 所在的位置， 再將結(jié)果追加到 result_var 。 生成的代碼類似:

def func_name():
    result = []

    # 解析 include 的模板
    def func_name_include():
        result_include = []
        return "".join(result_include)
    # 調(diào)用生成的 func_name_include 函數(shù)獲取渲染結(jié)果
    result.append(func_name_include())

    return "".join(result)

生成類似上面的代碼就是 include 的關(guān)鍵點，下面看一下實現(xiàn) include 功能 都做了哪些改動 (可以從 Github 上下載 template3a.py):

class Template:

    def __init__(self, ..., template_dir="", encoding="utf-8"):
        # ...
        self.template_dir = template_dir
        self.encoding = encoding
        # ...

    def _handle_tag(self, token):
        """處理標(biāo)簽"""
        # ...
        tag_name = tag.split()[0]
        if tag_name == "include":
            self._handle_include(tag)
        else:
            self._handle_statement(tag)

    def _handle_include(self, tag):
        filename = tag.split()[1].strip("""")
        included_template = self._parse_another_template_file(filename)
        # 把解析 include 模板后得到的代碼加入當(dāng)前代碼中
        # def __func_name():
        #    __result = []
        #    ...
        #    def __func_name_hash():
        #        __result_hash = []
        #        return "".join(__result_hash)
        self.code_builder.add(included_template.code_builder)
        # 把上面生成的代碼中函數(shù)的執(zhí)行結(jié)果添加到原有的結(jié)果中
        # __result.append(__func_name_hash())
        self.code_builder.add_line(
            "{0}.append({1}())".format(
                self.result_var, included_template.func_name
            )
        )

    def _parse_another_template_file(self, filename):
        template_path = os.path.realpath(
            os.path.join(self.template_dir, filename)
        )
        name_suffix = str(hash(template_path)).replace("-", "_")
        func_name = "{}_{}".format(self.func_name, name_suffix)
        result_var = "{}_{}".format(self.result_var, name_suffix)
        with open(template_path, encoding=self.encoding) as fp:
            template = self.__class__(
                fp.read(), indent=self.code_builder.indent,
                default_context=self.default_context,
                func_name=func_name, result_var=result_var,
                template_dir=self.template_dir
            )
        return template

首先是 __init__ 增加了兩個參數(shù) template_dir 和 encoding:

template_dir: 指定模板文件夾路徑，因為 include 的模板是相對路徑所以需要這個 選項來獲取模板的絕對路徑

encoding: 指定模板文件的編碼，默認(rèn)是 utf-8

然后就是 _parse_another_template_file 了，這個方法是用來解析 include 中 指定的模板文件的，其中的 func_name 和 result_var 之所以加了個 hash 值 作為后綴是不想跟其他函數(shù)變量重名。

_handle_include 實現(xiàn)的是解析 include 的模板， 然后將生成的代碼和代碼中函數(shù)的執(zhí)行結(jié)果添加到當(dāng)前代碼中。

下面來看一下實現(xiàn)的效果。還是用上面的模板文件:

item.html:

{{ item }}

list.html:

  {% for item in items %}
    {% include "item.html" %}
  {% endfor %}

先來看一下生成的代碼:

>>> from template3a import Template
>>> text = open("list.html").read()
>>> t = Template(text)
>>> t.code_builder
def __func_name():
    __result = []
    __result.extend(["

  "])
    for item in items:
        __result.extend(["
    "])
        def __func_name_7654650009897399020():
            __result_7654650009897399020 = []
            __result_7654650009897399020.extend(["
",str(item),"
"])
            return "".join(__result_7654650009897399020)
        __result.append(__func_name_7654650009897399020())
        __result.extend(["
  "])
    __result.extend(["

"])
    return "".join(__result)

然后是渲染效果:

>>> print(t.render({"items": ["item1", "item2", "item3"]}))


    
item1


    
item2


    
item3

include 已經(jīng)實現(xiàn)了，下面讓我們一起來實現(xiàn) extends 功能。

extends 標(biāo)簽實現(xiàn)的是模板繼承的功能，并且只能在第一行出現(xiàn)，語法如下:

假設(shè)有一個 parent.html 文件它的內(nèi)容是:

{% block header %} parent_header {% endblock header %}
{% block footer %} parent_footer {% endblock footer %}

還有一個 child.html 文件:

{% extends "parent.html" %}
{% block header %} child_header {{ block.super }} {% endblock header %}

child.html 渲染后的結(jié)果:

 child_header parent_header 
 parent_footer 

可以看到 extends 的效果類似用子模板里的 block 替換父模板中定義的同名 block, 同時又可以使用 {{ block.super }} 引用父模板中定義的內(nèi)容，有點類似 class 的繼承效果。

注意我剛才說的是: 類似用子模板里的 block 替換父模板中定義的同名 block 。

這個就是 extends 的關(guān)鍵點，我們可以先找出子模板里定義的 block ， 然后用子模板里的 block 替換父模板里的同名 block , 最后只處理替換后的父模板就可以了。

暫時先不管 block.super ，支持 extends 的代碼改動如下(可以從 Github 下載 template3b.py ):

class Template:
    def __init__(self, ...):
        # extends
        self.re_extends = re.compile(r"{% extends (?P.*?) %}")
        # blocks
        self.re_blocks = re.compile(
            r"{% block (?Pw+) %}"
            r"(?P.*?)"
            r"{% endblock 1 %}", re.DOTALL)

    def _parse_text(self):
        # extends
        self._handle_extends()

        tokens = self.re_tokens.split(self.raw_text)
        # ...

    def _handle_extends(self):
        match_extends = self.re_extends.match(self.raw_text)
        if match_extends is None:
            return

        parent_template_name = match_extends.group("name").strip(""" ")
        parent_template_path = os.path.join(
            self.template_dir, parent_template_name
        )
        # 獲取當(dāng)前模板里的所有 blocks
        child_blocks = self._get_all_blocks(self.raw_text)
        # 用這些 blocks 替換掉父模板里的同名 blocks
        with open(parent_template_path, encoding=self.encoding) as fp:
            parent_text = fp.read()
        new_parent_text = self._replace_parent_blocks(
            parent_text, child_blocks
        )
        # 改為解析替換后的父模板內(nèi)容
        self.raw_text = new_parent_text

    def _replace_parent_blocks(self, parent_text, child_blocks):
        """用子模板的 blocks 替換掉父模板里的同名 blocks"""
        def replace(match):
            name = match.group("name")
            parent_code = match.group("code")
            child_code = child_blocks.get(name)
            return child_code or parent_code
        return self.re_blocks.sub(replace, parent_text)

    def _get_all_blocks(self, text):
        """獲取模板內(nèi)定義的 blocks"""
        return {
            name: code
            for name, code in self.re_blocks.findall(text)
        }

{% extends "parent.html" %}
{% block header %} child_header {% endblock header %}

 child_header 
 parent_footer 

{% block header %} parent_header {% endblock header %}
{% block footer %} parent_footer {% endblock footer %}

{% extends "parent1.html" %}
{% block header %} {{ header }} {% endblock header %}

>>> from template3b import Template
>>> text = open("child1.html").read()
>>> t = Template(text)
>>> print(t.raw_text)
 {{ header }} 
 parent_footer 

>>> t.code_builder
def __func_name():
    __result = []
    __result.extend(["
 ",str(header)," 
 parent_footer 
"])
    return "".join(__result)

>>> print(t.render({"header": "child_header"}))
 child_header 
 parent_footer 

class Template:
    def __init__(self, ....):
        # blocks
        self.re_blocks = ...
        # block.super
        self.re_block_super = re.compile(r"{{ block.super }}")

    def _replace_parent_blocks(self, parent_text, child_blocks):
        def replace(match):
            ...
            parent_code = match.group("code")
            child_code = child_blocks.get(name, "")
            child_code = self.re_block_super.sub(parent_code, child_code)
            new_code = child_code or parent_code
            return new_code

{% block header %} parent_header {% endblock header %}

{% extends "parent2.html" %}
{% block header %} child_header {{ block.super }} {% endblock header %}

>>> from template3c import Template
>>> text = open("child2.html").read()
>>> t = Template(text)
>>> t.raw_text
"
 child_header  parent_header  
"

>>> t.render()
"
 child_header  parent_header  
"