If you've ever created a django template before then you'll have used a template tag in one form or another. This tutorial will show you how you can create a simple template tag to help automate a common task.
The simplest of the Simple template tags are used for those cases where you find that you have a chunk of HTML code which is used in multiple places within your code, but because the location isn't static it can't be included in a base template. These tags would take no parameters at all and would output the same chunk of HTML every time. An example of this in the default tags would be {% debug %} which will output a load of debug information at the point the tag is placed.
The next level of complexity for template tags comes by allowing parameters into the simple tags. This could be used for things where you require a consistent format or where you want to run a piece of python code over a variable before displaying it. An example of one if these in the default tags would be {% url url_name %} which we saw last week in the tutorial on naming urls.
Since both of these types of tags are created on a similar way this tutorial will demonstrate how to create one that takes parameters. The example to be used this week will be for a tag that takes a list as a parameter and formats it into a series of bullet points.
The first thing to do is to create a directory named templatetags within your application directory. This is a special directory that django will look in whenever you try to import a set of tags (it will look for this directory in every installed application). In the newly-created directory create a blank file named __init__.py (which is required by python) and a file name list_formatters.py which should contain the following code:
from django import template
register = template.Library()
@register.simple_tag
def format_list(input_list):
return "<ul>\n <li>%s</li>\n<ul>" % "</li>\n <li>".join(input_list)
This code basically registers the function with the template library and says that it's a simple tag. The function then takes its only input and joins it together with some HTML to produce a bullet point style list.
Now we have generated the code for the tag, we can import it into a template and try it out. Create a new view using the following code and point a url at it:
from django.template import Template,Context
from django.http import HttpResponse
def tag_test(request):
test_list=['Item 1','Item 2','Third time lucky']
t = Template("""{% load list_formatters %}
<html>
<head><title>Tag Test</title></head>
<body>
{% format_list test_list %}
</body>
</html>""")
return HttpResponse(t.render(Context({'test_list':test_list})))
View this newly-created page and you should see that the list passed into the context has been formatted as a series of bullet points.
The next tutorial will look at block template tags i.e. ones that take a block of text/code in the middle of them like {% block %}{% endblock %} or {% if condition %}{% else %}{% endif %}
Cool stuff.. thanks a lot.. i think this is a much better explanation than on the django website.
ReplyDeleteI just want to second what saurabh said. Better explanation of template tags than I have found anywhere else.
ReplyDeletewould be nice to close ul tag
ReplyDeletereturn /ul the last at the last ul tag
cheers
Great explanation! Thanks for this great tutorial!
ReplyDeletethanks for this essential post.its very important for development.i like and enjoy this article
ReplyDeletevery essential and informative post . many visitor are benefited by this article .unique article.
ReplyDeletegreat detailed post . i need this article very much .its very effective for many visitors like me.
ReplyDelete