mirror of https://github.com/kataras/iris.git synced 2025-01-23 18:51:03 +01:00

History

Gerasimos (Makis) Maropoulos 0d26f24eb7 examples: replace all app.Run(iris.Addr(...)) with app.Listen just for the shake of simplicity, both are doing the same exact thing as it's described on the http listening first example. Former-commit-id: d20afb2e899aee658a8e0ed1693357798df93462		2020-03-05 22:41:27 +02:00
..
amber.go	version 12.1.5	2020-02-02 16:29:06 +02:00
django.go	version 12.1.5	2020-02-02 16:29:06 +02:00
engine.go	version 12.1.5	2020-02-02 16:29:06 +02:00
funcs.go	version 12.1.5	2020-02-02 16:29:06 +02:00
handlebars.go	version 12.1.5	2020-02-02 16:29:06 +02:00
html.go	fix https://github.com/kataras/iris/issues/1450 and continue on implementing 1449	2020-02-14 23:34:56 +02:00
jet.go	Update to version 12.1.6	2020-02-05 12:36:21 +02:00
pug.go	fix of https://github.com/kataras/iris/issues/1450#issuecomment-586581677	2020-02-15 21:16:21 +02:00
README.md	examples: replace all app.Run(iris.Addr(...)) with app.Listen just for the shake of simplicity, both are doing the same exact thing as it's described on the http listening first example.	2020-03-05 22:41:27 +02:00
view.go	Upgrade to new go errors and some minor fixes and improvements including easier debugging of invalid routes and e.t.c.	2019-10-24 18:57:05 +03:00

README.md

View

Iris supports 6 template engines out-of-the-box, developers can still use any external golang template engine, as context/context#ResponseWriter() is an io.Writer.

All of these six template engines have common features with common API, like Layout, Template Funcs, Party-specific layout, partial rendering and more.

The standard html, its template parser is the golang.org/pkg/html/template/
Django, its template parser is the github.com/iris-contrib/pongo2
Pug(Jade), its template parser is the github.com/Joker/jade
Handlebars, its template parser is the github.com/aymerick/raymond
Amber, its template parser is the github.com/eknkc/amber
Jet, its template parser is the github.com/CloudyKit/jet

Examples

You can serve quicktemplate files too, simply by using the context#ResponseWriter, take a look at the iris/_examples/http_responsewriter/quicktemplate example.

Overview

// file: main.go
package main

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

func main() {
    app := iris.New()
    // Load all templates from the "./views" folder
    // where extension is ".html" and parse them
    // using the standard `html/template` package.
    app.RegisterView(iris.HTML("./views", ".html"))

    // Method:    GET
    // Resource:  http://localhost:8080
    app.Get("/", func(ctx iris.Context) {
        // Bind: {{.message}} with "Hello world!"
        ctx.ViewData("message", "Hello world!")
        // Render template file: ./views/hello.html
        ctx.View("hello.html")
    })

    // Method:    GET
    // Resource:  http://localhost:8080/user/42
    app.Get("/user/{id:long}", func(ctx iris.Context) {
        userID, _ := ctx.Params().GetInt64("id")
        ctx.Writef("User ID: %d", userID)
    })

    // Start the server using a network address.
    app.Listen(":8080")
}

<!-- file: ./views/hello.html -->
<html>
<head>
    <title>Hello Page</title>
</head>
<body>
    <h1>{{.message}}</h1>
</body>
</html>

Template functions

package main

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

func main() {
    app := iris.New()
    tmpl := iris.HTML("./templates", ".html")

    // builtin template funcs are:
    //
    // - {{ urlpath "mynamedroute" "pathParameter_ifneeded" }}
    // - {{ render "header.html" }}
    // - {{ render_r "header.html" }} // partial relative path to current page
    // - {{ yield }}
    // - {{ current }}

    // register a custom template func.
    tmpl.AddFunc("greet", func(s string) string {
        return "Greetings " + s + "!"
    })

    // register the view engine to the views, this will load the templates.
    app.RegisterView(tmpl)

    app.Get("/", hi)

    // http://localhost:8080
    app.Listen(":8080")
}

func hi(ctx iris.Context) {
    // render the template file "./templates/hi.html"
    ctx.View("hi.html")
}

<!-- file: ./templates/hi.html -->
<b>{{greet "kataras"}}</b> <!-- will be rendered as: <b>Greetings kataras!</b> -->

Embedded

View engine supports bundled(https://github.com/go-bindata/go-bindata) template files too. go-bindata gives you two functions, Assset and AssetNames, these can be set to each of the template engines using the .Binary function.

Example code:

package main

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

func main() {
    app := iris.New()
    // $ go get -u github.com/go-bindata/go-bindata/...
    // $ go-bindata ./templates/...
    // $ go build
    // $ ./embedding-templates-into-app
    // html files are not used, you can delete the folder and run the example
    app.RegisterView(iris.HTML("./templates", ".html").Binary(Asset, AssetNames))
    app.Get("/", hi)

    // http://localhost:8080
    app.Listen(":8080")
}

type page struct {
    Title, Name string
}

func hi(ctx iris.Context) {
    //                      {{.Page.Title}} and {{Page.Name}}
    ctx.ViewData("Page", page{Title: "Hi Page", Name: "iris"})
    ctx.View("hi.html")
}

A real example can be found here: https://github.com/kataras/iris/tree/master/_examples/view/embedding-templates-into-app.

Reload

Enable auto-reloading of templates on each request. Useful while developers are in dev mode as they no neeed to restart their app on every template edit.

Example code:

pugEngine := iris.Pug("./templates", ".jade")
pugEngine.Reload(true) // <--- set to true to re-build the templates on each request.
app.RegisterView(pugEngine)