当前位置: 首页 > 工具软件 > ThinkJS > 使用案例 >

thinkjs能在浏览器html文件,thinkjs框架的默认模板引擎Nunjucks的中文文档

施博文
2023-12-01

Node 端使用

$ npm install nunjucks

0

$npminstallnunjucks

下载后可直接 require('nunjucks') 使用

浏览器端使用

可直接使用 nunjucks.js (min),如果针对编译后的模板可使用 nunjucks-slim.js (min)。

你应该使用哪个文件

nunjucks.js 可用于动态加载模板,当模板变化时重新加载,也可以用于预编译后的模板。包含编译器,所以会比较大 (20K min/gzipped)。如果你刚接触 nunjucks 可使用这个文件,如果你不在意大小也可以在生产环境使用。

nunjucks-slim.js 只能用于预编译后的模板,只包含运行时的代码,所以比较小 (8K min/gzipped)。一般用于生产环境,如果你使用 grunt 或gulp任务自动预编译,也可以在开发环境使用。

直接用 script 引入文件:

0

或者可以作为一个 AMD 模块加载:

define(['nunjucks'], function(nunjucks) {

});

0

1

define(['nunjucks'],function(nunjucks){

});

确保在生产环境使用预编译版本,可使用 grunt或gulp,可在 浏览器使用 查看客户端优化的配置。

使用说明

这是最简单使用 nunjucks 的方式,首先设置配置项(如 autoescaping),然后渲染一个字符串:

nunjucks.configure({ autoescape: true });

nunjucks.renderString('Hello {{ username }}', { username: 'James' });

0

1

nunjucks.configure({autoescape:true});

nunjucks.renderString('Hello {{ username }}',{username:'James'});

renderString 并不常用,而是使用 render 来直接渲染文件,这种方式支持继承(extends)和包含(include)模板。使用之前需要配置文件的路径:

nunjucks.configure('views', { autoescape: true });

nunjucks.render('index.html', { foo: 'bar' });

0

1

nunjucks.configure('views',{autoescape:true});

nunjucks.render('index.html',{foo:'bar'});

在 node 端,'views' 为相对于当前工作目录 (working directory) 的路径。在浏览器端则为一个相对的 url,最好指定为绝对路径 (如 '/views')。

如果使用 express 可直接传入 configure:

var app = express();

nunjucks.configure('views', {

autoescape: true,

express: app

});

app.get('/', function(req, res) {

res.render('index.html');

});

0

1

2

3

4

5

6

7

8

9

varapp=express();

nunjucks.configure('views',{

autoescape:true,

express:app

});

app.get('/',function(req,res){

res.render('index.html');

});

上面的 API 适用于 node 端和浏览器端 (express 只适用于 node 端),在 node 端 nunjucks 从文件系统加载模板,在浏览器端通过 http 加载模板。

如果你在浏览器上使用编译后的模板的话,你不需要额外做其他的事情系统也能够理解它们。这使得我们可以轻松地在开发环境和生产环境上使用同一份代码,并在生产环境上只使用已经编译过的模板。

———————-

thinkjs框架的默认模板引擎Nunjucks的中文文档

文件扩展名

虽然你可以用任意扩展名来命名你的Nunjucks模版或文件,但Nunjucks社区还是推荐使用.njk。

如果你在给Nunjucks开发工具或是编辑器上的语法插件时,请记得使用.njk扩展名。

变量

变量会从模板上下文获取,如果你想显示一个变量可以:

{{ username }}

0

{{username}}

会从上下文查找 username 然后显示,可以像 javascript 一样获取变量的属性 (可使用点操作符或者中括号操作符):

{{ foo.bar }}

{{ foo["bar"] }}

0

1

{{foo.bar}}

{{foo["bar"]}}

如果变量的值为 undefined 或 null 将不显示,引用到 undefined 或 null 对象也是如此 (如 foo 为 undefined,{{ foo }}, {{ foo.bar }}, {{ foo.bar.baz }} 也不显示)。

过滤器

过滤器是一些可以执行变量的函数,通过管道操作符 (|) 调用,并可接受参数。

{{ foo | title }}

{{ foo | join(",") }}

{{ foo | replace("foo", "bar") | capitalize }}

0

1

2

{{foo|title}}

{{foo|join(",")}}

{{foo|replace("foo","bar")|capitalize}}

第三个例子展示了链式过滤器,最终会显示 “Bar”,第一个过滤器将 “foo” 替换成 “bar”,第二个过滤器将首字母大写。

Nunjucks 提供了一些内置的过滤器,你也可以自定义过滤器。

模板继承

模板继承可以达到模板复用的效果,当写一个模板的时候可以定义 “blocks”,子模板可以覆盖他,同时支持多层继承。

如果有一个叫做 parent.html 的模板,如下所示:

{% block header %}

This is the default content

{% endblock %}

{% block left %}{% endblock %}

{% block right %}

This is more content

{% endblock %}

0

1

2

3

4

5

6

7

8

9

10

11

12

{%blockheader%}

Thisisthedefaultcontent

{%endblock%}

{%blockleft%}{%endblock%}

{%blockright%}

Thisismorecontent

{%endblock%}

然后再写一个模板继承他

{% extends "parent.html" %}

{% block left %}

This is the left side!

{% endblock %}

{% block right %}

This is the right side!

{% endblock %}

0

1

2

3

4

5

6

7

8

{%extends"parent.html"%}

{%blockleft%}

Thisistheleftside!

{%endblock%}

{%blockright%}

Thisistherightside!

{%endblock%}

以下为渲染结果

This is the default content

This is the left side!

This is the right side!

0

1

2

3

4

5

6

7

8

Thisisthedefaultcontent

Thisistheleftside!

Thisistherightside!

你可以将继承的模板设为一个变量,这样就可以动态指定继承的模板。这个变量既可以是个指向模板文件的字符串,也可以是个模板编译后所生成的对象(需要添加上下文环境)。因此你可以通过设置上下文变量,从而在渲染时动态地改变所要继承的模板。

{% extends parentTemplate %}

0

{%extendsparentTemplate%}

super

你可以通过调用super从而将父级区块中的内容渲染到子区块中。如果在前面的例子中你的子模板是这样的:

{% block right %}

{{ super() }}

Right side!

{% endblock %}

0

1

2

3

{%blockright%}

{{super()}}

Rightside!

{%endblock%}

这个区块的渲染结果将是:

This is more content

Right side!

0

1

Thisismorecontent

Rightside!

标签

标签是一些特殊的区块,它们可以对模板执行一些操作。Nunjucks 包含一些内置的标签,你也可以自定义。

if

if 为分支语句,与 javascript 中的 if 类似。

{% if variable %}

It is true

{% endif %}

0

1

2

{%ifvariable%}

Itistrue

{%endif%}

如果 variable 定义了并且为 true (译者注:这里并非布尔值,和 javascript 的处理是一样的) 则会显示 “It is true”,否则什么也不显示。

{% if hungry %}

I am hungry

{% elif tired %}

I am tired

{% else %}

I am good!

{% endif %}

0

1

2

3

4

5

6

{%ifhungry%}

Iamhungry

{%eliftired%}

Iamtired

{%else%}

Iamgood!

{%endif%}

在内联表达式(inline expression)中也可以使用 if。

for

for 可以遍历数组 (arrays) 和对象 (dictionaries)。

如果你使用的自定义模板加载器为异步的可查看 asyncEach

var items = [{ title: "foo", id: 1 }, { title: "bar", id: 2}];

0

varitems=[{title:"foo",id:1},{title:"bar",id:2}];

Posts

{% for item in items %}

{{ item.title }}

{% else %}

This would display if the 'item' collection were empty

{% endfor %}

0

1

2

3

4

5

6

7

Posts

{%foriteminitems%}

{{item.title}}

{%else%}

Thiswoulddisplayifthe'item'collectionwereempty

{%endfor%}

上面的示例通过使用items数组中的每一项的title属性显示了所有文章的标题。如果items数组是空数组的话则会渲染else语句中的内容。

你还可以遍历对象:

var food = {

'ketchup': '5 tbsp',

'mustard': '1 tbsp',

'pickle': '0 tbsp'

};

0

1

2

3

4

varfood={

'ketchup':'5 tbsp',

'mustard':'1 tbsp',

'pickle':'0 tbsp'

};

{% for ingredient, amount in food %}

Use {{ amount }} of {{ ingredient }}

{% endfor %}

0

1

2

{%foringredient,amountinfood%}

Use{{amount}}of{{ingredient}}

{%endfor%}

dictsort 过滤器可将对象排序 (new in 0.1.8)

除此之外,Nunjucks 会将数组解开,数组内的值对应到变量 (new in 0.1.8)

var points = [[0, 1, 2], [5, 6, 7], [12, 13, 14]];

0

varpoints=[[0,1,2],[5,6,7],[12,13,14]];

{% for x, y, z in points %}

Point: {{ x }}, {{ y }}, {{ z }}

{% endfor %}

0

1

2

{%forx,y,zinpoints%}

Point:{{x}},{{y}},{{z}}

{%endfor%}

在循环中可获取一些特殊的变量

loop.index: 当前循环数 (1 indexed)

loop.index0: 当前循环数 (0 indexed)

loop.revindex: 当前循环数,从后往前 (1 indexed)

loop.revindex0: 当前循环数,从后往前 (0 based)

loop.first: 是否第一个

loop.last: 是否最后一个

loop.length: 总数

asyncEach

这个是适用于异步模板,请读文档。

asyncEach 为 for 的异步版本,只有当使用自定义异步模板加载器的时候才使用,否则请不要使用。异步过滤器和扩展也需要他。如果你在循环中使用了异步过滤器的话,Nunjucks就会在内部自动将循环转换成 asyncEach。

asyncEach 和 for 的使用方式一致,但他支持循环的异步控制。将两者区分的原因是性能,大部分人使用同步模板,将 for 转换成原生的 for 语句会快很多。

编译时 nunjuck 不用关心模板是如何加载的,所以无法决定 include 是同步或异步。这也是为什么Nunjucks无法自动将普通的循环语句转换成异步循环语句的原因,所以如果你要使用异步模板加载器的话,就需要使用 asyncEach。

// If you are using a custom loader that is async, you need asyncEach

var env = new nunjucks.Environment(AsyncLoaderFromDatabase, opts);

0

1

// If you are using a custom loader that is async, you need asyncEach

varenv=newnunjucks.Environment(AsyncLoaderFromDatabase,opts);

Posts

{% asyncEach item in items %}

{% include "item-template.html" %}

{% endeach %}

0

1

2

3

4

5

Posts

{%asyncEachiteminitems%}

{%include"item-template.html"%}

{%endeach%}

asyncAll

这个是适用于异步模板,请读文档。

asyncAll 和 asyncEach 类似,但 asyncAll 会并行的执行,并且每项的顺序仍然会保留。除非使用异步的过滤器、扩展或加载器,否则不要使用。

如果你写了一个 lookup 的过滤器用来从数据库获取一些文本,使用 asyncAll 可以并行渲染。

Posts

{% asyncAll item in items %}

{{ item.id | lookup }}

{% endall %}

0

1

2

3

4

5

Posts

{%asyncAlliteminitems%}

{{item.id|lookup}}

{%endall%}

如果 lookup 是一个异步的过滤器,那么可能会比较慢(如从磁盘获取些数据)。asyncAll 会减少执行的时间,他会并行执行所有的异步操作,当所有的操作完成后才会继续渲染页面。

macro

宏 (macro) 可以定义可复用的内容,类似与编程语言中的函数,看下面的示例:

{% macro field(name, value='', type='text') %}

value="{{ value | escape }}" />

{% endmacro %}

0

1

2

3

4

5

{%macrofield(name,value='',type='text')%}

value="{{ value | escape }}"/>

{%endmacro%}

现在 field 可以当作函数一样使用了:

{{ field('user') }}

{{ field('pass', type='password') }}

0

1

{{field('user')}}

{{field('pass',type='password')}}

支持关键字参数,通过链接查看具体使用方式。

还可以从其他模板 import 宏,可以使宏在整个项目中复用。

重要:如果你使用异步 API,请注意你 不能 在宏中做任何异步的操作,因为宏只是像函数一样被简单地调用。将来我们可能会提供一种异步的宏调用方式,但现在这么使用是不被支持的。

set

set 可以设置和修改变量。

{{ username }}

{% set username = "joe" %}

{{ username }}

0

1

2

{{username}}

{%setusername="joe"%}

{{username}}

如果 username 初始化的时候为 “james’, 最终将显示 “james joe”。

可以设置新的变量,并一起赋值。

{% set x, y, z = 5 %}

0

{%setx,y,z=5%}

如果在顶级作用域使用 set,将会改变全局的上下文中的值。如果只在某个作用域 (像是include或是macro) 中使用,则只会影响该作用域。

同样地,你也可以使用区块赋值将一个区块的内容储存在一个变量中。

它的语法和标准的set语法相似,只不过你不需要用=。区块中从头到{% endset %}之间的内容都会被捕获,并作为值来使用。

在某些情境下,你可以用这种语法来替代宏:

{% set standardModal %}

{% include 'standardModalData.html' %}

{% endset %}

0

1

2

3

4

{%setstandardModal%}

{%include'standardModalData.html'%}

{%endset%}

extends

extends 用来指定模板继承,被指定的模板为父级模板,查看模板继承。

{% extends "base.html" %}

0

{%extends"base.html"%}

你可以将继承的模板设为一个变量,这样就可以动态指定继承的模板。这个变量既可以是个指向模板文件的字符串,也可以是个模板编译后所生成的对象(需要添加上下文环境)。因此你可以通过设置上下文变量,从而在渲染时动态地改变所要继承的模板。

{% extends parentTemplate %}

0

{%extendsparentTemplate%}

extends也可以接受任意表达式,只要它最终返回一个字符串或是模板所编译成的对象:

{% extends name + ".html" %}`.

0

{%extendsname+".html"%}`.

block

区块(block) 定义了模板片段并标识一个名字,在模板继承中使用。父级模板可指定一个区块,子模板覆盖这个区块,查看模板继承。

{% block css %}

{% endblock %}

0

1

2

{%blockcss%}

{%endblock%}

可以在循环中定义区块

{% for item in items %}

{% block item %}{{ item }}{% endblock %}

{% endfor %}

0

1

2

{%foriteminitems%}

{%blockitem%}{{item}}{%endblock%}

{%endfor%}

子模板可以覆盖 item 区块并改变里面的内容。

{% extends "item.html" %}

{% block item %}

The name of the item is: {{ item.name }}

{% endblock %}

0

1

2

3

4

{%extends"item.html"%}

{%blockitem%}

Thenameoftheitemis:{{item.name}}

{%endblock%}

在区块中,你可以调用特殊的super函数。它会渲染父级区块中的内容。具体请查看super。

include

include 可引入其他的模板,可以在多模板之间共享一些小模板,如果某个模板已使用了继承那么 include 将会非常有用。

{% include "item.html" %}

0

{%include"item.html"%}

可在循环中引入模板

{% for item in items %}

{% include "item.html" %}

{% endfor %}

0

1

2

{%foriteminitems%}

{%include"item.html"%}

{%endfor%}

这一点可以帮助我们把模板切分成更小的部分,从而使得在浏览器上,当我们需要改变页面时,我们可以渲染这些小部分的模板,而非一整个的大的模板。

include 可以接受任意表达式,只要它最终返回一个字符串或是模板所编译成的对象: {% include name + ".html" as obj %}.

在某些情况下,我们可能希望在模板文件不存在时不要抛出异常。对于这类情况,我们可以使用ignore missing来略过这些异常:

{% include "missing.html" ignore missing %}

0

{%include"missing.html"ignoremissing%}

被包含的模版自身可以扩展(extends)另一个模版(因此你可以让一系列相关联的模版继承同一种结构)。 一个被包含的模版并不会改变包含它的模版的区块结构,它有一个分离的继承树和块级命名空间。换言之, 在渲染时,include并不 不是 将被包含模版代码拉取到包含它的模版中的预处理器。相对的,它对被 包含的模版触发了一次的分离渲染,然后再将渲染的结果引入。

import

import 可加载不同的模板,可使你操作模板输出的数据,模板将会输出宏 (macro) 和在顶级作用域进行的赋值 (使用 set)。

被 import 进来的模板没有当前模板的上下文,所以无法使用当前模板的变量,

创建一个叫 forms.html 如下所示

{% macro field(name, value='', type='text') %}

value="{{ value | escape }}" />

{% endmacro %}

{% macro label(text) %}

{{ text }}

{% endmacro %}

0

1

2

3

4

5

6

7

8

9

10

11

{%macrofield(name,value='',type='text')%}

value="{{ value | escape }}"/>

{%endmacro%}

{%macrolabel(text)%}

{{text}}

{%endmacro%}

我们可以 import 这个模板并将模板的输出绑定到变量 forms 上,然后就可以使用这个变量了:

{% import "forms.html" as forms %}

{{ forms.label('Username') }}

{{ forms.field('user') }}

{{ forms.label('Password') }}

{{ forms.field('pass', type='password') }}

0

1

2

3

4

5

{%import"forms.html"asforms%}

{{forms.label('Username')}}

{{forms.field('user')}}

{{forms.label('Password')}}

{{forms.field('pass',type='password')}}

也可以使用 from import 从模板中 import 指定的值到当前的命名空间:

{% from "forms.html" import input, label as description %}

{{ description('Username') }}

{{ input('user') }}

{{ description('Password') }}

{{ input('pass', type='password') }}

0

1

2

3

4

5

{%from"forms.html"importinput,labelasdescription%}

{{description('Username')}}

{{input('user')}}

{{description('Password')}}

{{input('pass',type='password')}}

import 可以接受任意表达式,只要它最终返回一个字符串或是模板所编译成的对象: {% import name + ".html" as obj %}.

raw

如果你想输出一些 Nunjucks 特殊的标签 (如 {{),可以使用 {{),可以使用 {% raw %} 将所有的内容输出为纯文本。

filter

filter区块允许我们使用区块中的内容来调用过滤器。不同于使用|语法,它会将区块渲染出的内容传递给过滤器。

{% filter title %}

may the force be with you

{% endfilter %}

{% filter replace("force", "forth") %}

may the force be with you

{% endfilter %}

0

1

2

3

4

5

6

{%filtertitle%}

maytheforcebewithyou

{%endfilter%}

{%filterreplace("force","forth")%}

maytheforcebewithyou

{%endfilter%}

切记:你不能在这些区块中进行任何异步操作。

call

call区块允许你使用标签之间的内容来调用一个宏。这在你需要给宏传入大量内容时是十分有用的。在宏中,你可以通过caller()来获取这些内容。

{% macro add(x, y) %}

{{ caller() }}: {{ x + y }}

{% endmacro%}

{% call add(1, 2) -%}

The result is

{%- endcall %}

0

1

2

3

4

5

6

{%macroadd(x,y)%}

{{caller()}}:{{x+y}}

{%endmacro%}

{%calladd(1,2)-%}

Theresultis

{%-endcall%}

上面的例子将会输出”The result is: 3″。

关键字参数

jinja2 使用 Python 的关键字参数,支持函数,过滤器和宏。Nunjucks 会通过一个调用转换 (calling convention) 来支持。

关键字参数如下:

{{ foo(1, 2, bar=3, baz=4) }}

0

{{foo(1,2,bar=3,baz=4)}}

bar 和 baz 为关键字参数,Nunjucks 将他们转换成一个对象作为最后一个参数传入,等价于 javascript 的如下调用:

foo(1, 2, { bar: 3, baz: 4})

0

foo(1,2,{bar:3,baz:4})

因为这使一个标准的调用转换,所以适用于所有的符合预期的函数和过滤器。查看 API 章节获得更多信息。

定义宏的时候也可以使用关键字参数,定义参数值时可设置默认值。Nunjucks 会自动将关键字参数与宏里定义的值做匹配。

{% macro foo(x, y, z=5, w=6) %}

{{ x }}, {{ y }}, {{ z }}, {{ w}}

{% endmacro %}

{{ foo(1, 2) }} -> 1, 2, 5, 6

{{ foo(1, 2, w=10) }} -> 1, 2, 5, 10

0

1

2

3

4

5

{%macrofoo(x,y,z=5,w=6)%}

{{x}},{{y}},{{z}},{{w}}

{%endmacro%}

{{foo(1,2)}}->1,2,5,6

{{foo(1,2,w=10)}}->1,2,5,10

在宏中还可以混合使用位置参数 (positional arguments) 和关键字参数。如示例,你可以将位置参数用作关键字参数:

{{ foo(20, y=21) }} -> 20, 21, 5, 6

0

{{foo(20,y=21)}}->20,21,5,6

你还可以用位置参数来替换关键字参数:

{{ foo(5, 6, 7, 8) }} -> 5, 6, 7, 8

0

{{foo(5,6,7,8)}}->5,6,7,8

如下示例,你可以跳过 (“skip”) 位置参数:

{{ foo(8, z=7) }} -> 8, , 7, 6

0

{{foo(8,z=7)}}->8,,7,6

注释

你可以使用 {# and #} 来写注释,渲染时将会去除所有的注释。

{# Loop through all the users #}

{% for user in users %}...{% endfor %}

0

1

{# Loop through all the users #}

{%foruserinusers%}...{%endfor%}

空白字符控制

模板在正常情况会将变量 (variable) 和标签区块 (tag blocks) 周围的空白字符完全输出。有时,你不想输出一些额外的空白字符,但代码又需要一些空白字符来显得整洁。

你可以在开始和结束区块 (start or end block tag) 添加 (-) 来去除前面和后面的空白字符。

{% for i in [1,2,3,4,5] -%}

{{ i }}

{%- endfor %}

0

1

2

{%foriin[1,2,3,4,5]-%}

{{i}}

{%-endfor%}

上面准确的输出为 “12345″,-%} 会去除标签右侧的空白字符,{%- 会去除标签之前的空白字符。

表达式

你可以使用和 javascript 一样的字面量。

Strings: "How are you?", 'How are you?'

Numbers: 40, 30.123

Arrays: [1, 2, "array"]

Dicts: { one: 1, two: 2 }

Boolean: true, false

运算 (Math)

Nunjucks 支持运算 (但尽量少用,把逻辑放在代码中),可使用以下操作符:

Addition: +

Subtraction: -

Division: /

Division and integer truncation: //

Division remainder: %

Multiplication: *

Power: **

可以如下使用:

{{ 2 + 3 }} (outputs 5)

{{ 10/5 }} (outputs 2)

{{ numItems*2 }}

0

1

2

{{2+3}}(outputs5)

{{10/5}}(outputs2)

{{numItems*2}}

比较 (Comparisons)

==

===

!=

!==

>

>=

<

<=

Examples:

{%-` 会去除标签之前的空白字符。

## 表达式

你可以使用和 javascript 一样的字面量。

* Strings: `"How are you?"`, `'How are you?'`

* Numbers: `40`, `30.123`

* Arrays: `[1, 2, "array"]`

* Dicts: `{ one: 1, two: 2 }`

* Boolean: `true`, `false`

### 运算 (Math)

Nunjucks 支持运算 (但尽量少用,把逻辑放在代码中),可使用以下操作符:

* Addition: `+`

* Subtraction: `-`

* Division: `/`

* Division and integer truncation: `//`

* Division remainder: `%`

* Multiplication: `*`

* Power: `**`

可以如下使用:

```jinja

{{ 2 + 3 }} (outputs 5)

{{ 10/5 }} (outputs 2)

{{ numItems*2 }}

0

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

{%-`会去除标签之前的空白字符。

## 表达式

你可以使用和javascript一样的字面量。

*Strings:`"How are you?"`,`'How are you?'`

*Numbers:`40`,`30.123`

*Arrays:`[1,2,"array"]`

*Dicts:`{one:1,two:2}`

*Boolean:`true`,`false`

### 运算 (Math)

Nunjucks支持运算(但尽量少用,把逻辑放在代码中),可使用以下操作符:

*Addition:`+`

*Subtraction:`-`

*Division:`/`

*Divisionandintegertruncation:`//`

*Divisionremainder:`%`

*Multiplication:`*`

*Power:`**`

可以如下使用:

```jinja

{{2+3}}(outputs5)

{{10/5}}(outputs2)

{{numItems*2}}

比较 (Comparisons)

==

===

!=

!==

>

>=

<

<=

Examples:

{% if numUsers < 5 %}...{% endif %}

{% if i == 0 %}...{% endif %}

0

1

{%ifnumUsers<5%}...{%endif%}

{%ifi==0%}...{%endif%}

Logic

and

or

not

可使用大括号来分组

Examples:

{% if users and showUsers %}...{% endif %}

{% if i == 0 and not hideFirst %}...{% endif %}

{% if (x < 5 or y < 5) and foo %}...{% endif %}

0

1

2

{%ifusersandshowUsers%}...{%endif%}

{%ifi==0andnothideFirst%}...{%endif%}

{%if(x<5ory<5)andfoo%}...{%endif%}

If 表达式

和 javascript 的三元运算符 (ternary operator) 一样,可使用 if 的内联表达式:

{{ "true" if foo else "false" }}

0

{{"true"iffooelse"false"}}

当 foo 为 true 的时候最终输出 “true” 否则为 “false”,对于获取默认值的时候非常有用:

{{ baz(foo if foo else "default") }}

0

{{baz(fooiffooelse"default")}}

函数调用 (Function Calls)

如果你传入一个函数,则可以直接调用

{{ foo(1, 2, 3) }}

0

{{foo(1,2,3)}}

正则表达式

你可以像在JavaScript中一样创建一个正则表达式:

{{ /^foo.*/ }}

{{ /bar$/g }}

0

1

{{/^foo.*/}}

{{/bar$/g}}

正则表达式所支持的标志如下。查阅Regex on MDN以获取更多信息。

g: 应用到全局

i: 不区分大小写

m: 多行模式

y: 粘性支持(sticky)

自动转义 (Autoescaping)

如果在环境变量中设置了 autoescaping,所有的输出都会自动转义,但可以使用 safe 过滤器,Nunjucks 就不会转义了。

{{ foo }} // <span%gt;

{{ foo | safe }} //

0

1

{{foo}}// <span%gt;

{{foo|safe}}//

如果未开启 autoescaping,所有的输出都会如实输出,但可以使用 escape 过滤器来转义。

{{ foo }} //

{{ foo | escape }} // <span>

0

1

{{foo}}//

{{foo|escape}}// <span>

全局函数 (Global Functions)

以下为一些内置的全局函数

range([start], stop, [step])

如果你需要遍历固定范围的数字可以使用 range,start (默认为 0) 为起始数字,stop 为结束数字,step 为间隔 (默认为 1)。

{% for i in range(0, 5) -%}

{{ i }},

{%- endfor %}

0

1

2

{%foriinrange(0,5)-%}

{{i}},

{%-endfor%}

上面输出 0,1,2,3,4.

cycler(item1, item2, …itemN)

cycler 可以循环调用你指定的一系列的值。

{% set cls = cycler("odd", "even") %}

{% for row in rows %}

{{ cls.next() }}">{{ row.name }}

{% endfor %}

0

1

2

3

{%setcls=cycler("odd","even")%}

{%forrowinrows%}

{{ cls.next() }}">{{row.name}}

 类似资料: