【Flask】扩展：Jinja2 模板（一）

简介

官方手册地址：https://jinja.palletsprojects.com/en/3.1.x/

Jinja2是Python下一个被广泛应用的模版引擎，他的设计思想来源于Django的模版引擎，并扩展了其语法和一系列强大的功能，其中最显著的一个是增加了沙箱执行功能和可选的自动转移功能，这对大多应用的安全性来说是非常重要的。

• 特性

• 沙箱中执行
• 强大的HTML自动转义系统保护系统免受XSS
• 模版继承
• 及时编译最优的python代码
• 可选提前编译模版的时间
• 易于调试。异常的函数直接指向模版中的对应行。
• 可配置的语法

Jinja2 模版过滤器

过滤器是通过管道符号（|）进行使用的，例如：{{ name|length }}，将返回name的长度。过滤器相当于是一个函数，把当前的变量传入到过滤器中，然后过滤器根据自己的功能，再返回相应的值，之后再将结果渲染到页面中。

Jinja2内置过滤器：

• abs(x, /)：返回一个数值的绝对值。例如：-1|abs。
• attr(obj: Any, name: str):
• batch(value: 't.Iterable[V]', linecount: int, fill_with: 't.Optional[V]' = None):

<table>
  {%- for row in items|batch(3, '&nbsp;') %}
    <tr>
    {%- for column in row %}
      <td>{{ column }}</td>
    {%- endfor %}
    </tr>
  {%- endfor %}
</table>

• capitalize(s: str):
• center(value: str, width: int = 80)
• default(value: V, default_value: V = '', boolean: bool = False)：如果当前变量没有值，则会使用参数中的值来代替。name|default('xiaotuo')——如果name不存在，则会使用xiaotuo来替代。boolean=False默认是在只有这个变量为undefined的时候才会使用default中的值，如果想使用python的形式判断是否为false，则可以传递boolean=true。也可以使用or来替换。

{{ my_variable|default('my_variable is not defined') }}

• dictsort(value: Mapping[K, V], case_sensitive: bool = False, by: 'te.Literal["key", "value"]' = 'key', reverse: bool = False):

{% for key, value in mydict|dictsort %}
    sort the dict by key, case insensitive

{% for key, value in mydict|dictsort(reverse=true) %}
   sort the dict by key, case insensitive, reverse order

{% for key, value in mydict|dictsort(true) %}
   sort the dict by key, case sensitive

{% for key, value in mydict|dictsort(false, 'value') %}
   sort the dict by value, case insensitive

• escape(value)或e：转义字符，会将<、>等符号转义成HTML中的符号。例如：content|escape或content|e。
• filesizeformat(value: Union[str, float, int], binary: bool = False):
• first(seq: 't.Iterable[V]')：返回一个序列的第一个元素。names|first。
• float(value: Any, default: float = 0.0)：将值转换为float类型。
• forceescape(value: 't.Union[str, HasHTML]'):
• format(value: str, *args: Any, **kwargs: Any)：格式化字符串。例如以下代码：

{{ "%s, %s!"|format(greeting, name) }}

{{ "%s, %s!" % (greeting, name) }}
{{ "{}, {}!".format(greeting, name) }}

• groupby(value: 't.Iterable[V]', attribute: Union[str, int], default: Optional[Any] = None)

<ul>{% for city, items in users|groupby("city") %}
    <li>{{ city }}
      <ul>{% for user in items %}
        <li>{{ user.name }}
      {% endfor %}</ul>
    </li>
  {% endfor %}
</ul>

• indent(s: str, width: Union[int, str] = 4, first: bool = False, blank: bool = False)
• int(value: Any, default: int = 0, base: int = 10)：将值转换为int类型。
• join(value: Iterable, d: str = '', attribute: Union[str, int, NoneType] = None): 将一个序列用d这个参数的值拼接成字符串。

{{ [1, 2, 3]|join('|') }}
{{ [1, 2, 3]|join }}

• last(seq: 't.Reversible[V]')：返回一个序列的最后一个元素。示例：names|last。
• length(obj, /)：返回一个序列或者字典的长度。示例：names|length。
• list(value: 't.Iterable[V]')
• lower(s: str)：将字符串转换为小写。
• map(value: Iterable, *args: Any, **kwargs: Any)
• max(value: 't.Iterable[V]', case_sensitive: bool = False, attribute: Union[str, int, NoneType] = None){{ [1, 2, 3]|max }}
• min(value: 't.Iterable[V]', case_sensitive: bool = False, attribute: Union[str, int, NoneType] = None){{ [1, 2, 3]|min }}
• pprint(value: Any)
• random(seq: 't.Sequence[V]')
• reject(value: 't.Iterable[V]', *args: Any, **kwargs: Any)
• rejectattr(value: 't.Iterable[V]', *args: Any, **kwargs: Any)

{{ users|rejectattr("is_active") }}
{{ users|rejectattr("email", "none") }}

• replace(s: str, old: str, new: str, count: Optional[int] = None)：替换将old替换为new的字符串。

{{ "Hello World"|replace("Hello", "Goodbye") }}
{{ "aaaaargh"|replace("a", "d'oh, ", 2) }}

• reverse(value: Union[str, Iterable[V]])
• round(value: float, precision: int = 0, method: 'te.Literal["common", "ceil", "floor"]' = 'common')

{{ 42.55|round }}
{{ 42.55|round(1, 'floor') }}
{{ 42.55|round|int }}

• safe(value: str)：如果开启了全局转义，那么safe过滤器会将变量关掉转义。示例：content_html|safe。
• select(value: 't.Iterable[V]', *args: Any, **kwargs: Any)

{{ numbers|select("odd") }}
{{ numbers|select("odd") }}
{{ numbers|select("divisibleby", 3) }}
{{ numbers|select("lessthan", 42) }}
{{ strings|select("equalto", "mystring") }}

• selectattr(value: 't.Iterable[V]', *args: Any, **kwargs: Any)

{{ users|selectattr("is_active") }}
{{ users|selectattr("email", "none") }}

• slice(value: 't.Collection[V]', slices: int, fill_with: 't.Optional[V]' = None)

<div class="columnwrapper">
    {%- for column in items|slice(3) %}
      <ul class="column-{{ loop.index }}">
      {%- for item in column %}
        <li>{{ item }}</li>
      {%- endfor %}
      </ul>
    {%- endfor %}
</div>

• sort(value: 't.Iterable[V]', reverse: bool = False, case_sensitive: bool = False, attribute: Union[str, int, NoneType] = None)

{% for user in users|sort(attribute="name")
    |sort(reverse=true, attribute="age") %}
    ...
{% endfor %}

• string(value)：将变量转换成字符串。
• striptags(value: 't.Union[str, HasHTML]')：删除字符串中所有的HTML标签，如果出现多个空格，将替换成一个空格。
• sum(iterable: 't.Iterable[V]', attribute: Union[str, int, NoneType] = None, start: V = 0)

{{ items|sum(attribute='price') }}

• title(s: str)
• tojson(value: Any, indent: Optional[int] = None)
• trim(value: str, chars: Optional[str] = None)：截取字符串前面和后面的空白字符。
• truncate(s: str, length: int = 255, killwords: bool = False, end: str = '...', leeway: Optional[int] = None)：截取length长度的字符串。

{{ "foo bar baz qux"|truncate(9) }}
{{ "foo bar baz qux"|truncate(9, True) }}
{{ "foo bar baz qux"|truncate(11) }}
{{ "foo bar baz qux"|truncate(11, False, '...', 0) }}

• unique(value: 't.Iterable[V]', case_sensitive: bool = False, attribute: Union[str, int, NoneType] = None)

{{ ['foo', 'bar', 'foobar', 'FooBar']|unique|list }}

• upper(s: str)：将字符串转换为大写。
• urlencode(value: Union[str, Mapping[str, Any], Iterable[Tuple[str, Any]]])
• urlize(value: str, trim_url_limit: Optional[int] = None, nofollow: bool = False, target: Optional[str] = None, rel: Optional[str] = None, extra_schemes: Optional[Iterable[str]] = None)
• wordcount(s: str)：计算一个长字符串中单词的个数。
• wordwrap(s: str, width: int = 79, break_long_words: bool = True, wrapstring: Optional[str] = None, break_on_hyphens: bool = True)
• xmlattr(d: Mapping[str, Any], autospace: bool = True)

Jinja2 控制语句

所有的控制语句都是放在{% ... %}中，并且有一个语句{% endxxx %}来进行结束，Jinja中常用的控制语句有if/for..in..。

• if：if语句和python中的类似，可以使用>，<，<=，>=，==，!=来进行判断，也可以通过and，or，not，()来进行逻辑合并操作。

  {% if <条件> %}
      <结果>
  {% elif <条件> %}
      <结果>
  {% else %}
      <结果>
  {% endif %}

• for...in...：for循环可以遍历任何一个序列包括列表、字典、元组。并且可以进行反向遍历。

• 普通的遍历

<ul>
  {% for user in users %}
      <li>{{ user.username|e }}</li>
  {% endfor %}
</ul>

• 遍历字典

<dl>
    {% for key, value in my_dict.items() %}
        <dt>{{ key|e }}</dt>
        <dd>{{ value|e }}</dd>
    {% endfor %}
</dl>

• 如果序列中没有值的时候，进入else

<ul>
    {% for user in users %}
        <li>{{ user.username|e }}</li>
    {% else %}
        <li><em>no users found</em></li>
    {% endfor %}
</ul>

并且Jinja中的for循环还包含以下变量，可以用来获取当前的遍历状态：

变量	描述
loop.index	当前迭代的索引（从1开始）
loop.index0	当前迭代的索引（从0开始）
loop.first	是否是第一次迭代，返回True或False
loop.last	是否是最后一次迭代，返回True或False
loop.length	序列的长度