DTL 语言着力于为静态的文本提供足够的编程功能，如提供分支和循环等决定呈现相关的逻辑。它主要用于分割文档的表示和数据的字符串文本，模板定义了占位符和各种定义文档应该如何显示的基本逻辑（模板标签“template tag”），模板可用来生成 HTML 或者各种基于文本的格式。Dojo 的 DTL 工具包实现了 DTL 语法的解析，并提供了一系列简单易用的接口用于接收参数，生成和解析基于 DTL 的各种文本或 HTML 页面。这样一来，我们可以基于简单的 DTL 语法构造 HTML 模板，并基于 Dojo 的 DTL 接口实现代码的充分复用。这篇文章将重点介绍 Dojo 的 DTL 工具包以及他们的各种使用方式和技巧。
DTL 模板语言是 Django 框架内置的一套包含特殊标签（tag）和过滤器（filters）的规则集。它包括 autoescape、block、comment、cycle、for、if、ifequal 等等标签和 add、capfirst、center、first、last、length、lower、safe 等等过滤器。这些标签和过滤器如同我们的编程语言一样，可以帮助我们实现各种各样的逻辑。Dojo 的 DTL 工具包基于这套规则实现了上述的大部分标签和过滤器的语法解析功能。所以，我们可以直接在 Dojo 中基于 DTL 模板语言实现我们的各种逻辑。
Dojo 的 DTL 工具包
Dojo 的 DTL 工具包提供了很多接口用于解析我们的“DTL 程序”，它不仅适用于文本的解析，也适用于 HTML 页面。对于之前已经使用 DTL 开发的工程师们，将已有代码移植到 Dojo 中是相当方便的，基本是无缝移植。
接下来我们来看看 Dojo 的 DTL 工具包的一些具体对象和接口。
Context 对象
Context 对象是 Dojo 的 DTL 工具包里用于存放内容的对象，Dojo 通过一些接口将该对象“注入”到模板里，其实 Context 有点类似于实参。来看一个简单示例：
清单 1. 简单 Context 示例
var context = new dojox.dtl.Context(
{foo: "foo", bar: "bar", get: function(key){ return key + "TEST"; }});
var tpl = new dojox.dtl.Template("{{ foo }}-{{ bar }}");
t.is("fooTEST-barTEST", tpl.render(context)); 这里我们初始化了一个 Context 对象，并定义了它的“get”方法，之后我们用该对象“填充”之后创建的 Template。这里的“{{ foo }}”和“{{ bar }}”代表“foo”变量和“bar”变量，所以最后的返回值为"fooTEST-barTEST"。这就是 Context 和 Template 协同的工作模式。
在来看一个内容过滤器的例子：
清单 2. Context 过滤
var context = new dojox.dtl.Context({ foo: "one", bar: "two", baz: "three" });
var filtered = context.filter("foo", "bar");
t.is(filtered.foo, "one");
t.is(filtered.bar, "two");
t.f(filtered.baz); filtered = context.filter({ bar: true, baz: true });
t.f(filtered.foo);
t.is(filtered.bar, "two");
t.is(filtered.baz, "three"); filtered = context.filter(new dojox.dtl.Context({ foo: true, baz: true }));
t.is(filtered.foo, "one");
t.f(filtered.bar);
t.is(filtered.baz, "three"); 这里我们提供了三种过滤的示例：
1. “context.filter("foo", "bar")”：直接通过属性名可以过滤掉除“foo”和“bar”以外的所有其它属性。
2. “context.filter({ bar: true, baz: true })”：也可以通过 true 或者 false 实现过滤。
3. “context.filter(new dojox.dtl.Context({ foo: true, baz: true }))”：新建一个 Context 对象过滤也是可以的。
除了过滤，我们的 Context 对象也可以被扩展：
清单 3. Context 扩展
var context = new dojox.dtl.Context({ foo: "one" });
var extended = context.extend({ bar: "two", baz: "three" });
t.is(extended.foo, "one");
t.is(extended.bar, "two");
t.is(extended.baz, "three");
extended = context.extend({ barr: "two", bazz: "three" });
t.is(extended.foo, "one");
t.f(extended.bar);
t.f(extended.baz);
t.is(extended.barr, "two");
t.is(extended.bazz, "three");
t.f(context.bar)
t.f(context.baz);
t.f(context.barr);
t.f(context.bazz); 文本模板之标签（Tag）
介绍完了 Context 对象，我们要来说说模板了。Context 内容对象是和模板（Template）对象协同工作的，并且它们基于 DTL 模板语言。我们先来看一个简单的文本模板示例：
清单 4. 简单文本模板
var dd = dojox.dtl;
var template = new dd.Template(
'{% extends "../../dojox/dtl/tests/templates/pocket.html" %}
{% block pocket %}Simple{% endblock %}');
t.is("Simple Pocket", template.render()); 再来看几个复杂点的例子：
清单 5. 简单文本模板进阶
var dd = dojox.dtl;
// 参数传递 1
var context = new dd.Context({
parent: "../../dojox/dtl/tests/templates/pocket.html"
})
template = new dd.Template('
{% extends parent %}{% block pocket %}Variabled{% endblock %}');
t.is("Variabled Pocket", template.render(context));
// 参数传递 2
context.parent = dojo.moduleUrl("dojox.dtl.tests.templates", "pocket.html");
template = new dd.Template('
{% extends parent %}{% block pocket %}Slightly More Advanced{% endblock %}');
t.is("Slightly More Advanced Pocket", template.render(context));
// 参数传递 3
context.parent = {
url: dojo.moduleUrl("dojox.dtl.tests.templates", "pocket.html")
}
template = new dd.Template('
{% extends parent %}{% block pocket %}Super{% endblock %}');
t.is("Super Pocket", template.render(context)); 除了传递模板 HTML，Context 也支持其它各种方式的实参传递：
清单 6. 文本模板传参
var dd = dojox.dtl;
var context = new dd.Context({
parent: dojo.moduleUrl("dojox.dtl.tests.templates", "pocket2.html"),
items: ["apple", "banana", "lemon" ]
});
var template = new dd.Template("
{% extends parent %}{% block pocket %}My {{ item }}{% endblock %}");
t.is("(My apple) (My banana) (My lemon) Pocket", template.render(context)); 清单 7. 父模板 pocket2.html
{% for item in items %}(
{% block pocket %}
Hot
{% endblock %}
) {% endfor %}
Pocket 根据 DTL 语法的规则，父模板的 block--“pocket ”会被子模板的 block--“pocket ”替代，然后通过解析 Context 传入的 items 参数，最后的执行结果应该为："(My apple) (My banana) (My lemon) Pocket"。
其实，我们也可以通过“block.super”在子模板里面访问父模板的内容：“{% extends parent %}{% block pocket %}My {{ item }} {{ block.super }} { % endblock %}”。
当然，DTL 语句也支持注释：
清单 8. 文本模板注释
var template = new dd.Template('
Hot{% comment %}<strong>Make me disappear</strong>{% endcomment %} Pocket');
t.is("Hot Pocket", template.render()); 再来看看 Cycle 标签：
清单 9. 文本模板 Cycle 标签
var context = new dd.Context({
items: ["apple", "banana", "lemon"],
unplugged: "Torrey"
});
var template = new dd.Template("
{% for item in items %}{% cycle 'Hot' 'Diarrhea' unplugged 'Extra' %}
Pocket. {% endfor %}");
t.is("Hot Pocket. Diarrhea Pocket. Torrey Pocket. ", template.render(context)); 再来看一个关于 Cycle 的稍微复杂一点的例子：
清单 10. 文本模板 Cycle 标签进阶
context = new dojox.dtl.Context({ unplugged: "Torrey" });
template = new dd.Template("
{% cycle 'Hot' 'Diarrhea' unplugged 'Extra' as steakum %}
Pocket. {% cycle steakum %} Pocket. {% cycle steakum %} Pocket.");
t.is("Hot Pocket. Diarrhea Pocket. Torrey Pocket.", template.render(context)); 这里的 Cycle 我们通过“as steakum”来给这个 Cycle 定义了一个引用，这样，我们可以在以后的代码里重复利用该 Cycle，通过“{% cycle steakum %}”来取它列表里面的下一个值。
接下来我们介绍一下“filter”标签：
清单 11. 文本模板 Filter 标签
var template = new dd.Template('
{% filter lower|center:"15" %}Hot Pocket{% endfilter %}');
t.is(" hot pocket ", template.render()); 这里的 Filter 标签用于格式化文本内容，“{% filter lower|center:"15" %}”表示将字体转为小写，居中并保持 15 个字符（不足补空格）。
再来看看“firstof”标签：
清单 12. 文本模板 Firstof 标签
var dd = dojox.dtl;
var context = new dd.Context({
found: "unicorn"
});
var template = new dd.Template("{% firstof one two three four found %}");
t.is("unicorn", template.render(context));
context.four = null;
t.is("null", template.render(context));
context.three = false;
t.is("false", template.render(context)); 关于“include”标签，示例如下：
清单 13. 文本模板 Include 标签
var dd = dojox.dtl;
var context = new dd.Context({
hello: dojo.moduleUrl("dojox.dtl.tests.templates", "hello.html"),
person: "Bob",
people: ["Charles", "Ralph", "Julia"]
});
var template = new dd.Template("{% include hello %}");
t.is("Hello, <span>Bob</span>", template.render(context)); 清单 14. 文本模板 Spaceless 标签
var dd = dojox.dtl;
var template = new dd.Template("
{% spaceless %}<ul> \n <li>Hot</li> \n\n<li>
Pocket </li>\n </ul>{% endspaceless %}");
t.is("
<ul><li>Hot</li><li>Pocket </li></ul>",
template.render()); 接下来还有各种 Dojo 支持的标签，如：for，if，ifchanged，ifequal，include，with，withratio 等等，它们的语法与 DTL 一样，有兴趣的读者可以参考 DTL 的语法介绍，我们这里不再一一介绍。
文本模板之过滤（Filter）
接下来我们要介绍过滤器，过滤器在 DTL 里面更多的是一种辅助的操作，我们先来看一个例子：
清单 15. 文本过滤 Add 操作
var dd = dojox.dtl;
var context = new dd.Context({ four: 4 });
tpl = new dd.Template('{{ four|add:"6" }}');
t.is("10", tpl.render(context));
context.four = "4";
t.is("10", tpl.render(context));
tpl = new dd.Template('{{ four|add:"six" }}');
t.is("4", tpl.render(context));
tpl = new dd.Template('{{ four|add:"6.6" }}');
t.is("10", tpl.render(context)); 其实这里的“add”操作兼容范围很广泛，它会强制转换相应的操作对象，如果不行，则会按照一种默认的方式实现“加”操作，适用于整数，小数甚至数组或列表型数据。
再来看一个“cut”的示例
清单 16. 文本过滤 Cut 操作
var dd = dojox.dtl;
var context = new dd.Context({ uncut: "Apples and oranges" });
var tpl = new dd.Template('{{ uncut|cut }}');
t.is("Apples and oranges", tpl.render(context));
tpl = new dd.Template('{{ uncut|cut:"A" }}');
t.is("pples and oranges", tpl.render(context));
tpl = new dd.Template('{{ uncut|cut:" " }}');
t.is("Applesandoranges", tpl.render(context));
tpl = new dd.Template('{{ uncut|cut:"e" }}');
t.is("Appls and orangs", tpl.render(context)); 清单 17. 文本过滤 Default
var dd = dojox.dtl;
var context = new dd.Context();
tpl = new dd.Template('{{ empty|default }}');
t.is("", tpl.render(context));
tpl = new dd.Template('{{ empty|default:"full" }}');
t.is("full", tpl.render(context));
context.empty = "not empty";
t.is("not empty", tpl.render(context)); 以上是几个比较简单的过滤操作，再来看几个稍微复杂的：
清单 18. 文本过滤 Dictsort
var dd = dojox.dtl;
var context = new dd.Context({
fruit: [
{ name: "lemons", toString: function(){ return this.name; } },
{ name: "apples", toString: function(){ return this.name; } },
{ name: "grapes", toString: function(){ return this.name; } }
]
});
tpl = new dd.Template('{{ fruit|dictsort|join:"|" }}');
t.is("lemons|apples|grapes", tpl.render(context));
tpl = new dd.Template('{{ fruit|dictsort:"name"|join:"|" }}');
t.is("apples|grapes|lemons", tpl.render(context)); 清单 19. 文本过滤 Truncatewords
var dd = dojox.dtl;
var context = new dd.Context({ word: "potted meat writes a lot of tests" });
var tpl = new dd.Template("{{ word|truncatewords }}");
t.is(context.word, tpl.render(context));
tpl = new dd.Template('{{ word|truncatewords:"1" }}');
t.is("potted", tpl.render(context));
tpl = new dd.Template('{{ word|truncatewords:"2" }}');
t.is("potted meat", tpl.render(context));
tpl = new dd.Template('{{ word|truncatewords:20" }}');
t.is(context.word, tpl.render(context));
context.word = "potted \nmeat \nwrites a lot of tests";
tpl = new dd.Template('{{ word|truncatewords:"3" }}');
t.is("potted \nmeat \nwrites", tpl.render(context)); 关于过滤器还有很多很多的 Dojo 支持的操作，如：filesizeformat，fix_ampersands，iriencode，pluralize，removetags，slice，urlencode 等等，它们的语法也与 DTL 一样，有兴趣的读者可以参考 DTL 的关于 Filter 相关内容，我们这里也不再一一介绍了。
DOM 模板
之前介绍的一些标签和过滤器是基于文本的，接下来我们会介绍 Dojo 的 DTL 工具包的针对 DOM 的一些标签和过滤相关的接口，这些接口会默认您的模板是标准 HTML 格式的，如果不是，它会检测到并抛出异常。这些接口非常适用于将我们之前写好的基于 DTL 的 HTML 模板无缝的集成到 Dojo 中来。
清单 20. DOM 模板错误检测
var dd = dojox.dtl;
var template;
var found = false;
try {
template = new dd.DomTemplate('No div');
dd.tests.dom.util.render(template);
}catch(e){
t.is("Text should not exist outside of the root node in template", e.message);
found = true;
}
t.t(found);
t.is("potted meat", tpl.render(context));
template = new dd.DomTemplate('<div></div>extra content');
found = false;
try {
dd.tests.dom.util.render(template);
}catch(e){
t.is("Content should not exist outside of the root node in template", e.message);
found = true;
}
t.t(found); 再来看两个关于报错的示例：
清单 21. DOM 模板错误检测进阶
template = new dd.DomTemplate('<div></div><div></div>');
found = false;
try {
dd.tests.dom.util.render(template);
}catch(e){
t.is("Content should not exist outside of the root node in template", e.message);
found = true;
}
t.t(found);
template = new dd.DomTemplate('{% if missing %}<div></div>{% endif %}');
found = false;
try {
dd.tests.dom.util.render(template);
}catch(e){
t.is("Rendered template does not have a root node", e.message);
found = true;
}
t.t(found); 我们可以尽可能的利用 DTL 语言的方便为我们构建“动态”的 HTML 页面，一下是一个关于元素属性的示例：
清单 22. DOM 模板元素属性
var dd = dojox.dtl;
var template = new dd.DomTemplate('
<div>{% for item in items %}<a index="{{forloop.counter0}}"
id="id_{{item.param}}">{{item.param}}</a>{% endfor %}</div>');
var context = new dd.Context({
items: [
{
name: "apple",
param: "appleparam"
},
{
name: "banana",
param: "bananaparam"
},
{
name: "orange",
param: "orangeparam"
}
]
});
doh.is('<div><a index="0" id="id_appleparam">appleparam</a><a index="1"
id="id_bananaparam">bananaparam</a><a index="2"
id="id_orangeparam">orangeparam</a></div>',
dd.tests.dom.util.render(template, context)); 当然，也可以添加自定义的属性：
清单 23. DOM 模板元素自定义属性
var dd = dojox.dtl;
var context = new dd.Context({frag: {start: 10, stop: 20}});
var template = new dd.DomTemplate('
<div startLine="{{ frag.start }}" stopLine="{{ frag.stop }}">abc</div>');
doh.is('
<div startline="10"
stopline="20">abc</div>',
dd.tests.dom.util.render(template, context)); 注意这里我们定义的是嵌套的 Context，所以使用的时候也应该通过“{{ frag.start }}”这种方式来使用。
关于 DOM 模板的相关标签和过滤还有很多，这里我们不再一一介绍，有兴趣的读者可以参考 Dojo 的 DTL 使用案例。
基于 DTL 模板的 Widget
前面我们主要介绍了如何使用 DTL 的基本接口，接下来我们会介绍一下它的一个进阶用法：构建基于 DTL 模板的自定义 Widget。
我们知道，Dojo 的 Widget 通常都有一个 HTML 模板，用来构建该 Widget 的初始基本结构。但是有时我们的 Widget 比较大，比较复杂，这回导致我们的 Widget 的 HTML 模板也比较复杂，由于 Widget 的 HTML 模板是比较“静态”的，所以如果 Widget 的 HTML 模板一旦复杂，势必导致我们的模板 HTML 代码量的剧增。如果我们能把 DTL 引入到模板中，使我们的模板具有一定的逻辑控制能力，即“动态”的模板，这样便能大大简化我们的模板 HTML 代码复杂度，使代码更易于维护，同时也可降低网络请求 HTML 模板需要的带宽，提高网络性能。
清单 24. 基于 DTL 模板的 Widget
dojo.declare("Fruit", [dijit._WidgetBase, dojox.dtl._DomTemplated], {
widgetsInTemplate: true,
items: ["apple", "banana", "orange"],
keyUp: function(e){
if((e.type == "click" || e.keyCode == dojo.keys.ENTER) &&
this.input.value){
console.debug(this.button);
var i = dojo.indexOf(this.items, this.input.value);
if(i != -1){
this.items.splice(i, 1);
}else{
this.items.push(this.input.value);
}
this.input.value = "";
this.render();
}
},
templateString: dojo.cache("dojox.dtl.demos.templates", "Fruit.html"),
}); 大家注意这里的“items”参数：“items: ["apple", "banana", "orange"]”和“templateString”参数，这里的“items”变量的内容会被注入到 Widget 的模板“Fruit.html”中，从而构建最终的 Widget 的 HTML 模板。来看看“Fruit.html”的内容：
清单 25. 基于 DTL 的 HTML 模板
<div>
<input dojoAttachEvent="onkeyup: keyUp" dojoAttachPoint="input">
<button dojoType="dijit.form.Button" dojoAttachPoint="button"
dojoAttachEvent="onClick: keyUp">
Add/Remove Item
</button>
<div id="pane" dojoType="dijit.layout.ContentPane parsed">
<ul>
{% for item in items %}
<li>
<button dojoType="dijit.form.Button parsed" title="Fruit: {{ item }}"
otherAttr2="x_{{item}}">
{{ item }}
<script type="dojo/connect" event="onClick" args="e">
console.debug("
You clicked", this.containerNode.innerHTML);</' + 'script>
</button>
</li>
{% endfor %}
</ul>
</div>
</div> 结束语
这篇文章介绍了 Dojo 中 DTL 工具包的一些特性，首先从 DTL 语言本身入手，介绍了 DTL 语言的出处，基本规则和特点，然后引出 Dojo 的 DTL 工具包，并由浅入深的逐步介绍了 Dojo 的 DTL 工具包的各种对象和接口，如 Context 对象，Template 对象以及 Render 方法等等。从文本标签，文本过滤器和 DOM 模板三个方面分别阐述了这些接口的特点和使用方式。最后，介绍了如何基于 Dojo 的 DTL 工具包构建基于 DTL 模板的 Widget。这些接口对我们的日常开发都很有帮助，建议大家平时可以多关注一下。
本文首发于IBM Developer Works：http://www.ibm.com/developerworks/cn/web/1206_zhouxiang_dojodtl/
扫一扫
6302
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
