如何在Django模板中获得“switch-case”语句功能？

yvt65v4c  于 2023-10-21  发布在  Go
关注(0)|答案(5)|浏览(155)

我发现一个link在Django模板中有一个“switch”标签，但我想知道如果没有它，这是否可以实现。只使用Django自带的东西？基本上，还有其他方法可以使用多个“if”或“ifequal”语句吗？

django

5条答案

按热度按时间
fdbelqdn

fdbelqdn1#

从Django 1.4开始，有{% elif %}：

  1. {% if a %}
  2.   thing
  3. {% elif b %}
  4.   other thing
  5. {% elif c %}
  6.   another thing
  7. {% endif %}
赞(0）分享  回复(0）举报  2023-10-21
yyyllmsg

yyyllmsg2#

不幸的是，这在默认的Django模板引擎中是不可能的。您必须编写类似这样的丑陋代码来模拟开关。

  1. {% if a %}
  2.     {{ a }}
  3. {% else %}
  4.     {% if b %}
  5.         {{ b }}
  6.     {% else %}
  7.         {% if c %}
  8.             {{ c }}
  9.         {% else %}
  10.             {{ default }}
  11.         {% endif %}
  12.     {% endif %}
  13. {% endif %}

或者如果只有一个if条件为真，并且不需要默认值。

  1. {% if a %}
  2. {{ a }}
  3. {% endif %}
  4. {% if b %}
  5. {{ b }}
  6. {% endif %}
  7. {% if c %}
  8. {{ c }}
  9. {% endif %}

通常，当模板引擎不足以完成你想要的任务时，这是一个信号，表明代码应该被移到Django视图中，而不是模板中。举例来说：

  1. # Django view
  2. if a:
  3.   val = a
  4. elif b:
  5.   val = b
  6. elif c:
  7.   val = c
  8. else:
  9.   val = default
  11. # Template
  12. {{ val }}
展开查看全部
赞(0）分享  回复(0）举报  2023-10-21
up9lanfz

up9lanfz3#

对于以前的回应者：在不理解用例的情况下，你就做出了假设并批评了提问者。@Ber说“到处都是”，这当然不是提问者所暗示的。不公平
我有一个例子，我想在Django模板中的一个地方执行{% switch %}语句。将switch语句的等价物移到Python代码中不仅不方便，而且实际上会使视图和模板更难阅读，并将属于一个地方的简单条件逻辑分成两个地方。
在许多情况下，我可以想象{% switch %}（或{% if %}）是有用的，不使用一个需要在视图中放置HTML。这是一个更糟糕的罪过，这就是为什么{% if %}首先存在。{% switch %}没有什么不同。
幸运的是，Django是可扩展的，很多人已经实现了switch。退房时间：
Switch template tag

  1. from django import template
  2. from django.template import Library, Node, VariableDoesNotExist
  4. register = Library()
  6. @register.tag(name="switch")
  7. def do_switch(parser, token):
  8.     """
  9.     The ``{% switch %}`` tag compares a variable against one or more values in
  10.     ``{% case %}`` tags, and outputs the contents of the matching block.  An
  11.     optional ``{% else %}`` tag sets off the default output if no matches
  12.     could be found::
  14.         {% switch result_count %}
  15.             {% case 0 %}
  16.                 There are no search results.
  17.             {% case 1 %}
  18.                 There is one search result.
  19.             {% else %}
  20.                 Jackpot! Your search found {{ result_count }} results.
  21.         {% endswitch %}
  23.     Each ``{% case %}`` tag can take multiple values to compare the variable
  24.     against::
  26.         {% switch username %}
  27.             {% case "Jim" "Bob" "Joe" %}
  28.                 Me old mate {{ username }}! How ya doin?
  29.             {% else %}
  30.                 Hello {{ username }}
  31.         {% endswitch %}
  32.     """
  33.     bits = token.contents.split()
  34.     tag_name = bits[0]
  35.     if len(bits) != 2:
  36.         raise template.TemplateSyntaxError("'%s' tag requires one argument" % tag_name)
  37.     variable = parser.compile_filter(bits[1])
  39.     class BlockTagList(object):
  40.         # This is a bit of a hack, as it embeds knowledge of the behaviour
  41.         # of Parser.parse() relating to the "parse_until" argument.
  42.         def __init__(self, *names):
  43.             self.names = set(names)
  44.         def __contains__(self, token_contents):
  45.             name = token_contents.split()[0]
  46.             return name in self.names
  48.     # Skip over everything before the first {% case %} tag
  49.     parser.parse(BlockTagList('case', 'endswitch'))
  51.     cases = []
  52.     token = parser.next_token()
  53.     got_case = False
  54.     got_else = False
  55.     while token.contents != 'endswitch':
  56.         nodelist = parser.parse(BlockTagList('case', 'else', 'endswitch'))
  58.         if got_else:
  59.             raise template.TemplateSyntaxError("'else' must be last tag in '%s'." % tag_name)
  61.         contents = token.contents.split()
  62.         token_name, token_args = contents[0], contents[1:]
  64.         if token_name == 'case':
  65.             tests = map(parser.compile_filter, token_args)
  66.             case = (tests, nodelist)
  67.             got_case = True
  68.         else:
  69.             # The {% else %} tag
  70.             case = (None, nodelist)
  71.             got_else = True
  72.         cases.append(case)
  73.         token = parser.next_token()
  75.     if not got_case:
  76.         raise template.TemplateSyntaxError("'%s' must have at least one 'case'." % tag_name)
  78.     return SwitchNode(variable, cases)
  80. class SwitchNode(Node):
  81.     def __init__(self, variable, cases):
  82.         self.variable = variable
  83.         self.cases = cases
  85.     def __repr__(self):
  86.         return "<Switch node>"
  88.     def __iter__(self):
  89.         for tests, nodelist in self.cases:
  90.             for node in nodelist:
  91.                 yield node
  93.     def get_nodes_by_type(self, nodetype):
  94.         nodes = []
  95.         if isinstance(self, nodetype):
  96.             nodes.append(self)
  97.         for tests, nodelist in self.cases:
  98.             nodes.extend(nodelist.get_nodes_by_type(nodetype))
  99.         return nodes
  101.     def render(self, context):
  102.         try:
  103.             value_missing = False
  104.             value = self.variable.resolve(context, True)
  105.         except VariableDoesNotExist:
  106.             no_value = True
  107.             value_missing = None
  109.         for tests, nodelist in self.cases:
  110.             if tests is None:
  111.                 return nodelist.render(context)
  112.             elif not value_missing:
  113.                 for test in tests:
  114.                     test_value = test.resolve(context, True)
  115.                     if value == test_value:
  116.                         return nodelist.render(context)
  117.         else:
  118.             return ""
展开查看全部
赞(0）分享  回复(0）举报  2023-10-21
htzpubme

htzpubme4#

在一个非常普遍的观点中，对switch语句的需要是一个信号，表明需要创建新的类和对象来捕获不同的“情况”。
然后，你只需要调用一个对象方法或引用一个对象属性，而不是到处“切换“。

赞(0）分享  回复(0）举报  2023-10-21
n1bvdmb6

n1bvdmb65#

这是Roy写的代码的固定版本：

  1. @register.tag(name="case")
  2. def case_tag(parser, token):
  3.     pass
  5. @register.tag(name="switch")
  6. def switch_tag(parser, token):
  7.     """
  8.     The ``{% switch %}`` tag compares a variable against one or more values in
  9.     ``{% case %}`` tags, and outputs the contents of the matching block.  An
  10.     optional ``{% else %}`` tag sets off the default output if no matches
  11.     could be found::
  13.         {% switch result_count %}
  14.             {% case 0 %}
  15.                 There are no search results.
  16.             {% case 1 %}
  17.                 There is one search result.
  18.             {% else %}
  19.                 Jackpot! Your search found {{ result_count }} results.
  20.         {% endswitch %}
  22.     Each ``{% case %}`` tag can take multiple values to compare the variable
  23.     against::
  25.         {% switch username %}
  26.             {% case "Jim" "Bob" "Joe" %}
  27.                 Me old mate {{ username }}! How ya doin?
  28.             {% else %}
  29.                 Hello {{ username }}
  30.         {% endswitch %}
  31.     """
  32.     bits = token.contents.split()
  33.     tag_name = bits[0]
  34.     if len(bits) != 2:
  35.         raise template.TemplateSyntaxError("'%s' tag requires one argument" % tag_name)
  36.     variable = parser.compile_filter(bits[1])
  38.     class BlockTagList(object):
  39.         # This is a bit of a hack, as it embeds knowledge of the behaviour
  40.         # of Parser.parse() relating to the "parse_until" argument.
  41.         def __init__(self, *names):
  42.             self.names = set(names)
  43.         def __contains__(self, token_contents):
  44.             name = token_contents.split()[0]
  45.             return name in self.names
  47.     # Skip over everything before the first {% case %} tag
  48.     # TODO: error if there is anything here!
  49.     parser.parse(BlockTagList('case', 'endswitch'))
  51.     cases = []
  52.     token = parser.next_token()
  53.     got_case = False
  54.     got_else = False
  55.     while token.contents != 'endswitch':
  56.         nodelist = parser.parse(BlockTagList('case', 'else', 'endswitch'))
  58.         if got_else:
  59.             raise template.TemplateSyntaxError("'else' must be last tag in '%s'." % tag_name)
  61.         contents = token.split_contents()
  62.         token_name, token_args = contents[0], contents[1:]
  64.         if token_name == 'case':
  65.             tests = map(parser.compile_filter, token_args)
  66.             case = (tests, nodelist)
  67.             got_case = True
  68.         else:
  69.             # The {% else %} tag
  70.             assert token_name == 'else'
  71.             case = (None, nodelist)
  72.             got_else = True
  73.         cases.append(case)
  74.         token = parser.next_token()
  76.     if not got_case:
  77.         raise template.TemplateSyntaxError("'%s' must have at least one 'case'." % tag_name)
  79.     return SwitchNode(variable, cases)
  81. class SwitchNode(Node):
  82.     def __init__(self, variable, cases):
  83.         self.variable = variable
  84.         self.cases = cases
  86.     def __repr__(self):
  87.         return "<Switch node>"
  89.     def __iter__(self):
  90.         for tests, nodelist in self.cases:
  91.             for node in nodelist:
  92.                 yield node
  94.     def get_nodes_by_type(self, nodetype):
  95.         nodes = []
  96.         if isinstance(self, nodetype):
  97.             nodes.append(self)
  98.         for tests, nodelist in self.cases:
  99.             nodes.extend(nodelist.get_nodes_by_type(nodetype))
  100.         return nodes
  102.     def render(self, context):
  103.         value_missing = False
  104.         value = self.variable.resolve(context, True)
  106.         for tests, nodelist in self.cases:
  107.             if tests is None:
  108.                 return nodelist.render(context)
  109.             elif not value_missing:
  110.                 for test in tests:
  111.                     test_value = test.resolve(context, True)
  112.                     if value == test_value:
  113.                         return nodelist.render(context)
  115.         assert False, f'No case hit for value {value}'

测试验证：

  1. import pytest
  2. from django.template import (
  3.     Context,
  4.     Template,
  5. )
  7. def test_switch():
  8.     assert Template('''
  9.     {% load base %}
  10.     {% switch foo %}
  11.         {% case 1 %}
  12.             foo        
  13.     {% endswitch %}
  14.     ''').render(Context(dict(foo=1))).strip() == 'foo'
  16.     assert Template('''
  17.     {% load base %}
  18.     {% switch foo %}
  19.         {% case 1 %}
  20.             foo    
  21.         {% else %}
  22.             bar    
  23.     {% endswitch %}
  24.     ''').render(Context(dict(foo=2))).strip() == 'bar'
  26.     assert Template('''
  27.     {% load base %}
  28.     {% switch foo %}
  29.         {% case 1 %}
  30.             foo    
  31.         {% case 2 %}
  32.             bar 
  33.     {% endswitch %}
  34.     ''').render(Context(dict(foo=2))).strip() == 'bar'
  36.     assert Template('''
  37.     {% load base %}
  38.     {% switch foo %}
  39.         {% case "hello world" %}
  40.             foo    
  41.         {% case "good bye world" %}
  42.             bar 
  43.     {% endswitch %}
  44.     ''').render(Context(dict(foo="hello world"))).strip() == 'foo'
  46.     with pytest.raises(AssertionError):
  47.         Template('''
  48.         {% load base %}
  49.         {% switch foo %}
  50.             {% case 1 %}
  51.                 foo
  52.         {% endswitch %}
  53.         ''').render(Context(dict(foo=0)))
  55.     with pytest.raises(AssertionError):
  56.         Template('''
  57.         {% load base %}
  58.         {% switch foo %}
  59.             {% case "hello world" %}
  60.                 foo    
  61.             {% case "good bye world" %}
  62.                 bar 
  63.         {% endswitch %}
  64.         ''').render(Context(dict(foo="something else"))).strip()
展开查看全部
赞(0）分享  回复(0）举报  2023-10-21
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com