国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

讓我們一起來構建一個模板引擎(三)

3fuyu / 2401人閱讀

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

在 上篇文章 中我們的模板引擎實現了對 iffor 對支持,同時在文章的最后我給大家留了一個 問題:如何實現支持 includeextends 的標簽功能。

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

include

include 標簽對語法是這樣的:假設有一個 item.html 模板文件,它的內容如下:

  • {{ item }}
  • 還有一個我們要渲染的模板 list.html 內容如下:

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

    渲染 list.html 后的結果類似:

    • item1
    • item2
    • item3

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

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

    生成類似上面的代碼就是 include 的關鍵點,下面看一下實現 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):
            """處理標簽"""
            # ...
            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 模板后得到的代碼加入當前代碼中
            # def __func_name():
            #    __result = []
            #    ...
            #    def __func_name_hash():
            #        __result_hash = []
            #        return "".join(__result_hash)
            self.code_builder.add(included_template.code_builder)
            # 把上面生成的代碼中函數的執行結果添加到原有的結果中
            # __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__ 增加了兩個參數 template_direncoding:

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

    encoding: 指定模板文件的編碼,默認是 utf-8

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

    _handle_include 實現的是解析 include 的模板, 然后將生成的代碼和代碼中函數的執行結果添加到當前代碼中。

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

    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 已經實現了,下面讓我們一起來實現 extends 功能。

    extends

    extends 標簽實現的是模板繼承的功能,并且只能在第一行出現,語法如下:

    假設有一個 parent.html 文件它的內容是:

    
    

    還有一個 child.html 文件:

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

    child.html 渲染后的結果:

    
    

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

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

    這個就是 extends 的關鍵點,我們可以先找出子模板里定義的 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
            )
            # 獲取當前模板里的所有 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
            )
            # 改為解析替換后的父模板內容
            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):
            """獲取模板內定義的 blocks"""
            return {
                name: code
                for name, code in self.re_blocks.findall(text)
            }

    從上面的代碼可以看出來我們遵循的是使用子模板 block 替換父模板同名 block 然后改為解析替換后的父模板的思路. 即,雖然我們要渲染的是:

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

    實際上我們最終渲染的是替換后的父模板:

    
    

    依舊是來看一下實際效果:

    parent1.html:

    
    

    child1.html:

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

    看看最后要渲染的模板字符串:

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

    可以看到確實是替換后的內容,再來看一下生成的代碼和渲染后的效果:

    >>> t.code_builder
    def __func_name():
        __result = []
        __result.extend(["
    
    "])
        return "".join(__result)
    
    >>> print(t.render({"header": "child_header"}))
    
    

    extends 的基本功能就這樣實現了。下面再實現一下 {{ block.super }} 功能。

    block.super

    {{ block.super }} 類似 Python class 里的 super 用來實現對父 block 的引用,讓子模板可以重用父 block 中定義的內容。 只要改一下 _replace_parent_blocks 中的 replace 函數讓它支持 {{ block.super }} 就可以了(可以從 Github 下載 template3c.py):

    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

    效果:

    parent2.html:

    child2.html:

    {% 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
    "
    "
    
    >>> t.render()
    "
    "

    到目前為主我們已經實現了現代 python 模板引擎應有的大部分功能了:

    變量

    if

    for

    include

    extends, block, block.super

    后面需要做的工作就是完善我們代碼了。

    不知道大家有沒有注意到,我之前都是用生成 html 來試驗模板引擎的功能的, 這是因為模板引擎確實是在 web 開發中用的比較多,既然是生成 html 源碼那就需要考慮 針對 html 做一點優化,比如去掉多余的空格,轉義之類的,還有就是一些 Web 安全方面的考慮。

    至于怎么實現這些優化項,我將在 第四篇文章 中向你詳細的講解。敬請期待。

    文章版權歸作者所有,未經允許請勿轉載,若此文章存在違規行為,您可以聯系管理員刪除。

    轉載請注明本文地址:http://specialneedsforspecialkids.com/yun/37852.html

    相關文章

    • 我們起來構建模板引擎(四)

      摘要:在本文中我們將解決一些用于生成的模板引擎需要面對的一些安全問題。整個系列的所有文章地址讓我們一起來構建一個模板引擎一讓我們一起來構建一個模板引擎二讓我們一起來構建一個模板引擎三讓我們一起來構建一個模板引擎四文章中涉及的代碼已經放到上了 在 上篇文章 中我們的模板引擎實現了對 include 和 extends 的支持, 到此為止我們已經實現了模板引擎所需的大部分功能。 在本文中我們將解...

      yuxue 評論0 收藏0
    • 基于TmodJS的前端模板工程化解決方案

      摘要:原作者唐斌騰訊什么原名是一個簡單易用的前端模板預編譯工具。本文作者為來自騰訊團隊的唐斌,他在本文中為我們分析了傳統前端模板內嵌的弊端,如開發調試效率低下自動化構建復雜度比較高等特點,并針對目前現狀給出了較好的解決方案。 原作者: 唐斌(騰訊)| TmodJS什么 TmodJS(原名atc)是一個簡單易用的前端模板預編譯工具。它通過預編譯技術讓前端模板突破瀏覽器限制,實現后端模板一樣的同...

      zhaochunqi 評論0 收藏0
    • 我們起來構建模板引擎(二)

      摘要:首先我們來實現對語句的支持。下面我們就一起來讓我們的模板引擎的語法支持和可以從上下載可以看到,其實也是只增加了兩行代碼。效果就這樣我們的模板引擎對的支持算是比較完善了。 在 上篇文章中我們的模板引擎實現了變量和注釋功能,同時在文章的最后我給大家留了一個 問題:如何實現支持 if 和 for 的標簽功能: {% if user.is_admin %} admin, {{ user...

      Anshiii 評論0 收藏0
    • 我們起來構建模板引擎

      摘要:使用技術我們將使用將模板編譯為代碼的方式來解析和渲染模板。下面我們就一起來實現這個方法。 假設我們要生成下面這樣的 html 字符串: welcome, Tom age: 20 weight: 100 height: 170 要求姓名以及 中的內容是根據變量動態生成的,也就是這樣的: welco...

      zombieda 評論0 收藏0
    • webpack多頁應用架構系列(十五):論前端如何在后端渲染開發模式下夾縫生存

      摘要:回到純靜態頁面開發階段,讓頁面不需要后端渲染也能跑起來。改造開始本文著重介紹如何將靜態頁面改造成后端渲染需要的模板??偨Y在后端渲染的項目里使用多頁應用架構是絕對可行的,可不要給老頑固們嚇唬得又回到傳統前端架構了。 本文首發于Array_Huang的技術博客——實用至上,非經作者同意,請勿轉載。原文地址:https://segmentfault.com/a/119000000820338...

      dinfer 評論0 收藏0

    發表評論

    0條評論

    3fuyu

    |高級講師

    TA的文章

    閱讀更多
    最新活動
    閱讀需要支付1元查看
    <