GVKun编程网logo

Golang模板引擎管道（golang 模板引擎）

13

本文将为您提供关于Golang模板引擎管道的详细介绍，我们还将为您解释golang模板引擎的相关知识，同时，我们还将为您提供关于django-模板引擎进阶、Django模板引擎以及模板、django默

本文将为您提供关于Golang模板引擎管道的详细介绍，我们还将为您解释golang 模板引擎的相关知识，同时，我们还将为您提供关于django - 模板引擎进阶、Django 模板引擎以及模板、django 默认模板引擎和 jinja2 模板引擎、django-3.模板引擎的实用信息。

本文目录一览：

Golang模板引擎管道（golang 模板引擎）

Golang模板引擎管道（golang 模板引擎）

我有一个Golang模板，定义如下

{{- define "test" -}}{{- printf "%s" .Name | trunc 24 -}}{{- end -}}

然后在我的一个文件中使用它：

{{ template "test" . }}

“测试”之后，点是什么意思？Golang模板文档说：

{{template "name" pipeline}}The template with the specified name is executed with dot setto the value of the pipeline.

但是我不确定是什么管道。阅读文档没有结果，有人可以再解释一次吗？

另外，为什么我们必须以点开始的值？例如{{ - printf "%s" .Name | trunc 24 -}}。这也是一种管道吗？

先感谢您！

答案1

小编典典

有2个template软件包，text/template和html/template。

它们具有相同的接口，但是该html/template程序包用于生成安全的HTML输出，以防止代码注入，因此应使用该程序包，而不是text/template在输出为HTML时使用。

由于它们具有相同的界面，但是html/template提供了一些额外的功能（对插入的数据进行上下文转义），因此仅在上记录了基础知识和原理text/html，而html/template大多数文献则集中在详细说明额外内容上。

话虽如此，“管道”属于基础。它记录在管道text/template部分：

流水线

管道是“命令”的可能链接的序列。命令是一个简单的值（参数）或函数或方法调用，可能带有多个参数：

Argument    The result is the value of evaluating the argument..Method [Argument...]    The method can be alone or the last element of a chain but,    unlike methods in the middle of a chain, it can take arguments.    The result is the value of calling the method with the    arguments:        dot.Method(Argument1, etc.)functionName [Argument...]    The result is the value of calling the function associated    with the name:        function(Argument1, etc.)    Functions and function names are described below.

通过用流水线字符“
|”分隔命令序列，可以“链接”流水线。在链式管道中，每个命令的结果作为以下命令的最后一个参数传递。流水线中最终命令的输出是流水线的值。

“参数”和“管道”是对数据的评估。

“点”
.基本上是一个光标，指向执行模板时传递的数据结构中的某处。点的起始值是您传递的值，但是许多操作（例如{{range}}或）都会修改该点{{with}}。

执行模板将遍历结构并设置光标，并用句点“。”表示。并在执行过程中将其称为“点”到结构中当前位置的值。

因此，在编写时.Name，这表示点当前指向的值，您要引用其字段或方法或称为的键Name。例如，如果您传递struct，则模板的开头.Name将表示struct字段（Name如果存在）或其命名为的方法Name()。

调用/包含另一个模板时，您可以告诉您将什么值传递给其执行。编写时{{template "something".}}，这意味着您要将当前由点指向的值传递给模板执行。如果只希望传递Name点所指向的结构的字段，则可以像那样进行{{template"something" .Name}}。

您在管道中传递的值{{template}}将成为调用的其他模板内的点。

因此，在处理/渲染模板时，点可能会更改，并且“仅”指向最初传递给模板执行的部分值。通常它很方便，或者仍然需要达到原始值，而不仅仅是光标。为此，模板包提供了$：

开始执行时，将$设置为传递给Execute的数据参数，即dot的起始值。

因此，即使您位于{{range}}例如（将点设置为要遍历的数组/ slice
/映射的连续元素）内，您仍然可以伸手并引用传递给该对象的值的任何其他部分模板执行。

因此，例如，如果您遍历像这样的书{{range .Books}}，并且需要Name原始传递的struct
的字段，则可以在内部执行{{range}}以下操作：

{{range .Books}}    Title: {{.Title}}    Original name: {{$.Name}}{{end}}

django - 模板引擎进阶

django - 模板引擎进阶

Django 模板系统

官方文档

 

常用语法

Django 模板中只需要记两种特殊符号：

{{ }} 和 {% %}

{{}} 表示变量，在模板渲染的时候替换成值，{% %} 表示逻辑相关的操作。

 

变量

{{变量名}}

变量名由字母数字和下划线组成。

点（.）在模板语言中有特殊的含义，用来获取对象的相应属性值。

几个例子：

view 中代码：

  
def template_test(request):
    l = [11, 22, 33]
    d = {"name": "alex"}

    class Person(object):
        def __init__(self, name, age):
            self.name = name
            self.age = age

        def dream(self):
            return "{} is dream...".format(self.name)

    Alex = Person(name="Alex", age=34)
    Egon = Person(name="Egon", age=9000)
    Eva_J = Person(name="Eva_J", age=18)

    person_list = [Alex, Egon, Eva_J]
    return render(request, "template_test.html", {"l": l, "d": d, "person_list": person_list})
 

模板中支持的写法：

  
{# 取l中的第一个参数 #}
{{ l.0 }}
{# 取字典中key的值 #}
{{ d.name }}
{# 取对象的name属性 #}
{{ person_list.0.name }}
{# .操作只能调用不带参数的方法 #}
{{ person_list.0.dream }}
 

注：当模板系统遇到一个（.）时，会按照如下的顺序去查询：

  1. 在字典中查询
  2. 属性或者方法
  3. 数字索引

 

Filters

翻译为过滤器，用来修改变量的显示结果。

语法： {{value|filter_name: 参数}}

''|'' 左右没有空格没有空格没有空格

default　　

{{ value|default:"nothing"}}

如果 value 值没传的话就显示 nothing

注：TEMPLATES 的 OPTIONS 可以增加一个选项：string_if_invalid：'' 找不到 ''，可以替代 default 的的作用。

filesizeformat

将值格式化为一个 “人类可读的” 文件尺寸 （例如 ''13 KB'', ''4.1 MB'', ''102 bytes'', 等等）。例如：

{{ value|filesizeformat }}

如果 value 是 123456789，输出将会是 117.7 MB。

add

给变量加参数

{{ value|add:"2" }}

value 是数字 4，则输出结果为 6。

{{ first|add:second }}

如果 first 是 [1,.2,3] ，second 是 [4,5,6] ，那输出结果是 [1,2,3,4,5,6] 。

lower

小写

{{ value|lower }}

upper

大写

{{ value|upper}}

title

标题

{{ value|title }}

ljust

左对齐

"{{ value|ljust:"10" }}"

rjust

右对齐

"{{ value|rjust:"10" }}"

center

居中

"{{ value|center:"15" }}"

length

{{ value|length }}

返回 value 的长度，如 value=[''a'', ''b'', ''c'', ''d''] 的话，就显示 4.

slice　　

切片

{{value|slice:"2:-1"}}

first

取第一个元素

{{ value|first }}

last

取最后一个元素

{{ value|last }}

join

使用字符串拼接列表。同 python 的 str.join (list)。

{{ value|join:" // " }}

truncatechars

如果字符串字符多于指定的字符数量，那么会被截断。截断的字符串将以可翻译的省略号序列（“...”）结尾。

参数：截断的字符数

{{ value|truncatechars:9}}

date

日期格式化

{{ value|date:"Y-m-d H:i:s"}}

可格式化输出的字符：点击查看。

safe

Django 的模板中会对 HTML 标签和 JS 等语法标签进行自动转义，原因显而易见，这样是为了安全。但是有的时候我们可能不希望这些 HTML 元素被转义，比如我们做一个内容管理系统，后台添加的文章中是经过修饰的，这些修饰可能是通过一个类似于 FCKeditor 编辑加注了 HTML 修饰符的文本，如果自动转义的话显示的就是保护 HTML 标签的源文件。为了在 Django 中关闭 HTML 的自动转义有两种方式，如果是一个单独的变量我们可以通过过滤器 “|safe” 的方式告诉 Django 这段代码是安全的不必转义。

比如：

value = "<a href=''#''> 点我 </a>"

{{ value|safe}}

 

自定义 filter

自定义过滤器只是带有一个或两个参数的 Python 函数:

  • 变量（输入）的值 - - 不一定是一个字符串
  • 参数的值 - 这可以有一个默认值，或完全省略

例如，在过滤器 {{var | foo：“bar”}} 中，过滤器 foo 将传递变量 var 和参数 “bar”。

自定义 filter 代码文件摆放位置：

  
app01/
    __init__.py
    models.py
    templatetags/  # 在app01下面新建一个package package
        __init__.py
        app01_filters.py  # 建一个存放自定义filter的py文件
    views.py
 

编写自定义 filter

  
from django import template
register = template.Library()


@register.filter
def fill(value, arg):
    return value.replace(" ", arg)


@register.filter(name="addSB")
def add_sb(value):
    return "{} SB".format(value)
 

使用自定义 filter

{# 先导入我们自定义filter那个文件 #}
{% load app01_filters %}

{# 使用我们自定义的filter #}
{{ somevariable|fill:"__" }}
{{ d.name|addSB }}

 

Tags

for

<ul>
{% for user in user_list %}
    <li>{{ user.name }}</li>
{% endfor %}
</ul>

for 循环可用的一些参数：

Variable Description
forloop.counter 当前循环的索引值（从 1 开始）
forloop.counter0 当前循环的索引值（从 0 开始）
forloop.revcounter 当前循环的倒序索引值（从 1 开始）
forloop.revcounter0 当前循环的倒序索引值（从 0 开始）
forloop.first 当前循环是不是第一次循环（布尔值）
forloop.last 当前循环是不是最后一次循环（布尔值）
forloop.parentloop 本层循环的外层循环

for ... empty

  
<ul>
{% for user in user_list %}
    <li>{{ user.name }}</li>
{% empty %}
    <li>空空如也</li>
{% endfor %}
</ul>
 

if,elif 和 else

  
{% if user_list %}
  用户人数：{{ user_list|length }}
{% elif black_list %}
  黑名单数：{{ black_list|length }}
{% else %}
  没有用户
{% endif %}
 

当然也可以只有 if 和 else

{% if user_list|length > 5 %}
  七座豪华SUV
{% else %}
    黄包车
{% endif %}

if 语句支持 and 、or、==、>、<、!=、<=、>=、in、not in、is、is not 判断。

with

定义一个中间变量

{% with total=business.employees.count %}
    {{ total }} employee{{ total|pluralize }}
{% endwith %}

 

csrf_token

这个标签用于跨站请求伪造保护。

在页面的 form 表单里面写上 {% csrf_token %}

 

注释

{# ... #}

 

注意事项

1. Django 的模板语言不支持连续判断，即不支持以下写法：

{% if a > b > c %}
...
{% endif %}

2. Django 的模板语言中属性的优先级大于方法

def xx(request):
    d = {"a": 1, "b": 2, "c": 3, "items": "100"}
    return render(request, "xx.html", {"data": d})

如上，我们在使用 render 方法渲染一个页面的时候，传的字典 d 有一个 key 是 items 并且还有默认的 d.items () 方法，此时在模板语言中:

{{ data.items }}

默认会取 d 的 items key 的值。

母板

  
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="x-ua-compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Title</title>
  {% block page-css %}
  
  {% endblock %}
</head>
<body>

<h1>这是母板的标题</h1>

{% block page-main %}

{% endblock %}
<h1>母板底部内容</h1>
{% block page-js %}

{% endblock %}
</body>
</html>
 

注意：我们通常会在母板中定义页面专用的 CSS 块和 JS 块，方便子页面替换。

继承母板

在子页面中在页面最上方使用下面的语法来继承母板。

{% extends ''layouts.html'' %}
 

块（block）

通过在母板中使用 {% block  xxx %} 来定义 "块"。

在子页面中通过定义母板中的 block 名来对应替换母板中相应的内容。

{% block page-main %}
  <p>世情薄</p>
  <p>人情恶</p>
  <p>雨送黄昏花易落</p>
{% endblock %}

组件

可以将常用的页面内容如导航条，页尾信息等组件保存在单独的文件中，然后在需要使用的地方按如下语法导入即可。

{% include ''navbar.html'' %}

静态文件相关

{% load static %}
<img src="{% static "images/hi.jpg" %}" alt="Hi!" />

引用 JS 文件时使用：

{% load static %}
<script src="{% static "mytest.js" %}"></script>

某个文件多处被用到可以存为一个变量

{% load static %}
{% static "images/hi.jpg" as myphoto %}
<img src="{{ myphoto }}"></img>

 

使用 get_static_prefix

{% load static %}
<img src="{% get_static_prefix %}images/hi.jpg" alt="Hi!" />

或者

{% load static %}
{% get_static_prefix as STATIC_PREFIX %}

<img src="{{ STATIC_PREFIX }}images/hi.jpg" alt="Hi!" />
<img src="{{ STATIC_PREFIX }}images/hi2.jpg" alt="Hello!" />

 

自定义 simpletag

和自定义 filter 类似，只不过接收更灵活的参数。

定义注册 simple tag

@register.simple_tag(name="plus")
def plus(a, b, c):
    return "{} + {} + {}".format(a, b, c)

使用自定义 simple tag

{% load app01_demo %}

{# simple tag #}
{% plus "1" "2" "abc" %}

 

inclusion_tag

多用于返回 html 代码片段

示例：

templatetags/my_inclusion.py

  
from django import template

register = template.Library()


@register.inclusion_tag(''result.html'')
def show_results(n):
    n = 1 if n < 1 else int(n)
    data = ["第{}项".format(i) for i in range(1, n+1)]
    return {"data": data}
 

templates/result.html

<ul>
  {% for choice in data %}
    <li>{{ choice }}</li>
  {% endfor %}
</ul>

templates/index.html

  
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="x-ua-compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>inclusion_tag test</title>
</head>
<body>

{% load my_inclusion %}

{% show_results 10 %}
</body>
</html>
 
 

Django 模板引擎以及模板

Django 模板引擎以及模板

在Django框架中，可以使用两种模板引擎，一种是默认的Django模板引擎，还有一种是Jinja2模板引擎；

1.模版引擎的作用和优点

模版引擎作用是将View视图中需要在前端HTML页面中展示的数据，通过模板引擎的语法规则，展示出来；

模版引擎优点是将业务逻辑的Python代码和页面设计的HTML代码分离，使代码更干净整洁更容易维护，使Python程序员和HTML/CSS程序员分开协作，提高生产的效率，且将HTML代码分离出来，还能使其能够复用；

2.HTML模板存放的位置

HTML模板存放的位置有两个，一个是存放在settings文件中指定的DIRS的目录列表中，还有一个是直接在对应的APP包下，创建templates目录，将HTML放置于此即可，不同APP对其他APP目录下的templates目录都是可见的；

3.模板引擎的配置

先在项目的settings.py文件中找到TEMPLATES变量，然后加入

TEMPLATES = [
    {
        # 选择模板引擎，默认是Django的模板引擎
        ''BACKEND'': ''django.template.backends.django.DjangoTemplates'',
        #或者是jinja2模版  ''BACKEND'': ''django.template.backends.jinja2.Jinja2''

        # 指定HTML模板存放的目录，如果HTML模板较多，可以设置多个模板路径
        ''DIRS'': [os.path.join(BASE_DIR, ''templates'')],
        # APP_DIRS的值判断是否支持将template目录放置在APP中，Django默认支持值为True
        ''APP_DIRS'': True,
        ''OPTIONS'': {
            ''context_processors'': [
                ''django.template.context_processors.debug'',
                ''django.template.context_processors.request'',
                ''django.contrib.auth.context_processors.auth'',
                ''django.contrib.messages.context_processors.messages'',
            ],
        },
    },
]

4.Django模板引擎的模板语法

变量(VARIABLE)：

{{ VARIABLE }}   # 用于引入后台传入的变量
{{ VARIABLE.name }}
{{ VARIABLE.age }}

标签(TAG)：

{% TAG %}   # 用于循环

1: 正序 for 循环
{% for item in items %}
    <p>{{ forloop.counter }}</p>
    <p>{{ item.name }}</p>
    <p>{{ item.desc }}</p>
{% endfor %}

2: 倒叙 for 循环
{% for item in items reversed %}
    <p>{{ forloop.counter }}</p>       # 记录循环到第几次，计数从1开始
    <p>{{ item.name }}</p>
    <p>{{ item.desc }}</p>
{% endfor %}

3: 变量字典
{% for k,v in dictionary.items %}
    <p>{{ k }},{{ v}}</p>
{% endfor %}

5.Django模板的继承的作用

在Django开发过程中，页面中的重复部分，可以通过Django的模板继承来完成，这样使得页面开发和管理更简单；

在HTML页面中使用到的关键字：

{% extends 这里填写被继承的HTML页面 %}

{% block 这里填写继承的block %}  {% endblock %}

{% include 这里填写需要引入的HTML子页面 %}

6.如何实现继承模板

我们知道了模板可以用继承的方式来实现复用，那接下来我们一起来操作一下：

第一步：可以在项目的templates中先编写好一个html页面，作为网站的基础页面被其他页面继承，我的HTML页面为base.html，然后在其中编辑HTML代码，注意要修改的部分写在{% block %} {% endblock %}的中间；

<body>
    <div>
        今天是星期几呀
    </div>
    
    <!-- 内容变化部分 -->
    {% block content %}
    <div>
        <p>今天是星期一</p>
    </div>
    {% endblock %}
    
    <div>
        好的，谢谢
    </div>
</body>

第二步：在你想要的app的templates目录下创建一个html页面，继承之前的基础页面，我还是使用的courses app，创建一个python.html文件，这些名字都可以自己命名的，不过要注意路径之类的；

{% extends ''base.html'' %}
{% block content %}
     <div>
        <p>今天是星期{{ week_id }}</p>
    </div>
{% endblock %}

第三步：在根路由urls.py中，添加访问路径的路由文件，一定要分清项目的了路由和app的路由哟；

url(r''^courses/'', include((''courses.urls'', ''courses''), namespace=''courses'')),

第四步：在app的路由文件urls.py中添加要访问的html路径；

urlpatterns = [
    url(r''python/(?P<week_id>\d+)$'', python, name=''python'')
]

第五步：在app下的views.py中创建一个python函数；

from django.shortcuts import render

def python(request, week_id):
    return render(request, ''python.html'', {''week_id'': week_id})

然后我们就可以运行项目，运行项目依旧是打断点，然后调试，我们看看结果是否是我们预期的结果呢，比如我的访问路径是

http://127.0.0.1:8000/courses/python/1

python后面接数字，不然会报错，因为我们在第四步中添加路由访问的html路径的时候正则表达式验证必须是数组，这个可以大家自己修改的，可以按照自己的想法来做练习哟；

django 默认模板引擎和 jinja2 模板引擎

django 默认模板引擎和 jinja2 模板引擎

在使用中，大家会发现 django 默认模板引擎有很多局限性，最明显的就是四则运算。就只能加减，乘除都不支持。另外还有判断相等，不能直接 if，要用 ifequal。确实不太方便。还有一点，django 默认模板引擎很慢，jinja2 宣称比 django 默认模板引擎快 10-20 倍。

两种模板语言在使用上差别不是很大。 jinja2 功能更强大，运行速度也比自带的模板要快很多。
 Django 主流的第三方 APP 基本上也都同时支持 Django 默认模板及 jinja2，如果要用 jinja2 也不会有多少障碍。
不过，django 更换模板引擎，需要修改一些东西，如果对 Django 还不熟悉，建议用默认的，省心。等对 Django 有了一定的熟悉后再根据项目实际情况及个人偏好进行选择。

先来安装，pip3 install jinja2。
配置：从 Django1.8 开始，支持第三方模板引擎，可以很容易的配置到。首先，在你的项目下建立一个 jinja2_env.py，内容如下：

#from __future__ import absolute_import  # 如果是py2就取消这行的注释

from django.contrib.staticfiles.storage import staticfiles_storage
from django.urls import reverse from jinja2 import Environment def environment(**options): env = Environment(**options) env.globals.update({ ''static'': staticfiles_storage.url, ''url'': reverse, }) return env

然后在 setting.py 设置

TEMPLATES = [
    {
        ''BACKEND'': ''django.template.backends.jinja2.Jinja2'', ***1
        ''DIRS'': [os.path.join(BASE_DIR, ''templates'')], ''APP_DIRS'': False, ***2 ''OPTIONS'': { ''context_processors'': [ ''django.template.context_processors.debug'', ''django.template.context_processors.request'', ''django.contrib.auth.context_processors.auth'', ''django.contrib.messages.context_processors.messages'', ], ''environment'': ''APP_NAME.jinja2_env.environment'', ***3 }, }, ]

 

标 *** 的是需要修改的地方。
- ***1：这里指定引擎为 jinja2
- ***2：这里确保不去 app 下的子目录的 jinja2 目录找模板
- ***3：配置环境，上边创建的 py 文件
这样一来，你的默认模板引擎就添加好了。

django-3.模板引擎

django-3.模板引擎

[TOC]

模板引擎DTL(django template language)

模板系统

  • 两对花括号包围的文本( {{ 变量 }} )是变量,意思是“把指定变量的值插入这里”.
  • 一对花括号和百分号包围的文本(如 {% 模板标签 %} )是模板标签
  • 过滤器,这是调整变量格式:{{ 变量|过滤器:"参数" }}
  • 内置模板标签和过滤器

使用模板系统

+ 编写模板字符串,创建 Template 对象,创建 Context 对象,然后调用 render() 方法。
+ 代码示例:

```
>>> from django import template
>>> t = template.Template(''My name is {{ name }}.'')  # 创建模板对象
>>> c = template.Context({''name'': ''Nige''})  # 上下文(模板变量和相应的值)
>>> print (t.render(c))  # 渲染模板
My name is Nige.
```    
+ 运行 python manage.py shell 启动交互式解释器,能在启动解释器之前,告诉Django 使用哪个设置文件,否则会抛异常

字典和上下文

  • 多个上下文,同一个模板

    >>> t = Template(''Hello, {{ name }}'')
>>> print (t.render(Context({''name'': ''John''})))
Hello, John
>>> print (t.render(Context({''name'': ''Julie''})))
Hello, Julie

  • 点号可以访问字典的键、属性、方法或对象的索引,板系统遇到变量名中的点号时会按照下述顺序尝试查找如foo.bar,foo.2

    • 字典查找(如 foo["bar"] )
    • 属性查找(如 foo.bar )
    • 方法调用(如 foo.bar() )
    • 列表索引查找(如 foo[2] )

  • 模板系统在变量处插入引擎的 string_if_invalid 配置选项,(默认为一个空字符串):

    • 方法设定了 alters_data=True ,那么渲染模板时不会执行方法
    • 方法查找的过程中,如果方法抛出异常,异常有 silent_variable_failure 属性,而且值为 True
    • 如果变量不存在

##　基本的模板标签和过滤器

标签

  • if/else标签

    • {% if ... %} 和 {% endif %}配对
    • {% else %},{% elif %}
    • {% if %} 支持使用 and 、 or 或 not,　优先级not,and,or,不能有括号

  • for标签

    • {% for ... in ...%}和{% forend %}配对
    • {% for ... in ... reversed %}反向迭代
    • {% empty %}子句，可迭代对象为空，则执行其后语句
    • {% for %} 循环内部,可以访问一个名为 forloop 的模板变量,其属性：
      • forloop.counter 的值是一个整数,表示循环的次数。这个属性的值从 1 开始
      • forloop.counter0 与 forloop.counter 类似,不过是从零开始的
      • forloop.revcounter 的值是一个整数,表示循环中剩余的元素数量
      • forloop.revcounter0 与 forloop.revcounter 类似,不过索引是基于零的
      • forloop.first 是个布尔值,第一次循环时为 True
      • forloop.last 是个布尔值,最后一次循环时为 True
      • 在嵌套的循环中, forloop.parentloop 引用父级循环的 forloop 对象

  • ifequal/ifnotequal标签

    • {% ifequal ... ...%} 标签比较两个值,如果相等,显示 {% ifequal %} 和 {% endifequal %} 之间的内容
    • {% ifequal %} 标签支持可选的 {% else %} 子句
    • {% ifequal %} 的参数只能是模板变量、字符串、整数和小数
    • {% ifnotequal %} 测试两个参数是否不相等

  • 注释

    • 注释使用 {# #} 标明
    • 多行注释{% comment %} ，{% endcomment %}

过滤器

+ {{ name|lower }}: lower 过滤器调整 {{ name }} 变量的值——把文本转换成小写
+ 过滤器可以串接:{{ my_list|first|upper }},获取列表中的第一个元素,然后将其转换成大写
+ 有些过滤器可以接受参数:{{ bio|truncatewords:"30" }},显示 bio 变量的前 30 个词
+ addslashes :在反斜线、单引号和双引号前面添加一个反斜线:{ value|addslashes }}
+ date :根据参数中的格式字符串格式化 date 或 datetime 对象:{{ pub_date|date:"F j, Y"}},
+ length :返回值的长度。对列表来说,返回元素的数量。对字符串来说,返回字符的数量。如果变量未定义,返回 0 。

模板加载机制

  • settings.py 文件中, TEMPLATES 设置。它的值是一个列表,分别针对各个模板引擎，模板引擎是字典,有以下设置：
    • BACKEND 的值是Python 路径,指向实现 Django 模板后端 API 的模板引擎类。内置的后端有 djan-go.template.backends.django.DjangoTemplates 和 django.template.backends.jinja2.Jinja2 。
    • DIRS 定义一个目录列表,模板引擎按顺序在里面查找模板源文件
    • APP_DIRS 设定是否在安装的应用中查找模板。按约定, APPS_DIRS 设为 True 时, DjangoTemplates 会在INSTALLED_APPS 中的各个应用里查找名为“templates”的子目录
    • OPTIONS 是一些针对后端的设置
  • 在项目根目录中放一些主模板(例如在 mysite/templates 目录中):''DIRS'': [os.path.join(BASE_DIR, ''templates'')],
  • 视图函数中使用模板加载机制
from django.template.loader import get_template
t = get_template(''current_datetime.html'')  # 传入模块名称，返回模板对象
html = t.render(Context({''current_date'': now}))　　# 出现类型错误，需要字典dir对象而不是Context对象，去掉Context直接{''current_date'': now}或使用Context().update({''current_date'': now)

render()

  • django.shortcuts 模块中 render()
  • 加载模板、创建上下文、渲染模板和创建 HttpResponse 对象全由 render() 调用代替, render() 的返回值是一个 HttpResponse 对象
  • 例子:
from django.shortcuts import render
import datetime


def current_datetime(request):
    now = datetime.datetime.now()
    return render(request, ''current_datetime.html'', {''current_date'': now})

render() 的第一个参数是请求对象,第二个参数是模板名称,第三个单数可选,是一个字段,用于创建传给模板的上下文。如果不指定第三个参数, render() 使用一个空字典。

  • 把模板存储在模板目录的子目录里,只需在模板名称前面加上子目录的名称和一条斜线return render(request, ''dateapp/current_datetime.html'', {''current_date'': now})

include模板标签

  • {% include %},{% include ''nav.html'' %}
  • 作用是引入另一个模板的内容。它的参数是要引入的模板的名称,可以是变量,也可以是硬编码的字符串(放在引号里,单双引号都行)

模板继承

定义有区别的片段

  • 父模板
{% block 块名称,用于区分块 %}子模板可以覆盖块的内容、向块中添加内容,或者原封不动。{% endblock %}
  • 子模块
{% extends "父模板的名称" %}  # 声明子模块,加载父模块,要出现在子模块的第一个模板标签,使用与 get_template() 相同的方法加载
{% block 要覆盖的块名称 %}覆盖的内容{% endblock %}
从父模板中的块里获取内容,使用 {{ block.super }} ,这是一个“魔法”变量,提供父模板中渲染后的文本。向块中添加内容,而不是完全覆盖时就可以这么做

今天的关于Golang模板引擎管道和golang 模板引擎的分享已经结束，谢谢您的关注，如果想了解更多关于django - 模板引擎进阶、Django 模板引擎以及模板、django 默认模板引擎和 jinja2 模板引擎、django-3.模板引擎的相关知识，请在本站进行查询。

本文标签：

上一篇抛出：所有goroutine都在睡眠中-死锁

下一篇Golang模板（并将函子传递给模板）（golang 模板函数）

相关文章