Renderização de Template com Go Iris

Renderização de Modelo

O Iris tem suporte integrado para oito mecanismos de modelo e os desenvolvedores ainda podem usar qualquer mecanismo de modelo externo da linguagem Go porque Context.ResponseWriter() é um io.Writer.

Todos os mecanismos de modelo compartilham uma API comum, incluindo análise usando recursos integrados, layout e layout específico de Party, funções de modelo e renderização parcial.

Você pode registrar um mecanismo de visualização para cada Party. Use o método Application/Party.RegisterView(ViewEngine) para registrar, como mostrado abaixo:

Carregue todos os modelos com a extensão ".html" da pasta "./views" e analise usando o pacote padrão html/template.

// [app := iris.New...]
tmpl := iris.HTML("./views", ".html")
app.RegisterView(tmpl)

No manipulador da rota principal, use o método Context.View para renderizar ou executar uma visualização.

if err := ctx.View("hi.html"); err != nil {
    ctx.HTML("%s", err.Error())
    return
}

Use o método Context.ViewData no middleware ou manipulador principal para vincular valores Go com padrões de chave-valor na visualização.

Vincule {{.mensagem}} com "Olá mundo!".

ctx.ViewData("mensagem", "Olá mundo!")

Vinculação raiz:

if err := ctx.View("user-page.html", User{}); err != nil {
    ctx.HTML("%s", err.Error())
    return
}

// vinculação raíz como {{.Nome}}

Use o método AddFunc do mecanismo de visualização preferido para adicionar funções de modelo.

//       nome da função, parâmetros de entrada, valor de retorno
tmpl.AddFunc("saudacao", func(s string) string {
    return "Saudações " + s + "!"
})

Se desejar recarregar a cada solicitação, chame o método Reload do mecanismo de visualização.

tmpl.Reload(true)

Se desejar usar modelos embutidos sem depender do sistema de arquivos local, use a ferramenta externa go-bindata e passe a função AssetFile() que ele gera como o primeiro parâmetro de entrada para o mecanismo de visualização preferido.

tmpl := iris.HTML(AssetFile(), ".html")

Código de exemplo:

// Arquivo: main.go
pacote principal

import "github.com/kataras/iris/v12"

func principal() {
    app := iris.New()

    // Analisar todos os modelos com o sufixo ".html" da pasta "./views"
    // Use o pacote padrão `html/template` para análise
    tmpl := iris.HTML("./views", ".html")
    // Definir delimitadores personalizados
    tmpl.Delims("{{", "}}")
    // Ativar recompilação para alterações locais nos arquivos de modelo
    tmpl.Reload(true)
    
    // As funções de modelo padrão incluem:
    //
    // - {{ urlpath "myNamedRoute" "pathParameter_ifNeeded" }}
    // - {{ render "header.html" . }}
    // E o caminho relativo para a página atual:
    // - {{ render_r "header.html" . }} 
    // - {{ yield . }}
    // - {{ current }}
    // Registrar uma função de modelo personalizada:
    tmpl.AddFunc("saudar", func(s string) string {
        return "Saudações " + s + "!"
    })
    
    // Registrar o mecanismo de visualização para a aplicação,
    // isso carregará os modelos.
    app.RegisterView(tmpl)
    
    // Método: GET
    // Recurso: http://localhost:8080
    app.Get("/", func(ctx iris.Context) {
        // Vincular {{.message}} a "Olá, mundo!"
        ctx.ViewData("message", "Olá, mundo!")
        // Renderizar o arquivo de modelo: ./views/hi.html
        if err := ctx.View("hi.html"); err != nil {
            ctx.HTML("%s", err.Error())
            return
        }
    })
    
    app.Listen(":8080")
}

Página de saudação


{{.message}}
{{saudar "para você"}}

Abra uma nova guia no seu navegador e visite http://localhost:8080.

O resultado renderizado deve ser o seguinte:

    Página de saudação


    Olá, mundo!
    Saudações para você!