摘要：使用技術(shù)我們將使用將模板編譯為代碼的方式來(lái)解析和渲染模板。下面我們就一起來(lái)實(shí)現(xiàn)這個(gè)方法。

假設(shè)我們要生成下面這樣的 html 字符串:

    
welcome, Tom
    

        
age: 20
        
weight: 100
        
height: 170
    

要求姓名以及

    
welcome, {name}
    

        {info}
    

沒(méi)接觸過(guò)模板的同學(xué)可能會(huì)想到使用字符串格式化的方式來(lái)實(shí)現(xiàn):

HTML = """

    
welcome, {name}
    

        {info}
    

"""


def gen_html(person):
    name = person["name"]
    info_list = [
        "
{0}: {1}
".format(item, value)
        for item, value in person["info"].items()
    ]
    info = "
".join(info_list)
    return HTML.format(name=name, info=info)

這種方案有一個(gè)很明顯的問(wèn)題那就是，需要拼接兩個(gè) html 片段。 使用過(guò)模板技術(shù)的同學(xué)應(yīng)該很容易就想到，在 Web 開(kāi)發(fā)中生成 HTML 的更常用的辦法是使用模板:

HTML = """

    
welcome, {{ person["name"] }}
    

        {% for item, value in person["info"].items() %}
        
{{ item }}: {{ value }}
        {% endfor %}
    

"""


def gen_html(person):
    return Template(HTML).render({"person": person})

本系列文章要講的就是如何從零開(kāi)始實(shí)現(xiàn)一個(gè)這樣的模板引擎( Template )。

我們將使用將模板編譯為 python 代碼的方式來(lái)解析和渲染模板。 比如上面的模板將被編譯為如下 python 代碼:

def render_function():
    result = []

    result.extend([
        "

",
        "
welcome, "
        str(person["name"]),
        "
",
        "

"
    ])
    for item, value in person["info"].items():
        result.extend([
            "
",
            str(item),
            ": ",
            str(value),
            "
"
        ])
    result.extend([
        "
"
        "
"
    ])
    return "".join(result)

然后通過(guò) exec 執(zhí)行生成的代碼，之后再執(zhí)行 render_function() 就可以得到我們需要的 html 字符串了:

namespace = {"person": person}
exec(code, namespace)
render_function = namespace["render_function"]
html = render_function()

模板引擎的核心技術(shù)就是這些了，下面讓我們一步一步的實(shí)現(xiàn)它吧。

我們都知道 python 代碼是高度依賴(lài)縮進(jìn)的，所以我們需要一個(gè)對(duì)象用來(lái)保存我們生成代碼時(shí)的當(dāng)前縮進(jìn)情況， 同時(shí)也保存已經(jīng)生成的代碼行（可以直接在 github 上下載 template1a.py ）:

# -*- coding: utf-8 -*-
# tested on Python 3.5.1


class CodeBuilder:
    INDENT_STEP = 4     # 每次縮進(jìn)的空格數(shù)

    def __init__(self, indent=0):
        self.indent = indent    # 當(dāng)前縮進(jìn)
        self.lines = []         # 保存一行一行生成的代碼

    def forward(self):
        """縮進(jìn)前進(jìn)一步"""
        self.indent += self.INDENT_STEP

    def backward(self):
        """縮進(jìn)后退一步"""
        self.indent -= self.INDENT_STEP

    def add(self, code):
        self.lines.append(code)

    def add_line(self, code):
        self.lines.append(" " * self.indent + code)

    def __str__(self):
        """拼接所有代碼行后的源碼"""
        return "
".join(map(str, self.lines))

    def __repr__(self):
        """方便調(diào)試"""
        return str(self)

forward 和 backward 方法可以用來(lái)控制縮進(jìn)前進(jìn)或后退一步，比如在生成 if 語(yǔ)句的時(shí)候:

if age > 13:      # 生成完這一行以后，需要切換縮進(jìn)了 ``forward()``
    ...
    ...           # 退出 if 語(yǔ)句主體的時(shí)候，同樣需要切換一次縮進(jìn) ``backward()``
...

這個(gè)模板引擎的核心部分就是一個(gè) Template 類(lèi)，用法:

# 實(shí)例化一個(gè) Template 對(duì)象
template = Template("""
hello, {{ name }}
{% for skill in skills %}
    
you are good at {{ skill }}.
{% endfor %}
""")

# 然后，使用一些數(shù)據(jù)來(lái)渲染這個(gè)模板
html = template.render(
    {"name": "Eric", "skills": ["python", "english", "music", "comic"]}
)

一切魔法都在 Template 類(lèi)里。下面我們寫(xiě)一個(gè)基本的 Template 類(lèi)（可以直接在 github 上下載 template1b.py ）:

class Template:

    def __init__(self, raw_text, indent=0, default_context=None,
                 func_name="__func_name", result_var="__result"):
        self.raw_text = raw_text
        self.default_context = default_context or {}
        self.func_name = func_name
        self.result_var = result_var
        self.code_builder = code_builder = CodeBuilder(indent=indent)
        self.buffered = []

        # 生成 def __func_name():
        code_builder.add_line("def {}():".format(self.func_name))
        code_builder.forward()
        # 生成 __result = []
        code_builder.add_line("{} = []".format(self.result_var))
        self._parse_text()

        self.flush_buffer()
        # 生成 return "".join(__result)
        code_builder.add_line("return "".join({})".format(self.result_var))
        code_builder.backward()

    def _parse_text(self):
        pass

    def flush_buffer(self):
        # 生成類(lèi)似代碼: __result.extend(["
", name, "
"])
        line = "{0}.extend([{1}])".format(
            self.result_var, ",".join(self.buffered)
        )
        self.code_builder.add_line(line)
        self.buffered = []

    def render(self, context=None):
        namespace = {}
        namespace.update(self.default_context)
        if context:
            namespace.update(context)
        exec(str(self.code_builder), namespace)
        result = namespace[self.func_name]()
        return result

以上就是 Template 類(lèi)的核心方法了。我們之后要做的就是實(shí)現(xiàn)和完善 _parse_text 方法。 當(dāng)模板字符串為空時(shí)生成的代碼如下:

>>> import template1b
>>> template = template1b.Template("")
>>> template.code_builder
def __func_name():
    __result = []
    __result.extend([])
    return "".join(__result)

可以看到跟上面[使用技術(shù)]那節(jié)所說(shuō)生成的代碼是類(lèi)似的。下面我們就一起來(lái)實(shí)現(xiàn)這個(gè) _parse_text 方法。

首先要實(shí)現(xiàn)是對(duì)變量的支持，模板語(yǔ)法是 {{ variable }} 。 既然要支持變量，首先要做的就是把變量從模板中找出來(lái)，這里我們可以使用正則表達(dá)式來(lái)實(shí)現(xiàn):

re_variable = re.compile(r"{{ .*? }}")

>>> re_variable = re.compile(r"{{ .*? }}")
>>> re_variable.findall("
{{ title }}
")
["{{ title }}"]
>>>

知道了如何匹配變量語(yǔ)法，下面我們要把變量跟其他的模板字符串分割開(kāi)來(lái)，這里還是用的 re:

>> re_variable = re.compile(r"({{ .*? }})")
>>> re_variable.split("
{{ title }}
")
["
", "{{ title }}", "
"]

這里的正則之所以加了個(gè)分組是因?yàn)槲覀兺瑫r(shí)還需要用到模板里的變量。 分割開(kāi)來(lái)以后我們就可以對(duì)每一項(xiàng)進(jìn)行解析了。支持 {{ variable }} 語(yǔ)法的 Template 類(lèi)增加了如下代碼 （可以直接在 github 上下載 template1c.py ）:

class Template:

    def __init__(self, raw_text, indent=0, default_context=None,
                 func_name="__func_name", result_var="__result"):
        # ...
        self.buffered = []

        self.re_variable = re.compile(r"{{ .*? }}")
        self.re_tokens = re.compile(r"({{ .*? }})")

        # 生成 def __func_name():
        code_builder.add_line("def {}():".format(self.func_name))
        # ...

    def _parse_text(self):
        tokens = self.re_tokens.split(self.raw_text)

        for token in tokens:
            if self.re_variable.match(token):
                variable = token.strip("{} ")
                self.buffered.append("str({})".format(variable))
            else:
                self.buffered.append("{}".format(repr(token)))

_parse_text 中之所以要用 repr ，是因?yàn)榇藭r(shí)需要把 token 當(dāng)成一個(gè)普通的字符串來(lái)處理， 同時(shí)需要考慮 token 中包含 " 和 " 的情況。 下面是幾種有問(wèn)題的寫(xiě)法:

"str({})".format(token): 這種是把 token 當(dāng)成變量來(lái)用了，生成的代碼為 str(token)

""{}"".format(token): 這種雖然是把 token 當(dāng)成了字符串，但是會(huì)有轉(zhuǎn)義的問(wèn)題，當(dāng) token 中包含 " 時(shí)生成的代碼為 ""hello""

下面先來(lái)看一下新的 template1c.py 生成了什么樣的代碼:

>>> from template1c import Template
>>> template = Template("
{{ title }}
")
>>> template.code_builder
def __func_name():
    __result = []
    __result.extend(["
",str(title),"
"])
    return "".join(__result)

沒(méi)問(wèn)題，跟預(yù)期的是一樣的。再來(lái)看一下 render 的效果:

>>> template.render({"title": "Python"})
"
Python
"

不知道你有沒(méi)有發(fā)現(xiàn)，其實(shí) {{ variable }} 不只支持變量，還支持表達(dá)式和運(yùn)算符:

>>> Template("{{ 1 + 2 }}").render()
"3"
>>> Template("{{ items[0] }}").render({"items": [1, 2, 3]})
"1"
>>> Template("{{ func() }}").render({"func": list})
"[]"

這個(gè)既可以說(shuō)是個(gè) BUG 也可以說(shuō)是個(gè)特性?， 看模板引擎是否打算支持這些功能了， 我們?cè)谶@里是打算支持這些功能 ;)。

既然支持了 {{ }} 那么支持注釋也就非常好實(shí)現(xiàn)了。

打算支持的注釋模板語(yǔ)法是 {# comments #} ，有了上面實(shí)現(xiàn) {{ variable }} 的經(jīng)驗(yàn)，實(shí)現(xiàn)注釋是類(lèi)似的代碼 （可以直接在 github 上下載 template1d.py ）:

class Template:

    def __init__(self, raw_text, indent=0, default_context=None,
                 func_name="__func_name", result_var="__result"):
        # ...
        self.buffered = []

        self.re_variable = re.compile(r"{{ .*? }}")
        self.re_comment = re.compile(r"{# .*? #}")
        self.re_tokens = re.compile(r"""(
            (?:{{ .*? }})
            |(?:{# .*? #})
        )""", re.X)

        # 生成 def __func_name():
        # ...

    def _parse_text(self):
        tokens = self.re_tokens.split(self.raw_text)

        for token in tokens:
            if self.re_variable.match(token):
                # ...
            # 注釋 {# ... #}
            elif self.re_comment.match(token):
                continue
            else:
                # ...

效果:

>>> from template1d import Template
>>> template = Template("
{{ title }} {# comment #}
")
>>> template.code_builder
def __func_name():
    __result = []
    __result.extend(["
",str(title)," ","
"])
    return "".join(__result)

>>> template.render({"title": "Python"})
"
Python 
"

至此，我們的模板引擎已經(jīng)支持了變量和注釋功能。 那么如何實(shí)現(xiàn)支持 if 語(yǔ)句和 for 循環(huán)的標(biāo)簽語(yǔ)法呢:

{% if user.is_admin %}
    admin, {{ user.name }}
{% elif user.is_staff %}
    staff
{% else %}
    others
{% endif %}

{% for name in names %}
    {{ name }}
{% endfor %}

我將在 第二篇文章 中向你詳細(xì)的講解。敬請(qǐng)期待。