\n\n定制自定义模板 tags 和 filters 的位置就是 Django 应用内。如果它们关联至某个已存在的应用，在那里将它们打包就很有用；否则，它们能被添加至新应用。当一个 Django 应用被添加至 INSTALLED_APPS
\n该应用应包含一个 templatetags models.py views.py __init__.py
\n\n自定义的 tags 和 filters 会保存在模块名为 templatetags
\n例如，如果你的 tags/filters 保存在一个名为 poll_extras.py
\nCode Copy
polls / \n __init__ . py \n models . py \n templatetags / \n __init__ . py \n poll_extras . py \n views . py \n在模板中你会使用以下代码：
\nDjango template Copy
{% load poll_extras %} \n为了使 {% load %} INSTALLED_APPS
\n我们并未限制放入 templatetags {% load %}
\n要成为一个可用的 tag 库，模块必须包含一个名为 register template.Library
\nCode Copy
from django import template \n\nregister = template . Library () \n或者，模板标签模块能通过 DjangoTemplates 'libraries'
\n\n \n\n自定义的过滤器就是一些有一到两个参数的 Python 函数：
\n\n（输入的）变量的值，不一定得是字符串类型
而参数的值，它们可以有一个默认值，或者被排除在外
\n举个例子，在过滤器 {{ var|foo:"bar" }} var bar foo
\n因为模板语言不提供异常处理机制，所以任何从模板过滤器中抛出的异常都将被视为服务器异常。因此，如果有一个合理的返回值将要被返回的话，过滤器函数应当避免产生异常。万一模板中出现有明显错误的输入，产生异常也仍然比隐藏这个 bug 要好。
\n这是一个过滤器定义的例子:
\nCode Copy
def cut ( value , arg ): \n """Removes all values of arg from the given string""" \n return value . replace ( arg , '' ) \n这个例子展示了如何使用这个过滤器：
\nDjango template Copy
{{ somevariable | cut :"0" }} \n大部分的过滤器并没有参数。这样的话，只需要把这些参数从你的函数中去掉就好。
\nCode Copy
def lower ( value ): # Only one argument. \n """Converts a string into all lowercase""" \n return value . lower () \n\n\n\n\ndjango.template.Library. filter ( ) Link to this definition # \n \n\n每当你写好你的过滤器定义的时候，你需要用你的 Library
\nCode Copy
register . filter ( 'cut' , cut ) \nregister . filter ( 'lower' , lower ) \nLibrary.filter()
\n\n过滤器的名称——字符串。
编辑函数——一个 Python 函数（不是函数名的字符串）。
\n你也能以装饰器的模式使用 register.filter()
\nCode Copy
@register . filter ( name = 'cut' ) \ndef cut ( value , arg ): \n return value . replace ( arg , '' ) \n\n@register . filter \ndef lower ( value ): \n return value . lower () \n若你不填 name
\n最后， register.filter() is_sage needs_autoescape expects_localtime 过滤器和自动转义 过滤器和时区
\n \n\n\n\n\ndjango.template.defaultfilters. stringfilter ( ) Link to this definition # \n \n\n如果编写只接收一个字符串作为第一个参数的模板过滤器，你需要使用 stringfilter
\nCode Copy
from django import template \nfrom django.template.defaultfilters import stringfilter \n\nregister = template . Library () \n\n@register . filter \n@stringfilter \ndef lower ( value ): \n return value . lower () \n这样，您就可以将一个整数传递给这个过滤器，而不会导致 AttributeError lower()
\n \n\n编写自定义过滤器时，考虑一下过滤器将如何与 Django 的自动转义行为交互。
\n\n原始字符串 指原生 Python 字符串。在输出时，如果自动转义生效，则对它们进行转义，否则将保持不变。
安全字符串 是在输出时被标记为安全的字符串，不会进一步转义。必要的转义已在之前完成。它们通常用于原样输出 HTML，HTML 会在客户端被解释。
\n实质上，这些字符串是 SafeString
\nCode Copy
from django.utils.safestring import SafeString \n\nif isinstance ( value , SafeString ): \n # Do something with the "safe" string. \n ... \n \n模板过滤器代码有两种情况：
\n\n你的过滤器不会将任何 HTML 不安全的字符(< > ' " & is_safe True
\nCode Copy
@register . filter ( is_safe = True ) \ndef myfilter ( value ): \n return value \n该标志告诉 Django，若一个“安全”字符串传给您的过滤器，结果仍会是安全的。若传入了不安全的字符串，Django 会在需要时自动转义。
\n你可以这么认为，“过滤器是安全的——它不会产生任何不安全的 HTML。”
\n一定要 is_safe SafeData str
\n举例来说，假定有个过滤器，会在任何输入后追加 xx is_safe
\nCode Copy
@register . filter ( is_safe = True ) \ndef add_xx ( value ): \n return ' %s xx' % value \n当该过滤器对某个启用了自动转义的模板生效时，Django 会对输出自动转义，不管输入是否被标记为“安全的”。
\n默认情况下， is_sate False
\n在确定过滤器是否确实将安全字符串保留为安全字符串时要千万小心。如果你正在 删除 字符，你可能不经意的在结果中留下不成对的 HTML 标记或实体。例如，从输入中删除一个 > <a> <a ; & &
\n标记过滤器的 is_safe is_safe
\n或者，你的过滤器代码要手动关注必须的转义操作。这在输出新 HTML 标记时是必须的。想要避免你的 HTML 标记不被后续操作转义，你要将输出标记为安全的，且需要自己处理输入。
\n要将输出标记为安全字符串，使用 django.utils.safestring.mark_safe()
\n不过还是要小心，你要做的不只是将输出标记为安全的。你需要确保它 真的是 安全的，你所做的取决于自动转义是否生效。理想状态下，编写的过滤器在自动转义开启与关闭的情况下均能正确的操作模板，这样模板作者用起来就更简单了。
\n为了让你的过滤器知道自动转移开关的状态，在你注册过滤器函数时将 needs_autoescape False True autoescape True False autoescape True
\n例子，让我们编写一个强制大写字符串的首字母的过滤器:
\nCode Copy
from django import template \nfrom django.utils.html import conditional_escape \nfrom django.utils.safestring import mark_safe \n\nregister = template . Library () \n\n@register . filter ( needs_autoescape = True ) \ndef initial_letter_filter ( text , autoescape = True ): \n first , other = text [ 0 ], text [ 1 :] \n if autoescape : \n esc = conditional_escape \n else : \n esc = lambda x : x \n result = '<strong> %s </strong> %s ' % ( esc ( first ), esc ( other )) \n return mark_safe ( result ) \nneeds_autoescape autoescape autoescape django.utils.html.conditional_escape conditional_escape() 不是 一个 SafeData escape() SafeData conditional_escape()
\n最后，在上述例子中，我们牢记将结果标为安全的，所以 HMTL 未经转义就直接插入模板中。
\n这种场景下无需担心 is_safe is_safe
\n \n\nWarning
\n在重用内置过滤器时避免 XSS 漏洞
\nDjango 内置的过滤器默认配置 autoescape=True
\n在旧版本的 Django 中，复用 Django 内置过滤器时要小心，因为 自动转义 None autoescape=True
\n举个例子，如果你想编写一个联合 urlize linebreaksbr urlize_and_linebreaks
\nCode Copy
from django.template.defaultfilters import linebreaksbr , urlize \n\n@register . filter ( needs_autoescape = True ) \ndef urlize_and_linebreaks ( text , autoescape = True ): \n return linebreaksbr ( \n urlize ( text , autoescape = autoescape ), \n autoescape = autoescape \n ) \n接下来：
\nDjango template Copy
{{ comment | urlize_and_linebreaks }} \n等价于：
\nDjango template Copy
{{ comment | urlize | linebreaksbr }} \n \n \n\n如果你编写了一个自定义过滤器，处理 datetime expects_localtime True
\nCode Copy
@register . filter ( expects_localtime = True ) \ndef businesshours ( value ): \n try : \n return 9 <= value . hour < 17 \n except AttributeError : \n return '' \n设置该标志后，如果过滤器接收的第一个参数是一个时区敏感的 datetime，Django 在将其传递给过滤器前的某个合适时间将其转换为当前时区的时间，依据 模板中的时区转换规则
\n \n \n\n标签比过滤器更复杂，因为标签啥都能做。Django 提供了很多快捷方式，简化了编写绝大多数类型的标签过程。我们先探索这些快捷方式，然后解释如何在快捷方式不够强大的情况下从零编写标签。
\n\n\n\n\ndjango.template.Library. inclusion_tag ( ) Link to this definition # \n \n\n另一种常见的模板标签会为 另一个 模板渲染数据。例如， Django 的后台利用自定义模板标签在表单页的底部展示按钮。这些按钮看起来一样，但是连接目标根据被编辑的对象不同而不同——所以，这是一个极好的例子，展示如何用当前对象的细节填充小模板。（在后台例子中，即 submit_row
\n这种标签被称为“包含标签”。
\n编写包含标签可能最好通过实例来展示。让我们编写一个标签，它会将指定 Poll 教程
\nDjango template Copy
{% show_results poll %} \n输出看起来像这样：
\nHtml Copy
< ul > \n < li > First choice</ li > \n < li > Second choice</ li > \n < li > Third choice</ li > \n</ ul > \n首先，定义一个函数，接受参数，并返回一个字典。此处的要点是我们只需返回一个字典，不是任何其它复杂的东西。这将作为一个模板上下文被模板碎片使用。例子:
\nCode Copy
def show_results ( poll ): \n choices = poll . choice_set . all () \n return { 'choices' : choices } \n随后，创建用于渲染标签输出的模板。该模板是标签的一个固有特性：标签作者指定它，而不是模板设计者。跟随我们的例子，模板非常简短：
\nDjango template Copy
< ul > \n{% for choice in choices %} \n < li > {{ choice }} </ li > \n{% endfor %} \n</ ul > \n现在，在 Library inclusion_tag() results.html
\nCode Copy
# Here, register is a django.template.Library instance, as before \n@register . inclusion_tag ( 'results.html' ) \ndef show_results ( poll ): \n ... \n或者，也能用 django.template.Template
\nCode Copy
from django.template.loader import get_template \nt = get_template ( 'results.html' ) \nregister . inclusion_tag ( t )( show_results ) \n在第一次创建该函数时。
\n有时候，你的包含标签可能要求超多参数，模板作者不得不传入所有参数，并牢记它们的顺序，非常痛苦。为了解决此问题， Django 为包含标签提供了一个 take_context takes_context
\n举个例子，假设你编写了一个包含标签，总会在一个包含指向首页的 home_link home_title
\nCode Copy
@register . inclusion_tag ( 'link.html' , takes_context = True ) \ndef jump_link ( context ): \n return { \n 'link' : context [ 'home_link' ], \n 'title' : context [ 'home_title' ], \n } \n注意，该函数的第一个参数 必须 是 context
\n在 register.inclusion_tag() takes_context=True link.html
\nDjango template Copy
Jump directly to < a href = " {{ link }} " > {{ title }} </ a > .\n后面，当你想用该自定义标签时，加载它的库，并不带任何参数的调用它，像这样：
\nDjango template Copy
{% jump_link %} \n注意，只要使用了 takes_context=True
\ntakes_context False True 包含标签
\n包含标签
\nCode Copy
@register . inclusion_tag ( 'my_template.html' ) \ndef my_tag ( a , b , * args , ** kwargs ): \n warning = kwargs [ 'warning' ] \n profile = kwargs [ 'profile' ] \n ... \n return ... \n随后在模板中，任意数量的，以空格分隔的参数会被传递给模板标签。与 Python 中类似，关键字参数的赋值使用等号（"=
\nDjango template Copy
{% my_tag 123 "abcd" book.title warning = message | lower profile = user.profile %} \n \n\n\n\n模板系统工作只需两步：编译和渲染。为了定义自定义模板标签，你需指定如何编译和渲染。
\nDjango 编译模板时，会将原始模板文本划为“节点”。每个节点都是一个 django.template.Node render() 节点 render() 节点 render()
\n因此，要定义一个自定义模板标签，你要指定如何将原始模板标签转换为 节点 render()
\n \n\n\n模板解析器遇到的每个模板标签，解析器都会调用一个 Python 函数，参数是标签内容和解析器对象本身。该函数需要基于标签的内容返回一个 节点
\n举个例子，让我们完整地实现模板标签 {% current_time %} strftime()
\nDjango template Copy
< p > The time is {% current_time "%Y-%m-%d %I:%M %p" %} .</ p > \n这个函数的解析器应用获取参数，并创建一个 节点
\nCode Copy
from django import template \n\ndef do_current_time ( parser , token ): \n try : \n # split_contents() knows not to split quoted strings. \n tag_name , format_string = token . split_contents () \n except ValueError : \n raise template . TemplateSyntaxError ( \n " %r tag requires a single argument" % token . contents . split ()[ 0 ] \n ) \n if not ( format_string [ 0 ] == format_string [ - 1 ] and format_string [ 0 ] in ( '"' , "'" )): \n raise template . TemplateSyntaxError ( \n " %r tag's argument should be in quotes" % tag_name \n ) \n return CurrentTimeNode ( format_string [ 1 : - 1 ]) \n注意：
\n\nparser
token.contents 'current_time "%Y-%m-%d %I:%M %p"'
token.split_contents() token.contents.split() token.split_contents()
该方法要在语法错误发生时抛出包含有用信息的 django.template.TemplateSyntaxError
TemplateSyntaxError tag_name token.contents.split()[0]
该函数返回一个 CurrentTimeNode "%Y-%m-%d %I:%M %p" format_string[1:-1]
这种解析是很低级的。Django 开发者已试着在该解析系统之上编写小型解析框架，使用类似 EBNF 语法，但这些尝试使得模板引擎运行的很慢。低级意味着快。
\n \n\n\n编写自定义标签的第二步是定义一个 Node render()
\n承接上述例子，我们需要定义 CurrentTimeNode
\nCode Copy
import datetime \nfrom django import template \n\nclass CurrentTimeNode ( template . Node ): \n def __init__ ( self , format_string ): \n self . format_string = format_string \n\n def render ( self , context ): \n return datetime . datetime . now () . strftime ( self . format_string ) \n注意：
\n\n__init__() do_current_time() format_string 节点 __init__()
render()
render() context.template.engine.debug True django.template.TemplateSyntaxError
\n最终，这种对编译和渲染的解耦会产生一个高效的模板系统，因为一个模板无需多次解析就能渲染多个上下文。
\n \n\n模板标签的输出 不会 自动通过自动转义过滤器（除了上述的 simple_tag()
\n若模板标签的 render() mark_safe()
\n同理，如果你的模板标签为某些子渲染进程创建了新的上下文，那么就需要将当前上下文对应的自动转义属性传入。 Context __init__ autoescape
\nCode Copy
from django.template import Context \n\ndef render ( self , context ): \n # ... \n new_context = Context ({ 'var' : obj }, autoescape = context . autoescape ) \n # ... Do something with new_context ... \n该场景不常见，但在自助渲染模板时很有用。例如:
\nCode Copy
def render ( self , context ): \n t = context . template . engine . get_template ( 'small_fragment.html' ) \n return t . render ( Context ({ 'var' : obj }, autoescape = context . autoescape )) \n在本例中，如果我们忽略了将当前的 context.autoescape Context 总会 被自动转义，这可能与期望不同，尤其是模板标签被用于 {% autoescape off %}
\n \n\n节点被解析后，其 render
\n为了确保你的模板标签是线程安全的，你应该永远不要在节点中存储状态信息。例如，Django 提供了一个内置的 cycle
\nDjango template Copy
{% for o in some_list %} \n < tr class = " {% cycle 'row1' 'row2' %} " > \n ...\n </ tr > \n{% endfor %} \nCycleNode
\nCode Copy
import itertools \nfrom django import template \n\nclass CycleNode ( template . Node ): \n def __init__ ( self , cyclevars ): \n self . cycle_iter = itertools . cycle ( cyclevars ) \n\n def render ( self , context ): \n return next ( self . cycle_iter ) \n但是，假设有两个模板渲染器同时渲染上述模板片段：
\n\n线程 1 执行其第一次迭代， CycleNode.render()
线程 2 执行其第一次迭代， CycleNode.render()
线程 1 执行其第二次迭代， CycleNode.render()
线程 2 执行其第二次迭代， CycleNode.render()
\nCycleNode 正在被迭代，却是全局范围的。就像线程 1 和线程 2 担心的那样，它们总是返回同样的值。这不是我们想要的。
\n为了定位此问题，Django 提供了一个 render_context context render_context render Node
\n让我们用 render_context CycleNode
\nCode Copy
class CycleNode ( template . Node ): \n def __init__ ( self , cyclevars ): \n self . cyclevars = cyclevars \n\n def render ( self , context ): \n if self not in context . render_context : \n context . render_context [ self ] = itertools . cycle ( self . cyclevars ) \n cycle_iter = context . render_context [ self ] \n return next ( cycle_iter ) \n注意，将 Node CycleNode cyclevars Node render_context CycleNode render_context
\n\nNote
\n注意我们是如何利用 self CycleNode render_context CycleNodes self render_context render_context[self]
\n \n \n\n\n最后，用你的模块的 Library 编写自定义模板标签 1 介绍的那样。举个例子：
\nCode Copy
register . tag ( 'current_time' , do_current_time ) \ntag
\n\n模板标签的名字——一个字符串。若为空，将会使用编译函数的名字。
编辑函数——一个 Python 函数（不是函数名的字符串）。
\n就像过滤器注册一样，这里也能用装饰器:
\nCode Copy
@register . tag ( name = "current_time" ) \ndef do_current_time ( parser , token ): \n ... \n\n@register . tag \ndef shout ( parser , token ): \n ... \n若未输入 name
\n \n\n\n虽然你能利用 token.split_contents()
\n前文的例子已经成功将当前时间转为字符串并将之返回，假设你想传入一个 DateTimeField
\nDjango template Copy
< p > This post was last updated at {% format_time blog_entry.date_updated "%Y-%m-%d %I:%M %p" %} .</ p > \n首先，token.split_contents()
\n\n标签名 format_time
字符串 'blog_entry.date_updated'
格式化字符串 '"%Y-%m-%d %I:%M %p"' split_contents()
\n现在，你的标签应该看起来像这样:
\nCode Copy
from django import template \n\ndef do_format_time ( parser , token ): \n try : \n # split_contents() knows not to split quoted strings. \n tag_name , date_to_be_formatted , format_string = token . split_contents () \n except ValueError : \n raise template . TemplateSyntaxError ( \n " %r tag requires exactly two arguments" % token . contents . split ()[ 0 ] \n ) \n if not ( format_string [ 0 ] == format_string [ - 1 ] and format_string [ 0 ] in ( '"' , "'" )): \n raise template . TemplateSyntaxError ( \n " %r tag's argument should be in quotes" % tag_name \n ) \n return FormatTimeNode ( date_to_be_formatted , format_string [ 1 : - 1 ]) \n你也需要修改 renderer，让其获取 blog_entry date_updated django.template Variable()
\n要使用 Variable variable.resolve(context)
\nCode Copy
class FormatTimeNode ( template . Node ): \n def __init__ ( self , date_to_be_formatted , format_string ): \n self . date_to_be_formatted = template . Variable ( date_to_be_formatted ) \n self . format_string = format_string \n\n def render ( self , context ): \n try : \n actual_date = self . date_to_be_formatted . resolve ( context ) \n return actual_date . strftime ( self . format_string ) \n except template . VariableDoesNotExist : \n return '' \n变量解决方案会在无法在当前页的上下文中找到指定字符串时抛出 VariableDoesNotExist
\n \n\n\n上述例子输出了一个值。一般来说，如果你的模板标签设置模板变量，会比直接输出更加灵活。这样，模板作者在你的模板标签创建时能复用这些值。
\n要在上下文中设置变量，需要在 render() CurrentTimeNode current_time
\nCode Copy
import datetime \nfrom django import template \n\nclass CurrentTimeNode2 ( template . Node ): \n def __init__ ( self , format_string ): \n self . format_string = format_string \n def render ( self , context ): \n context [ 'current_time' ] = datetime . datetime . now () . strftime ( self . format_string ) \n return '' \n注意， render() render() render()
\n下面是如何使用新版标签的实例：
\nDjango template Copy
{% current_time "%Y-%m-%d %I:%M %p" %} < p > The time is {{ current_time }} .</ p > \n\n上下文中的变量作用域
\n上下文内变量仅在模板中相同 block
\n \n但是， CurrentTimeNode2 current_time {{ current_time }} {% current_time %}
\nDjango template Copy
{% current_time "%Y-%m-%d %I:%M %p" as my_current_time %} \n< p > The current time is {{ my_current_time }} .</ p > \n为此，你需要重构编译函数和 Node
\nCode Copy
import re \n\nclass CurrentTimeNode3 ( template . Node ): \n def __init__ ( self , format_string , var_name ): \n self . format_string = format_string \n self . var_name = var_name \n def render ( self , context ): \n context [ self . var_name ] = datetime . datetime . now () . strftime ( self . format_string ) \n return '' \n\ndef do_current_time ( parser , token ): \n # This version uses a regular expression to parse tag contents. \n try : \n # Splitting by None == splitting by spaces. \n tag_name , arg = token . contents . split ( None , 1 ) \n except ValueError : \n raise template . TemplateSyntaxError ( \n " %r tag requires arguments" % token . contents . split ()[ 0 ] \n ) \n m = re . search ( r '(.*?) as (\\w+)' , arg ) \n if not m : \n raise template . TemplateSyntaxError ( " %r tag had invalid arguments" % tag_name ) \n format_string , var_name = m . groups () \n if not ( format_string [ 0 ] == format_string [ - 1 ] and format_string [ 0 ] in ( '"' , "'" )): \n raise template . TemplateSyntaxError ( \n " %r tag's argument should be in quotes" % tag_name \n ) \n return CurrentTimeNode3 ( format_string [ 1 : - 1 ], var_name ) \n此处的不同点是 do_current_time() CurrentTimeNode3
\n最后，如果你的自定义上下文更新模板标签只需要简单的语法，考虑使用 simple_tag()
\n \n\n\n模板标签能串联工作。例如，标准标签 ttag:{% comment %} <comment> 隐藏任何东西，直到碰到 {% endcomment %} parser.parse()
\n以下是如何实现一个简单的 {% comment %}
\nCode Copy
def do_comment ( parser , token ): \n nodelist = parser . parse (( 'endcomment' ,)) \n parser . delete_first_token () \n return CommentNode () \n\nclass CommentNode ( template . Node ): \n def render ( self , context ): \n return '' \n\nNote
\n{% comment %} {% comment %} {% endcomment %} parser.skip_past('endcomment') parser.parse(('endcomment',)) parser.delete_first_token()
\n \nparser.parse() django.template.NodeList Node
\n上文例子 "nodelist = parser.parse(('endcomment',))" nodelist {% comment %} {% endcomment %} {% comment %} {% endcomment %}
\n在调用 parser.parse() {% endcomment %} parser.delete_first_token()
\nCommentNode.render() {% comment %} {% endcomment %}
\n \n\n\n在前文的例子中， do_comment {% comment %} {% endcomment %}
\n举个例子，这里有个模板标签， {% upper %} {% endupper %}
\n用法：
\nDjango template Copy
{% upper %} This will appear in uppercase, {{ your_name }} .{% endupper %} \n与之前的例子一样，我们将使用 parser.parse() nodelist Node
\nCode Copy
def do_upper ( parser , token ): \n nodelist = parser . parse (( 'endupper' ,)) \n parser . delete_first_token () \n return UpperNode ( nodelist ) \n\nclass UpperNode ( template . Node ): \n def __init__ ( self , nodelist ): \n self . nodelist = nodelist \n def render ( self , context ): \n output = self . nodelist . render ( context ) \n return output . upper () \n唯一的新概念是 UpperNode.render() self.nodelist.render(context)
\n更多关于复杂渲染的例子，查看 django/template/defaulttags.py {% for %} django/template/smartif.py {% if %}
\n \n ","rootId":"how-to-create-custom-template-tags-and-filters","toc":[{"title":"代码布局","anchor":"code-layout","children":[]},{"title":"编写自定义的模板过滤器","anchor":"writing-custom-template-filters","children":[{"title":"注册自定义过滤器","anchor":"registering-custom-filters","children":[]},{"title":"模板过滤器期望字符串","anchor":"template-filters-that-expect-strings","children":[]},{"title":"过滤器和自动转义","anchor":"filters-and-auto-escaping","children":[]},{"title":"过滤器和时区","anchor":"filters-and-time-zones","children":[]}]},{"title":"编写自定义模板标签","anchor":"writing-custom-template-tags","children":[{"title":"简单标签","anchor":"simple-tags","children":[]},{"title":"包含标签","anchor":"inclusion-tags","children":[]},{"title":"进阶自定义模板标签","anchor":"advanced-custom-template-tags","children":[]},{"title":"简介","anchor":"a-quick-overview","children":[]},{"title":"编写编译函数","anchor":"writing-the-compilation-function","children":[]},{"title":"编写渲染器","anchor":"writing-the-renderer","children":[]},{"title":"自动转义的注意事项","anchor":"auto-escaping-considerations","children":[]},{"title":"线程安全的注意事项","anchor":"thread-safety-considerations","children":[]},{"title":"注册该标签","anchor":"registering-the-tag","children":[]},{"title":"传递模板变量给标签","anchor":"passing-template-variables-to-the-tag","children":[]},{"title":"在上下文中设置变量","anchor":"setting-a-variable-in-the-context","children":[]},{"title":"解析直到碰到另一区块的标签","anchor":"parsing-until-another-block-tag","children":[]},{"title":"解析直到碰到另一区块标签，并保存内容。","anchor":"parsing-until-another-block-tag-and-saving-contents","children":[]}]}],"breadcrumbs":[{"docname":"howto/index","title":"操作指南","url":"/zh-hans/4.0/howto/"}],"prev":{"docname":"howto/custom-template-backend","title":"如何编写一个自定义的模板后端","url":"/zh-hans/4.0/howto/custom-template-backend/"},"next":{"docname":"howto/custom-file-storage","title":"如何编写一个自定义的文件存储类","url":"/zh-hans/4.0/howto/custom-file-storage/"},"formats":{"html":"/zh-hans/4.0/howto/custom-template-tags/","markdown":"/zh-hans/4.0/howto/custom-template-tags.md","json":"/zh-hans/4.0/howto/custom-template-tags.json"},"source":"https://github.com/django/django/blob/stable/4.0.x/docs/howto/custom-template-tags.txt","official":"https://docs.djangoproject.com/zh-hans/4.0/howto/custom-template-tags/","inVersions":["6.1","6.0","5.2","5.1","5.0","4.2","4.1","4.0","3.2","3.1","3.0","2.2","2.1","2.0"],"inLocales":["en","zh-hans","fr","ja","id","it","pt-br","ko","es","el","pl"]}