html 플라스크 - Play2 스칼라 템플릿에서 변수 선언하기




전역변수 주석 (7)

꽤 깨끗해 보이고 때로는 선호되는 확실한 해결책이 있습니다. 템플릿 주위에 범위를 정의하고 그 안에 변수를 정의한 다음 범위에서 필요한 html 코드를 생성하도록합니다.

@{
  val title = "Home"

  <h1>Welcome on {title}</h1>
}

여기에는 몇 가지 단점이 있습니다.

  • Scala NodeSeq 로 html을 생성 할 때 가끔 제한적일 수 있습니다.
  • 이 솔루션에 대한 성능 문제가 있습니다. @{ 내부의 코드는 컴파일 된 런타임 인 ​​것으로 보이는데, 페이지 용으로 생성 된 스칼라 코드가 이와 같이 loooks (일부 일반적인 Twirl 요소가 삭제됨) 되었기 때문입니다.

생성 된 코드 :

...    

Seq[Any](format.raw/*1.1*/("""<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Basic Twirl</title>
    </head>
    <body>

        """),_display_(/*9.10*/{
            val title = "Home"

                <h1>Welcome on {title}</h1>
        }),format.raw/*15.10*/("""

    """),format.raw/*17.5*/("""</body>
</html>"""))
      }
    }
  }

...

Play2 Scala 템플릿에서 로컬 변수를 선언하고 초기화하는 방법은 무엇입니까?

나는 이것을 가지고있다:

@var title : String = "Home"

템플릿의 맨 위에 선언했지만이 오류가 발생합니다.

illegal start of simple expression """),_display_(Seq[Any](/*3.2*/var)),format.raw/*3.5*/(""" title : String = "Home"

virtualeyes '해결책은 적절한 것이지만, 다른 가능성이 있습니다, 당신은 단지 디폴트 값으로 뷰의 param을 선언 할 수 있습니다. 그런 경우에는 전체 템플릿에 사용할 수있게 할 것입니다. controller :

@(title: String = "Home page")

<h1>Welcome on @title</h1>

제어 장치:

def index = Action{
    Ok(views.html.index("Other title"))
}

Java 컨트롤러는 템플릿의 기본값을 인식하지 않으므로 매번 템플릿을 추가해야합니다.

public static Result index(){
    return ok(views.html.index.render("Some default value..."));
}

@defining으로 모든 컨텐츠를 래핑하지 않으려면 다음을 수행하십시오.

@yourVariable = { yourValue }

@defining 지시문은 템플릿에서 실제로 읽을 수 없습니다 ...


@defining("foo") { title=>
  <div>@title</div>
  ...
}

기본적으로, 당신은 그것을 사용하려고하는 블록을 포장해야합니다.


scala 템플릿이 이것을 지원합니다. 템플릿에 변수를 정의 할 수 있습니다.

@import java.math.BigInteger; var i=1; var k=1

템플릿 값을 변경할 수 있습니다.

@{k=2}

@(title:String)(implicit session:play.api.mvc.Session)
@import java.math.BigInteger; var i=1; var k=1
^
<div id='[email protected]'>
                     ^
  <div id='[email protected]'></div>
                     ^
</div>

@isExcel= {@Boolean.valueOf(java.lang.System.getProperty(SettingsProperties.isExcel))}

@Will Hartung 의 답변과 동일한 기본 아이디어를 바탕으로, 여기 내 마술 단일 태그 확장 가능 템플릿 엔진이 있습니다. 그것은 문서와 예제를 포함합니다 :-)

WEB-INF / tags / block.tag :

<%--
    The block tag implements a basic but useful extensible template system.

    A base template consists of a block tag without a 'template' attribute.
    The template body is specified in a standard jsp:body tag, which can
    contain EL, JSTL tags, nested block tags and other custom tags, but
    cannot contain scriptlets (scriptlets are allowed in the template file,
    but only outside of the body and attribute tags). Templates can be
    full-page templates, or smaller blocks of markup included within a page.

    The template is customizable by referencing named attributes within
    the body (via EL). Attribute values can then be set either as attributes
    of the block tag element itself (convenient for short values), or by
    using nested jsp:attribute elements (better for entire blocks of markup).

    Rendering a template block or extending it in a child template is then
    just a matter of invoking the block tag with the 'template' attribute set
    to the desired template name, and overriding template-specific attributes
    as necessary to customize it.

    Attribute values set when rendering a tag override those set in the template
    definition, which override those set in its parent template definition, etc.
    The attributes that are set in the base template are thus effectively used
    as defaults. Attributes that are not set anywhere are treated as empty.

    Internally, attributes are passed from child to parent via request-scope
    attributes, which are removed when rendering is complete.

    Here's a contrived example:

    ====== WEB-INF/tags/block.tag (the template engine tag)

    <the file you're looking at right now>

    ====== WEB-INF/templates/base.jsp (base template)

    <%@ page trimDirectiveWhitespaces="true" %>
    <%@ taglib prefix="t" tagdir="/WEB-INF/tags" %>
    <t:block>
        <jsp:attribute name="title">Template Page</jsp:attribute>
        <jsp:attribute name="style">
            .footer { font-size: smaller; color: #aaa; }
            .content { margin: 2em; color: #009; }
            ${moreStyle}
        </jsp:attribute>
        <jsp:attribute name="footer">
            <div class="footer">
                Powered by the block tag
            </div>
        </jsp:attribute>
        <jsp:body>
            <html>
                <head>
                    <title>${title}</title>
                    <style>
                        ${style}
                    </style>
                </head>
                <body>
                    <h1>${title}</h1>
                    <div class="content">
                        ${content}
                    </div>
                    ${footer}
                </body>
            </html>
        </jsp:body>
    </t:block>

    ====== WEB-INF/templates/history.jsp (child template)

    <%@ page trimDirectiveWhitespaces="true" %>
    <%@ taglib prefix="t" tagdir="/WEB-INF/tags" %>
    <t:block template="base" title="History Lesson">
        <jsp:attribute name="content" trim="false">
            <p>${shooter} shot first!</p>
        </jsp:attribute>
    </t:block>

    ====== history-1977.jsp (a page using child template)

    <%@ page trimDirectiveWhitespaces="true" %>
    <%@ taglib prefix="t" tagdir="/WEB-INF/tags" %>
    <t:block template="history" shooter="Han" />

    ====== history-1997.jsp (a page using child template)

    <%@ page trimDirectiveWhitespaces="true" %>
    <%@ taglib prefix="t" tagdir="/WEB-INF/tags" %>
    <t:block template="history" title="Revised History Lesson">
        <jsp:attribute name="moreStyle">.revised { font-style: italic; }</jsp:attribute>
        <jsp:attribute name="shooter"><span class="revised">Greedo</span></jsp:attribute>
    </t:block>

--%>

<%@ tag trimDirectiveWhitespaces="true" %>
<%@ tag import="java.util.HashSet, java.util.Map, java.util.Map.Entry" %>
<%@ tag dynamic-attributes="dynattributes" %>
<%@ attribute name="template" %>
<%
    // get template name (adding default .jsp extension if it does not contain
    // any '.', and /WEB-INF/templates/ prefix if it does not start with a '/')
    String template = (String)jspContext.getAttribute("template");
    if (template != null) {
        if (!template.contains("."))
            template += ".jsp";
        if (!template.startsWith("/"))
            template = "/WEB-INF/templates/" + template;
    }
    // copy dynamic attributes into request scope so they can be accessed from included template page
    // (child is processed before parent template, so only set previously undefined attributes)
    Map<String, String> dynattributes = (Map<String, String>)jspContext.getAttribute("dynattributes");
    HashSet<String> addedAttributes = new HashSet<String>();
    for (Map.Entry<String, String> e : dynattributes.entrySet()) {
        if (jspContext.getAttribute(e.getKey(), PageContext.REQUEST_SCOPE) == null) {
            jspContext.setAttribute(e.getKey(), e.getValue(), PageContext.REQUEST_SCOPE);
            addedAttributes.add(e.getKey());
        }
    }
%>

<% if (template == null) { // this is the base template itself, so render it %>
    <jsp:doBody/>
<% } else { // this is a page using the template, so include the template instead %>
    <jsp:include page="<%= template %>" />
<% } %>

<%
    // clean up the added attributes to prevent side effect outside the current tag
    for (String key : addedAttributes) {
        jspContext.removeAttribute(key, PageContext.REQUEST_SCOPE);
    }
%>






html scala templates playframework playframework-2.0