【问题标题】:Navigation in django在 django 中导航
【发布时间】:2010-09-25 08:22:17
【问题描述】:

我刚刚在 django 中完成了我的第一个小 webapp,我喜欢它。我即将开始将一个旧的生产 PHP 站点转换为 django,作为其模板的一部分,有一个导航栏。

在 PHP 中,我在模板代码中根据当前 URL 检查每个导航选项的 URL,如果它们对齐,则应用 CSS 类。乱七八糟的。

对于 django 是否有更好的方法或处理模板中代码的好方法?

首先,我将如何获取当前 URL?

【问题讨论】:

  • 我为此创建了github.com/orokusaki/django-active-menu - 它支持嵌套的 URL 结构,并且依赖于配置而不是约定(听起来很邪恶),因此您可以根据需要定义站点的层次结构。您只需使用<a href="{% url "view:name" %}" {% active_class "view:name" %}>。您可以选择使用它来生成 just " active" 值(通过将 False 作为第二个参数传递给标签)以附加到现有的类属性,但对于大多数导航链接,该示例是我用什么。
  • 这个问题好像和这个有关stackoverflow.com/a/9801473/5739875
  • 也许这个网格有帮助:djangopackages.org/grids/g/navigation

标签: django navigation


【解决方案1】:

您不需要 if 来执行此操作,请查看以下代码:

tags.py

@register.simple_tag
def active(request, pattern):
    import re
    if re.search(pattern, request.path):
        return 'active'
    return ''

urls.py

urlpatterns += patterns('',
    (r'/$', view_home_method, 'home_url_name'),
    (r'/services/$', view_services_method, 'services_url_name'),
    (r'/contact/$', view_contact_method, 'contact_url_name'),
)

base.html

{% load tags %}

{% url 'home_url_name' as home %}
{% url 'services_url_name' as services %}
{% url 'contact_url_name' as contact %}

<div id="navigation">
    <a class="{% active request home %}" href="{{ home }}">Home</a>
    <a class="{% active request services %}" href="{{ services }}">Services</a>
    <a class="{% active request contact %}" href="{{ contact }}">Contact</a>
</div>

就是这样。 实现细节请看:
gnuvince.wordpress.com
110j.wordpress.com

【讨论】:

  • href 的属性缺少 django 模板括号 {{, }}。例如,Home 应该是 Home tags.py 文件也需要一些包含。否则,很好的解决方案!
  • +1 这与应用程序的耦合更松散。作为一个初学者,我发现标签需要它自己的应用程序,你不能只是将它转储到全局 tags.py 文件中。我创建了一个名为标签的新应用程序,一切都很顺利。 docs.djangoproject.com/en/dev/howto/custom-template-tags
  • @Keyo,在你的项目中创建一个 templatetags 目录,并将你的项目添加到 installedapps。这也可以解决问题。或者,就像您说的那样,将您的主站点创建为项目中的应用程序。
  • 别忘了在settings.py@ 中添加django.core.context_processors.request 到你的TEMPLATE_CONTEXT_PROCESSORS
  • 这对于可能嵌套的状态无效,例如mysite.com(作为 home)和 mysite.com/blog,因为路径将显示为 / 和 /blog/(分别)每次都为前者产生匹配。如果你不使用/ 作为登陆,那可能没问题,否则我只使用return 'active' if pattern == request.path else ''(我还没有看到这个问题,但我只是设置使用这个)。
【解决方案2】:

我使用模板继承来自定义导航。例如:

base.html

<html>
    <head>...</head>
    <body>
        ...
        {% block nav %}
        <ul id="nav">
            <li>{% block nav-home %}<a href="{% url 'home' %}">Home</a>{% endblock %}</li>
            <li>{% block nav-about %}<a href="{% url 'about' %}">About</a>{% endblock %}</li>
            <li>{% block nav-contact %}<a href="{% url 'contact' %}">Contact</a>{% endblock %}</li>
        </ul>
        {% endblock %}
        ...
    </body>
</html>

关于.html

{% extends "base.html" %}

{% block nav-about %}<strong class="nav-active">About</strong>{% endblock %}

【讨论】:

  • 我非常喜欢这个想法,尤其是在灵活性方面,但它带来了 less-DRY 的权衡。不过,我确实开始在网站中使用它。
  • 我对这种方法并不热衷,因为由同一个子模板处理多个站点部分并不少见。因此,您最终将自定义变量放入视图中并将条件放入模板中,或者重新排列子模板以使它们都是唯一的……所有这些都只是为了检测当前站点部分。模板标签方法最终会变得更干净。
  • 我查看了其他一些解决方案,似乎它们都有点小窍门。至少,这个非常简单,易于实现/报废。
  • 我将&lt;ul id="nav"&gt;....&lt;/ul&gt; 重构为不同的文件,比如说tabs.html。所以现在 base.html 包含 {%block nav%}{%include "tabs.html"%}{%endblock%} 然后突出显示活动选项卡停止工作(在上面的 about.html 中)。我错过了什么吗?
  • @Maddy 你已经进行了足够多的间接操作,我不确定我是否将其保持在脑海中,但我认为答案与include 标签的方式有关作品。查看文档中包含的注释:docs.djangoproject.com/en/dev/ref/templates/builtins/#include 在您的情况下,当您尝试覆盖 about.html 中的基本模板时,我认为您已经有了一个呈现的 HTML 块,而不是 Django 模板等待处理的块。
【解决方案3】:

我喜欢上面 110j 的清洁度,所以我拿走了大部分并进行了重构,以解决我遇到的 3 个问题:

  1. 正则表达式是 将“家”网址与所有网址匹配 其他
  2. 我需要多个网址 映射到一个导航标签,所以我 需要一个更复杂的标签 可变数量的参数
  3. 修复了一些网址问题

这里是:

tags.py:

from django import template

register = template.Library()

@register.tag
def active(parser, token):
    args = token.split_contents()
    template_tag = args[0]
    if len(args) < 2:
        raise template.TemplateSyntaxError, "%r tag requires at least one argument" % template_tag
    return NavSelectedNode(args[1:])

class NavSelectedNode(template.Node):
    def __init__(self, patterns):
        self.patterns = patterns
    def render(self, context):
        path = context['request'].path
        for p in self.patterns:
            pValue = template.Variable(p).resolve(context)
            if path == pValue:
                return "active" # change this if needed for other bootstrap version (compatible with 3.2)
        return ""

urls.py:

urlpatterns += patterns('',
    url(r'/$', view_home_method, {}, name='home_url_name'),
    url(r'/services/$', view_services_method, {}, name='services_url_name'),
    url(r'/contact/$', view_contact_method, {}, name='contact_url_name'),
    url(r'/contact/$', view_contact2_method, {}, name='contact2_url_name'),
)

base.html:

{% load tags %}

{% url home_url_name as home %}
{% url services_url_name as services %}
{% url contact_url_name as contact %}
{% url contact2_url_name as contact2 %}

<div id="navigation">
    <a class="{% active request home %}" href="home">Home</a>
    <a class="{% active request services %}" href="services">Services</a>
    <a class="{% active request contact contact2 %}" href="contact">Contact</a>
</div>

【讨论】:

  • 这也许是我们对 Marcus 的最佳回答,但它如何与“家”一起工作?它总是活跃的?如何使其仅在根 url 调用(www.toto.com/ 和 www.toto.com/index)上激活?两个答案都不会导致这个问题......
【解决方案4】:

我是django-lineage的作者,我专门为解决这个问题而写的:D

我在自己的项目中使用(完全可以接受的)jpwatts 方法感到恼火,并从 110j 的回答中汲取了灵感。血统看起来像这样:

{% load lineage %}
<div id="navigation">
    <a class="{% ancestor '/home/' %}" href="/home/">Home</a>
    <a class="{% ancestor '/services/' %}" href="/services/">Services</a>
    <a class="{% ancestor '/contact/' %}" href="/contact/">Contact</a>
</div>

ancestor 如果参数与当前页面 URL 的开头匹配,则简单地替换为“活动”。

还支持可变参数和完整的{% url %} 类型反向解析。我撒了几个配置选项,充实了一点,打包起来供大家使用。

如果有人感兴趣,请在以下位置阅读更多信息:

>> github.com/marcuswhybrow/django-lineage

【讨论】:

  • 硬编码路径进入模板:(
【解决方案5】:

自Django 1.5:

在所有通用的基于类的视图(或任何基于类的视图继承 来自 ContextMixin),上下文字典包含一个视图变量 指向 View 实例。

因此,如果您使用此类视图,则可以添加类似 breadcrumbs 的内容作为类级别字段并在模板中使用。

示例查看代码:

class YourDetailView(DetailView):
     breadcrumbs = ['detail']
     (...)

在您的模板中,您可以这样使用它:

<a href="/detail/" {% if 'detail' in view.breadcrumbs %}class="active"{% endif %}>Detail</a>

如果要额外“高亮”父导航项,需要扩展breadcrumbs列表:

class YourDetailView(DetailView):
     breadcrumbs = ['dashboard', 'list', 'detail']
     (...)

...在您的模板中:

<a href="/dashboard/" {% if 'dashboard' in view.breadcrumbs %}class="active"{% endif %}>Dashboard</a>
<a href="/list/" {% if 'list' in view.breadcrumbs %}class="active"{% endif %}>List</a>
<a href="/detail/" {% if 'detail' in view.breadcrumbs %}class="active"{% endif %}>Detail</a>

这是一个简单而干净的解决方案,并且非常适合嵌套导航。

【讨论】:

  • 在那个例子中,不是所有三个导航项都是.active吗?
  • 是的,但这通常是您希望通过多级导航实现的目标。如果需要,您当然可以将一项放入breadcrumbs。但你说得对——我的例子不是最好的。
  • @Oli 改进示例。
【解决方案6】:

您可以将 class 或 id 应用于页面的 body 元素,而不是特定的导航项。

HTML:

<body class="{{ nav_class }}">

CSS:

body.home #nav_home,
body.about #nav_about { */ Current nav styles */ }

【讨论】:

    【解决方案7】:

    我是这样做的:

    <a class="tab {% ifequal active_tab "statistics" %}active{% endifequal %}" href="{% url Member.Statistics %}">Statistics</a>
    

    然后我所要做的就是在我看来将{'active_tab': 'statistics'} 添加到我的上下文字典中。

    如果您使用RequestContext,您可以在模板中获取当前路径:

    {{ request.path }}
    

    在你看来:

    from django.template import RequestContext
    
    def my_view(request):
        # do something awesome here
        return template.render(RequestContext(request, context_dict))
    

    【讨论】:

    • 感谢您分享此信息。我使用了这种方法,但我的导航栏中也有一个平面页面,因此为了检测并正确突出显示它,我使用了 {% ifequal flatpage.url '/about/' %}。我不喜欢对 URL 进行硬编码检测,但它适用于一次性 hack。
    • 此解决方案的问题是您将“统计信息”硬编码到代码中。这违背了使用 url 标签获取页面 url 的目的。
    【解决方案8】:

    我从上面的 nivhab 中获取了代码,并删除了一些奇怪的东西,并将其变成了一个干净的模板标签,修改了它,以便 /account/edit/ 仍然使 /account/ 选项卡处于活动状态。

    #current_nav.py
    from django import template
    
    register = template.Library()
    
    @register.tag
    def current_nav(parser, token):
        import re
        args = token.split_contents()
        template_tag = args[0]
        if len(args) < 2:
            raise template.TemplateSyntaxError, "%r tag requires at least one argument" % template_tag
        return NavSelectedNode(args[1])
    
    class NavSelectedNode(template.Node):
        def __init__(self, url):
            self.url = url
    
        def render(self, context):
            path = context['request'].path
            pValue = template.Variable(self.url).resolve(context)
            if (pValue == '/' or pValue == '') and not (path  == '/' or path == ''):
                return ""
            if path.startswith(pValue):
                return ' class="current"'
            return ""
    
    
    
    #template.html
    {% block nav %}
    {% load current_nav %}
    {% url home as home_url %}
    {% url signup as signup_url %}
    {% url auth_login as auth_login_url %}
    <ul class="container">
        <li><a href="{{ home_url }}"{% current_nav home_url %} title="Home">Home</a></li>
        <li><a href="{{ auth_login_url }}"{% current_nav auth_login_url %} title="Login">Login</a></li>
        <li><a href="{{ signup_url }}"{% current_nav signup_url %} title="Signup">Signup</a></li>
    </ul>
    {% endblock %}
    

    【讨论】:

      【解决方案9】:

      这只是上面Toba提出的css方案的一个变种:

      在您的基本模板中包含以下内容:

      <body id="section-{% block section %}home{% endblock %}">
      

      然后在扩展基本用途的模板中:

      {% block section %}show{% endblock %}
      

      然后您可以使用 css 根据 body 标签突出显示当前区域(例如,如果我们有一个 id 为 nav-home 的链接):

      #section-home a#nav-home{
       font-weight:bold;
      }
      

      【讨论】:

        【解决方案10】:

        您可以使用带有适当参数的reverse function 来获取当前网址。

        【讨论】:

          【解决方案11】:

          到目前为止,感谢您的回答,先生们。我又去了一些稍微不同的东西..

          在我的模板中:

          <li{{ link1_active }}>...link...</li>
          <li{{ link2_active }}>...link...</li>
          <li{{ link3_active }}>...link...</li>
          <li{{ link4_active }}>...link...</li>
          

          一旦我确定了我在逻辑中的哪个页面(通常在 urls.py 中),我将 class="selected" 作为正确名称下的上下文的一部分传递给模板。

          例如,如果我在 link1 页面上,我会将 {'link1_active':' class="selected"'} 附加到上下文中,以便模板提取并注入。

          它似乎工作并且它相当干净。

          编辑:为了将 HTML 排除在我的控制器/视图之外,我对此进行了一些修改:

          <li{% if link1_active %} class="selected"{% endif %}>...link...</li>
          <li{% if link2_active %} class="selected"{% endif %}>...link...</li>
          ...
          

          它使模板的可读性降低了一点,但我同意,最好不要从 urls 文件中推送原始 HTML。

          【讨论】:

          • 你应该真的避免在你的视图中处理原始 HTML,这是这项技术所需要的。您是否考虑过编写自定义模板标签?
          • 你是对的。我已经编辑停止通过 HTML。我现在只是通过True。我还没有写任何模板标签,但是是的,这可能是一个很好的起点。
          【解决方案12】:

          我发现最好的方法是使用包含标签:

          templates/fnf/nav_item.html

          <li class="nav-item">
              <a class="nav-link {% if is_active %}active{% endif %}" href="{% url url_name %}">{{ link_name }}</a>
          </li>
          

          这只是我希望渲染的基本引导导航项。

          它获取 href 值,以及可选的 link_name 值。 is_active 是根据当前请求计算出来的。

          templatetags/nav.py

          from django import template
          
          register = template.Library()
          
          
          @register.inclusion_tag('fnf/nav_item.html', takes_context=True)
          def nav_item(context, url_name, link_name=None):
              return {
                  'url_name': url_name,
                  'link_name': link_name or url_name.title(),
                  'is_active': context.request.resolver_match.url_name == url_name,
              }
          

          然后在导航中使用它: templates/fnf/nav.html

          {% load nav %}
          <nav class="navbar navbar-expand-lg navbar-light bg-light">
                  <ul class="navbar-nav mr-auto">
                          {% nav_item 'dashboard' %}
                      </ul>
          

          【讨论】:

          • 只是粗略阅读,但这不会限制 URL 上的 exact 匹配项吗?我通常也将这样的导航提示用于深层页面。例如,如果您在/about/company-history/ 或/about/what-we-do/ 上,则会突出显示关于导航项
          • 是的,但是is_active 可以被替换并返回字典中添加的其他键。此外,支票可以是context.request.resolver_match.url_name.startswith(x) 或其他任何内容。此外,您可以在 return 语句之前有代码以建立 dict 值。此外,您可以使用不同的模板,例如top_level_nav.html 的一个模板,具有不同的逻辑等。
          • 干净简单的解决方案...不错!
          【解决方案13】:

          我在同一页面上有多个通过循环动态创建的菜单。上面与上下文相关的帖子给了我一个快速修复。希望这可以帮助某人。 (除了活动模板标签外,我还使用它——我的修复解决了动态问题)。这似乎是一个愚蠢的比较,但它确实有效。我选择将变量命名为 active_something-unique 和 something-unique,这样它就可以与嵌套菜单一起使用。

          这是视图的一部分(足以理解我在做什么):

          def project_list(request, catslug):
              "render the category detail page"
              category = get_object_or_404(Category, slug=catslug, site__id__exact=settings.SITE_ID)
              context = {
                  'active_category': 
                      category,
                  'category': 
                      category,
                  'category_list': 
                      Category.objects.filter(site__id__exact=settings.SITE_ID),
          
              }
          

          这是来自模板:

          <ul>
            {% for category in category_list %}
              <li class="tab{% ifequal active_category category %}-active{% endifequal %}">
                <a href="{{ category.get_absolute_url }}">{{ category.cat }}</a>
              </li>
            {% endfor %}
          </ul>
          

          【讨论】:

            【解决方案14】:

            我的解决方案是编写一个简单的上下文处理器来根据请求路径设置变量:

            def navigation(request):
            """
            Custom context processor to set the navigation menu pointer.
            """
            nav_pointer = ''
            if request.path == '/':
                nav_pointer = 'main'
            elif request.path.startswith('/services/'):
                nav_pointer = 'services'
            elif request.path.startswith('/other_stuff/'):
                nav_pointer = 'other_stuff'
            return {'nav_pointer': nav_pointer}
            

            (不要忘记将您的自定义处理器添加到 settings.py 中的 TEMPLATE_CONTEXT_PROCESSORS。)

            然后在基本模板中,我为每个链接使用一个 ifequal 标记来确定是否附加“活动”类。当然,这种方法严格限制于路径结构的灵活性,但它适用于我相对适度的部署。

            【讨论】:

            • 我认为在全球范围内拥有这些确实很有意义,因此您可以通过各种方式引用站点部分(例如,为不同的站点部分使用不同的模板。+1。
            【解决方案15】:

            我只是想分享我对 nivhab 帖子的小幅改进。在我的应用程序中,我有子导航,我不想只使用 CSS 来隐藏它们,所以我需要某种“if”标签来显示某个项目的子导航。

            from django import template
            register = template.Library()
            
            @register.tag
            def ifnaviactive(parser, token):
                nodelist = parser.parse(('endifnaviactive',))
                parser.delete_first_token()
            
                import re
                args = token.split_contents()
                template_tag = args[0]
                if len(args) < 2:
                    raise template.TemplateSyntaxError, "%r tag requires at least one argument" % template_tag
                return NavSelectedNode(args[1:], nodelist)
            
            class NavSelectedNode(template.Node):
                def __init__(self, patterns, nodelist):
                    self.patterns = patterns
                    self.nodelist = nodelist
            
                def render(self, context):
                    path = context['request'].path
                    for p in self.patterns:
                        pValue = template.Variable(p).resolve(context)
                        if path == pValue:
                            return self.nodelist.render(context)
                    return ""
            

            你基本上可以像活动标签一样使用它:

            {% url product_url as product %}
            
            {% ifnaviactive request product %}
                <ul class="subnavi">
                    <li>Subnavi item for product 1</li>
                    ...
                </ul>
            {% endifnaviactive %}
            

            【讨论】:

              【解决方案16】:

              只是对原始解决方案的另一种改进。

              这接受多种模式,最好也是未命名的模式,写成用 '"' 包裹的相对 URL,如下所示:

              {% url admin:clients_client_changelist as clients %}
              {% url admin:clients_town_changelist as towns %}
              {% url admin:clients_district_changelist as districts %}
              
              <li class="{% active "/" %}"><a href="/">Home</a></li>
              <li class="{% active clients %}"><a href="{{ clients }}">Clients</a></li>
              {% if request.user.is_superuser %}
              <li class="{% active towns districts %}">
                  <a href="#">Settings</a>
                  <ul>
                      <li><a href="{{ towns }}">Towns</a></li>
                      <li><a href="{{ districts }}">Districts</a></li>
                  </ul>
              </li>
              {% endif %}
              

              标签是这样的:

              from django import template
              
              register = template.Library()
              
              @register.tag
              def active(parser, token):
                  args = token.split_contents()
                  template_tag = args[0]
                  if len(args) < 2:
                      raise template.TemplateSyntaxError, "%r tag requires at least one argument" % template_tag
                  return NavSelectedNode(args[1:])
              
              class NavSelectedNode(template.Node):
                  def __init__(self, urls):
                      self.urls = urls
              
                  def render(self, context):
                      path = context['request'].path
              
                      for url in self.urls:
                          if '"' not in url:
                              cpath = template.Variable(url).resolve(context)
                          else:
                              cpath = url.strip('"')
              
                          if (cpath == '/' or cpath == '') and not (path == '/' or path == ''):
                              return ""
                          if path.startswith(cpath):
                              return 'active'
                      return ""
              

              【讨论】:

                【解决方案17】:

                我使用 jquery 来突出显示我的导航栏。此解决方案只是将 css 类“活动”添加到适合 css 选择器的项目。

                <script type="text/javascript" src="/static/js/jquery.js"></script>
                <script>
                    $(document).ready(function(){
                        var path = location.pathname;
                        $('ul.navbar a.nav[href$="' + path + '"]').addClass("active");
                    });
                </script>
                

                【讨论】:

                  【解决方案18】:

                  对@tback 的回答做了一点改进,没有任何%if% 标签:

                  # navigation.py
                  from django import template
                  from django.core.urlresolvers import resolve
                  
                  register = template.Library()
                  
                  @register.filter(name="activate_if_active", is_safe=True)
                  def activate_if_active(request, urlname):
                    if resolve(request.get_full_path()).url_name == urlname:
                      return "active"
                    return ''
                  

                  像这样在你的模板中使用它:

                  {% load navigation %}
                  <li class="{{ request|activate_if_active:'url_name' }}">
                    <a href="{% url 'url_name' %}">My View</a>
                  </li>
                  

                  并在您的TEMPLATE_CONTEXT_PROCESSORS 设置中包含"django.core.context_processors.request"。

                  【讨论】:

                    【解决方案19】:

                    稍微修改 Andreas 的答案,看起来您可以将 urls.py 中的路由名称传递给模板标签。在我的示例my_tasks 中,然后在模板标记函数中使用反向函数来计算 URL 应该是什么,然后您可以将其与请求对象中的 URL 进行匹配(在模板上下文中可用)

                    from django import template
                    from django.core.urlresolvers import reverse
                    
                    register = template.Library()
                    
                    @register.tag
                    def active(parser, token):
                        args = token.split_contents()
                        template_tag = args[0]
                        if len(args) < 2:
                            raise template.TemplateSyntaxError, "%r tag requires at least one argument" % template_tag
                        return NavSelectedNode(args[1:])
                    
                    class NavSelectedNode(template.Node):
                        def __init__(self, name):
                            self.name = name
                    
                        def render(self, context):
                    
                            if context['request'].path == reverse(self.name[1]):
                                return 'active'
                            else:
                                return ''
                    

                    urls.py

                    url(r'^tasks/my', my_tasks, name = 'my_tasks' ),
                    

                    template.html

                    <li class="{% active request all_tasks %}"><a href="{% url all_tasks %}">Everyone</a></li>
                    

                    【讨论】:

                    【解决方案20】:

                    我知道我迟到了。不过,我不喜欢任何流行的解决方案:

                    block method 似乎是错误的:我认为导航应该是自包含的。

                    template_tag method 似乎是错误的:我不喜欢我必须先从 url-tag 中获取 url。另外,我认为 css-class 应该在模板中定义,而不是在标签中。

                    因此,我编写了一个没有上述缺点的过滤器。如果 url 处于活动状态,则返回 True,因此可以与 {% if %} 一起使用:

                    {% load navigation %}
                    <li{% if request|active:"home" %} class="active"{% endif %}><a href="{% url "home" %}">Home</a></li>
                    

                    代码:

                    @register.filter(name="active")
                    def active(request, url_name):
                        return resolve(request.path_info).url_name == url_name
                    

                    只需确保在带有导航的页面上使用RequestContext 或在settings.py 中启用请求上下文处理器

                    TEMPLATE_CONTEXT_PROCESSORS = (
                        ...
                        'django.core.context_processors.request',
                    )
                    

                    【讨论】:

                      【解决方案21】:

                      我见过jpwatts'、110j's、nivhab's & Marcus Whybrow's 的答案,但他们似乎都缺少一些东西:根路径呢?为什么它总是活跃的?

                      所以我做了另一种更简单的方法,让“控制器”自行决定,我认为它可以解决大部分大问题。

                      这是我的自定义标签:

                      ## myapp_tags.py
                      
                      @register.simple_tag
                      def nav_css_class(page_class):
                          if not page_class:
                              return ""
                          else:
                              return page_class
                      

                      然后,“控制器”声明需要的 CSS 类(事实上,最重要的是它向模板声明了它的存在)

                      ## views.py
                      
                      def ping(request):
                          context={}
                          context["nav_ping"] = "active"
                          return render(request, 'myapp/ping.html',context)
                      

                      最后,我在导航栏中渲染它:

                      <!-- sidebar.html -->
                      
                      {% load myapp_tags %}
                      ...
                      
                      <a class="{% nav_css_class nav_home %}" href="{% url 'index' %}">
                          Accueil
                      </a>
                      <a class="{% nav_css_class nav_candidats %}" href="{% url 'candidats' %}">
                          Candidats
                      </a>
                      <a class="{% nav_css_class nav_ping %}" href="{% url 'ping' %}">
                          Ping
                      </a>
                      <a class="{% nav_css_class nav_stat %}" href="{% url 'statistiques' %}">
                          Statistiques
                      </a>
                      ...
                      

                      所以每个页面都有自己的 nav_css_class 值来设置,如果设置了,模板会呈现活动状态:在模板上下文中不需要request,没有 URL 分配,也没有关于多 URL 页面或根的问题页面。

                      【讨论】:

                        【解决方案22】:

                        受到这个solution的启发,我开始使用这种方法:

                        **Placed in templates as base.html**
                        
                        {% block tab_menu %}
                        <ul class="tab-menu">
                          <li class="{% if active_tab == 'tab1' %} active{% endif %}"><a href="#">Tab 1</a></li>
                          <li class="{% if active_tab == 'tab2' %} active{% endif %}"><a href="#">Tab 2</a></li>
                          <li class="{% if active_tab == 'tab3' %} active{% endif %}"><a href="#">Tab 3</a></li>
                        </ul>
                        {% endblock tab_menu %}
                        
                        **Placed in your page template**
                        
                        {% extends "base.html" %}
                        
                        {% block tab_menu %}
                          {% with active_tab="tab1" %} {{ block.super }} {% endwith %}
                        {% endblock tab_menu %}
                        

                        【讨论】:

                          【解决方案23】:

                          这是我的尝试。我最终在我的视图中实现了一个包含我的导航结构(带有一些元数据)的类。然后我将它注入到模板中并渲染出来。

                          我的解决方案涉及 i18n。它可能应该再抽象一点,但我并没有真正在意。

                          views.py:

                          from django.utils.translation import get_language, ugettext as _
                          
                          
                          class Navi(list):
                              items = (_('Events'), _('Users'), )
                          
                              def __init__(self, cur_path):
                                  lang = get_language()
                                  first_part = '/' + cur_path.lstrip('/').split('/')[0]
                          
                                  def set_status(n):
                                      if n['url'] == first_part:
                                          n['status'] == 'active'
                          
                                  for i in self.items:
                                      o = {'name': i, 'url': '/' + slugify(i)}
                                      set_status(o)
                                      self.append(o)
                          
                          # remember to attach Navi() to your template context!
                          # ie. 'navi': Navi(request.path)
                          

                          我使用这样的包含定义了模板逻辑。基础模板:

                          {% include "includes/navigation.html" with items=navi %}
                          

                          实际包含(includes/navigation.html):

                           <ul class="nav">
                               {% for item in items %}
                                   <li class="{{ item.status }}">
                                       <a href="{{ item.url }}">{{ item.name }}</a>
                                   </li>
                               {% endfor %}
                           </ul>
                          

                          希望有人会觉得这很有用!我想扩展这个想法来支持嵌套层次结构等会很容易。

                          【讨论】:

                            【解决方案24】:

                            创建一个包含模板“intranet/nav_item.html”:

                            {% load url from future %}
                            
                            {% url view as view_url %}
                            <li class="nav-item{% ifequal view_url request.path %} current{% endifequal %}">
                                <a href="{{ view_url }}">{{ title }}</a>
                            </li>
                            

                            并将其包含在 nav 元素中:

                            <ul>
                                {% include "intranet/nav_item.html" with view='intranet.views.home' title='Home' %}
                                {% include "intranet/nav_item.html" with view='crm.views.clients' title='Clients' %}
                            </ul>
                            

                            您需要将其添加到设置中:

                            from django.conf import global_settings
                            TEMPLATE_CONTEXT_PROCESSORS = global_settings.TEMPLATE_CONTEXT_PROCESSORS + (
                                'django.core.context_processors.request',
                            )
                            

                            【讨论】:

                              【解决方案25】:

                              这是一个非常简单的解决方案,https://github.com/hellysmile/django-activeurl

                              【讨论】:

                              • 请注意,您应该在此处或此站点上发布有用的答案点,否则您的帖子可能会被删除为"Not an Answer"。如果您愿意,您仍然可以包含该链接,但仅作为“参考”。答案应该是独立的,不需要链接。
                              【解决方案26】:

                              来自SO Question

                              {% url 'some_urlpattern_name' as url %}
                              <a href="{{url}}"{% if request.path == url %} class="active"{% endif %}>Link</a>
                              

                              根据需要对每个链接重复。

                              【讨论】:

                              • 这仅适用于直接匹配。如果后代页面也处于活动状态,大多数导航系统会将导航项标记为活动状态。即,如果/blog/posts/2021/04/12 是 /blog/ 导航项将处于活动状态的 url。
                              • @Oli 是的,它有时会不起作用。例如在stackoverflow导航中,即Questions,Tags,Users,Badges,Unanswered,。它不适用于Questions,但对于所有其他导航都可以正常工作。
                              【解决方案27】:

                              我还使用 jQuery 来突出显示它,发现它比使用非语义 Django 模板标签混乱模板更优雅。

                              以下代码适用于引导程序 3 中的嵌套下拉菜单(突出显示父元素和子 &lt;li&gt; 元素。

                              // DOM Ready
                              $(function() {
                                  // Highlight current page in nav bar
                                  $('.nav, .navbar-nav li').each(function() {
                                      // Count the number of links to the current page in the <li>
                                      var matched_links = $(this).find('a[href]').filter(function() {
                                          return $(this).attr('href') == window.location.pathname; 
                                      }).length;
                                      // If there's at least one, mark the <li> as active
                                      if (matched_links)
                                          $(this).addClass('active');
                                  });
                              });
                              

                              为当前页面添加click 事件到return false(或将href 属性更改为#)也很容易,无需更改模板/html 标记:

                                      var matched_links = $(this).find('a[href]').filter(function() {
                                          var matched = $(this).attr('href') == window.location.pathname;
                                          if (matched)
                                              $(this).click(function() { return false; });
                                          return matched;
                                      }).length;
                              

                              【讨论】:

                                【解决方案28】:

                                我将这个 mixin 组合用于基于类的视图:

                                class SetActiveViewMixin(object):
                                    def get_context_data(self, **kwargs):
                                        context = super(SetActiveViewMixin, self).get_context_data(**kwargs)
                                        context['active_nav_menu'] = {
                                            self.request.resolver_match.view_name: ' class="pure-menu-selected"'
                                        }
                                        return context
                                

                                在模板中使用这个:

                                <ul>
                                    <li{{active_nav_menu.node_explorer }}><a href="{% url 'node_explorer' '' %}">Explore</a></li>
                                    <li{{active_nav_menu.node_create }}><a href="{% url 'node_create' path %}">Create</a></li>
                                    <li{{active_nav_menu.node_edit }}><a href="{% url 'node_edit' path %}">Edit</a></li>
                                    <li{{active_nav_menu.node_delete }}><a href="{% url 'node_delete' path %}">Delete</a></li>
                                </ul>
                                

                                【讨论】:

                                  【解决方案29】:

                                  我的有点类似于之前提交的另一种 JS 方法.. 只是没有 jQuery...

                                  假设我们在 base.html 中有以下内容:

                                  <div class="pure-u-1 pure-menu pure-menu-open pure-menu-horizontal header" >
                                      <ul class="">
                                          <li id="home"><a href="{% url 'article:index' %}">Home</a></li>
                                          <li id="news"><a href="{% url 'article:index' %}">News</a></li>
                                          <li id="analysis"><a href="{% url 'article:index' %}">Analysis</a></li>
                                          <li id="opinion"><a href="{% url 'article:index' %}">Opinion</a></li>
                                          <li id="data"><a href="{% url 'article:index' %}">Data</a></li>
                                          <li id="events"><a href="{% url 'article:index' %}">Events</a></li>
                                          <li id="forum"><a href="{% url 'article:index' %}">Forum</a></li>
                                          <li id="subscribe"><a href="{% url 'article:index' %}">Subscribe</a></li>
                                      </ul>
                                      <script type="text/javascript">
                                          (function(){
                                              loc=/\w+/.exec(window.location.pathname)[0];
                                              el=document.getElementById(loc).className='pure-menu-selected';         
                                          })();   
                                      </script>
                                  </div>
                                  

                                  我只是让我的层次结构遵循特定的 URL 模式...在主机地址之后...我有我的主要类别,例如家庭、新闻、分析等,而正则表达式只是将第一个单词拉出地点

                                  【讨论】:

                                    【解决方案30】:

                                    **

                                    只需像这样以 jinja 格式添加网址和名称

                                    **

                                     <ul class="nav navbar-nav">
                                            <li>
                                               <a href="{% url 'index' %}">Cities</a>
                                            </li>
                                            <li>
                                               <a href="{% url 'all_cafes' %}">Cafes</a>
                                            </li>
                                        </ul>
                                    

                                    【讨论】:

                                      猜你喜欢
                                      • 2016-08-25
                                      • 2013-04-28
                                      • 2012-08-08
                                      • 2017-08-31
                                      • 2020-08-10
                                      • 1970-01-01
                                      • 2013-06-08
                                      • 1970-01-01
                                      • 2017-11-24
                                      相关资源
                                      最近更新 更多