diff --git a/en/07.4.md b/en/07.4.md
index c8c3e268d..5a4a1bf0e 100644
--- a/en/07.4.md
+++ b/en/07.4.md
@@ -17,12 +17,12 @@ In Go, we have the `template` package to help handle templates. We can use funct
Example:
```Go
- func handler(w http.ResponseWriter, r *http.Request) {
- t := template.New("some template") // Create a template.
- t, _ = t.ParseFiles("tmpl/welcome.html", nil) // Parse template file.
- user := GetUser() // Get current user infomration.
- t.Execute(w, user) // merge.
- }
+func handler(w http.ResponseWriter, r *http.Request) {
+ t := template.New("some template") // Create a template.
+ t, _ = t.ParseFiles("tmpl/welcome.html", nil) // Parse template file.
+ user := GetUser() // Get current user infomration.
+ t.Execute(w, user) // merge.
+}
```
As you can see, it's very easy to use, load and render data in templates in Go, just as in other programming languages.
@@ -40,32 +40,32 @@ We've just shown you how to parse and render templates. Let's take it one step f
In Go, Every field that you intend to be rendered within a template should be put inside of `{{}}`. `{{.}}` is shorthand for the current object, which is similar to its Java or C++ counterpart. If you want to access the fields of the current object, you should use `{{.FieldName}}`. Notice that only exported fields can be accessed in templates. Here is an example:
```Go
- package main
-
- import (
- "html/template"
- "os"
- )
-
- type Person struct {
- UserName string
- }
-
- func main() {
- t := template.New("fieldname example")
- t, _ = t.Parse("hello {{.UserName}}!")
- p := Person{UserName: "Astaxie"}
- t.Execute(os.Stdout, p)
- }
+package main
+
+import (
+ "html/template"
+ "os"
+)
+
+type Person struct {
+ UserName string
+}
+
+func main() {
+ t := template.New("fieldname example")
+ t, _ = t.Parse("hello {{.UserName}}!")
+ p := Person{UserName: "Astaxie"}
+ t.Execute(os.Stdout, p)
+}
```
The above example outputs `hello Astaxie` correctly, but if we modify our struct a little bit, the following error emerges:
```Go
- type Person struct {
- UserName string
- email string // Field is not exported.
- }
+type Person struct {
+ UserName string
+ email string // Field is not exported.
+}
- t, _ = t.Parse("hello {{.UserName}}! {{.email}}")
+t, _ = t.Parse("hello {{.UserName}}! {{.email}}")
```
This part of the code will not be compiled because we try to access a field that has not been exported. However, if we try to use a field that does not exist, Go simply outputs an empty string instead of an error.
@@ -80,67 +80,67 @@ We know how to output a field now. What if the field is an object, and it also h
More examples:
```Go
- package main
-
- import (
- "html/template"
- "os"
- )
-
- type Friend struct {
- Fname string
- }
-
- type Person struct {
- UserName string
- Emails []string
- Friends []*Friend
- }
-
- func main() {
- f1 := Friend{Fname: "minux.ma"}
- f2 := Friend{Fname: "xushiwei"}
- t := template.New("fieldname example")
- t, _ = t.Parse(`hello {{.UserName}}!
- {{range .Emails}}
- an email {{.}}
- {{end}}
- {{with .Friends}}
- {{range .}}
- my friend name is {{.Fname}}
- {{end}}
- {{end}}
- `)
- p := Person{UserName: "Astaxie",
- Emails: []string{"astaxie@beego.me", "astaxie@gmail.com"},
- Friends: []*Friend{&f1, &f2}}
- t.Execute(os.Stdout, p)
- }
+package main
+
+import (
+ "html/template"
+ "os"
+)
+
+type Friend struct {
+ Fname string
+}
+
+type Person struct {
+ UserName string
+ Emails []string
+ Friends []*Friend
+}
+
+func main() {
+ f1 := Friend{Fname: "minux.ma"}
+ f2 := Friend{Fname: "xushiwei"}
+ t := template.New("fieldname example")
+ t, _ = t.Parse(`hello {{.UserName}}!
+ {{range .Emails}}
+ an email {{.}}
+ {{end}}
+ {{with .Friends}}
+ {{range .}}
+ my friend name is {{.Fname}}
+ {{end}}
+ {{end}}
+ `)
+ p := Person{UserName: "Astaxie",
+ Emails: []string{"astaxie@beego.me", "astaxie@gmail.com"},
+ Friends: []*Friend{&f1, &f2}}
+ t.Execute(os.Stdout, p)
+}
```
### Conditions
If you need to check for conditions in templates, you can use the `if-else` syntax just like you do in regular Go programs. If the pipeline is empty, the default value of `if` is `false`. The following example shows how to use `if-else` in templates:
```Go
- package main
-
- import (
- "os"
- "text/template"
- )
-
- func main() {
- tEmpty := template.New("template test")
- tEmpty = template.Must(tEmpty.Parse("Empty pipeline if demo: {{if ``}} will not be outputted. {{end}}\n"))
- tEmpty.Execute(os.Stdout, nil)
-
- tWithValue := template.New("template test")
- tWithValue = template.Must(tWithValue.Parse("Not empty pipeline if demo: {{if `anything`}} will be outputted. {{end}}\n"))
- tWithValue.Execute(os.Stdout, nil)
-
- tIfElse := template.New("template test")
- tIfElse = template.Must(tIfElse.Parse("if-else demo: {{if `anything`}} if part {{else}} else part.{{end}}\n"))
- tIfElse.Execute(os.Stdout, nil)
- }
+package main
+
+import (
+ "os"
+ "text/template"
+)
+
+func main() {
+ tEmpty := template.New("template test")
+ tEmpty = template.Must(tEmpty.Parse("Empty pipeline if demo: {{if ``}} will not be outputted. {{end}}\n"))
+ tEmpty.Execute(os.Stdout, nil)
+
+ tWithValue := template.New("template test")
+ tWithValue = template.Must(tWithValue.Parse("Not empty pipeline if demo: {{if `anything`}} will be outputted. {{end}}\n"))
+ tWithValue.Execute(os.Stdout, nil)
+
+ tIfElse := template.New("template test")
+ tIfElse = template.Must(tIfElse.Parse("if-else demo: {{if `anything`}} if part {{else}} else part.{{end}}\n"))
+ tIfElse.Execute(os.Stdout, nil)
+}
```
As you can see, it's easy to use `if-else` in templates.
@@ -184,105 +184,105 @@ Suppose we have an `emailDeal` template function associated with its `EmailDealW
Example:
```Go
- package main
-
- import (
- "fmt"
- "html/template"
- "os"
- "strings"
- )
-
- type Friend struct {
- Fname string
+package main
+
+import (
+ "fmt"
+ "html/template"
+ "os"
+ "strings"
+)
+
+type Friend struct {
+ Fname string
+}
+
+type Person struct {
+ UserName string
+ Emails []string
+ Friends []*Friend
+}
+
+func EmailDealWith(args ...interface{}) string {
+ ok := false
+ var s string
+ if len(args) == 1 {
+ s, ok = args[0].(string)
}
-
- type Person struct {
- UserName string
- Emails []string
- Friends []*Friend
+ if !ok {
+ s = fmt.Sprint(args...)
}
-
- func EmailDealWith(args ...interface{}) string {
- ok := false
- var s string
- if len(args) == 1 {
- s, ok = args[0].(string)
- }
- if !ok {
- s = fmt.Sprint(args...)
- }
- // find the @ symbol
- substrs := strings.Split(s, "@")
- if len(substrs) != 2 {
- return s
- }
- // replace the @ by " at "
- return (substrs[0] + " at " + substrs[1])
- }
-
- func main() {
- f1 := Friend{Fname: "minux.ma"}
- f2 := Friend{Fname: "xushiwei"}
- t := template.New("fieldname example")
- t = t.Funcs(template.FuncMap{"emailDeal": EmailDealWith})
- t, _ = t.Parse(`hello {{.UserName}}!
- {{range .Emails}}
- an emails {{.|emailDeal}}
- {{end}}
- {{with .Friends}}
- {{range .}}
- my friend name is {{.Fname}}
- {{end}}
- {{end}}
- `)
- p := Person{UserName: "Astaxie",
- Emails: []string{"astaxie@beego.me", "astaxie@gmail.com"},
- Friends: []*Friend{&f1, &f2}}
- t.Execute(os.Stdout, p)
+ // find the @ symbol
+ substrs := strings.Split(s, "@")
+ if len(substrs) != 2 {
+ return s
}
+ // replace the @ by " at "
+ return (substrs[0] + " at " + substrs[1])
+}
+
+func main() {
+ f1 := Friend{Fname: "minux.ma"}
+ f2 := Friend{Fname: "xushiwei"}
+ t := template.New("fieldname example")
+ t = t.Funcs(template.FuncMap{"emailDeal": EmailDealWith})
+ t, _ = t.Parse(`hello {{.UserName}}!
+ {{range .Emails}}
+ an emails {{.|emailDeal}}
+ {{end}}
+ {{with .Friends}}
+ {{range .}}
+ my friend name is {{.Fname}}
+ {{end}}
+ {{end}}
+ `)
+ p := Person{UserName: "Astaxie",
+ Emails: []string{"astaxie@beego.me", "astaxie@gmail.com"},
+ Friends: []*Friend{&f1, &f2}}
+ t.Execute(os.Stdout, p)
+}
```
Here is a list of built-in template functions:
```Go
- var builtins = FuncMap{
- "and": and,
- "call": call,
- "html": HTMLEscaper,
- "index": index,
- "js": JSEscaper,
- "len": length,
- "not": not,
- "or": or,
- "print": fmt.Sprint,
- "printf": fmt.Sprintf,
- "println": fmt.Sprintln,
- "urlquery": URLQueryEscaper,
- }
+var builtins = FuncMap{
+ "and": and,
+ "call": call,
+ "html": HTMLEscaper,
+ "index": index,
+ "js": JSEscaper,
+ "len": length,
+ "not": not,
+ "or": or,
+ "print": fmt.Sprint,
+ "printf": fmt.Sprintf,
+ "println": fmt.Sprintln,
+ "urlquery": URLQueryEscaper,
+}
```
## Must
The template package has a function called `Must` which is for validating templates, like the matching of braces, comments, and variables. Let's take a look at an example of `Must`:
```Go
- package main
+package main
- import (
- "fmt"
- "text/template"
- )
+import (
+ "fmt"
+ "text/template"
+)
- func main() {
- tOk := template.New("first")
- template.Must(tOk.Parse(" some static text /* and a comment */"))
- fmt.Println("The first one parsed OK.")
+func main() {
+ tOk := template.New("first")
+ template.Must(tOk.Parse(" some static text /* and a comment */"))
+ fmt.Println("The first one parsed OK.")
- template.Must(template.New("second").Parse("some static text {{ .Name }}"))
- fmt.Println("The second one parsed OK.")
+ template.Must(template.New("second").Parse("some static text {{ .Name }}"))
+ fmt.Println("The second one parsed OK.")
- fmt.Println("The next one ought to fail.")
- tErr := template.New("check parse error with Must")
- template.Must(tErr.Parse(" some static text {{ .Name }"))
- }
+ fmt.Println("The next one ought to fail.")
+ tErr := template.New("check parse error with Must")
+ template.Must(tErr.Parse(" some static text {{ .Name }"))
+}
```
Output:
@@ -306,76 +306,76 @@ Here's a complete example, supposing that we have the following three files: `he
Main template:
```html
{% raw %}
- //header.tmpl
- {{define "header"}}
-
-
- Something here
-
-
- {{end}}
-
- //content.tmpl
- {{define "content"}}
- {{template "header"}}
-
Nested here
-
-
Nested usag
-
Call template
-
- {{template "footer"}}
- {{end}}
-
- //footer.tmpl
- {{define "footer"}}
-
-
- {{end}}
-
- //When using subtemplating make sure that you have parsed each sub template file,
- //otherwise the compiler wouldn't understand what to substitute when it reads the {{template "header"}}
+//header.tmpl
+{{define "header"}}
+
+
+ Something here
+
+
+{{end}}
+
+//content.tmpl
+{{define "content"}}
+{{template "header"}}
+
Nested here
+
+
Nested usag
+
Call template
+
+{{template "footer"}}
+{{end}}
+
+//footer.tmpl
+{{define "footer"}}
+
+
+{{end}}
+
+//When using subtemplating make sure that you have parsed each sub template file,
+//otherwise the compiler wouldn't understand what to substitute when it reads the {{template "header"}}
{% endraw %}
```
Code:
```Go
- package main
-
- import (
- "fmt"
- "os"
- "io/ioutil"
- "text/template"
- )
-
- var templates *template.Template
-
- func main() {
- var allFiles []string
- files, err := ioutil.ReadDir("./templates")
- if err != nil {
- fmt.Println(err)
- }
- for _, file := range files {
- filename := file.Name()
- if strings.HasSuffix(filename, ".tmpl") {
- allFiles = append(allFiles, "./templates/"+filename)
- }
+package main
+
+import (
+ "fmt"
+ "os"
+ "io/ioutil"
+ "text/template"
+)
+
+var templates *template.Template
+
+func main() {
+ var allFiles []string
+ files, err := ioutil.ReadDir("./templates")
+ if err != nil {
+ fmt.Println(err)
+ }
+ for _, file := range files {
+ filename := file.Name()
+ if strings.HasSuffix(filename, ".tmpl") {
+ allFiles = append(allFiles, "./templates/"+filename)
}
-
- templates, err = template.ParseFiles(allFiles...) #parses all .tmpl files in the 'templates' folder
-
- s1, _ := templates.LookUp("header.tmpl")
- s1.ExecuteTemplate(os.Stdout, "header", nil)
- fmt.Println()
- s2, _ := templates.LookUp("content.tmpl")
- s2.ExecuteTemplate(os.Stdout, "content", nil)
- fmt.Println()
- s3, _ := templates.LookUp("footer.tmpl")
- s3.ExecuteTemplate(os.Stdout, "footer", nil)
- fmt.Println()
- s3.Execute(os.Stdout, nil)
}
+
+ templates, err = template.ParseFiles(allFiles...) #parses all .tmpl files in the 'templates' folder
+
+ s1, _ := templates.LookUp("header.tmpl")
+ s1.ExecuteTemplate(os.Stdout, "header", nil)
+ fmt.Println()
+ s2, _ := templates.LookUp("content.tmpl")
+ s2.ExecuteTemplate(os.Stdout, "content", nil)
+ fmt.Println()
+ s3, _ := templates.LookUp("footer.tmpl")
+ s3.ExecuteTemplate(os.Stdout, "footer", nil)
+ fmt.Println()
+ s3.Execute(os.Stdout, nil)
+}
```
Here we can see that `template.ParseFiles` parses all nested templates into cache, and that every template defined by `{{define}}` are independent of each other. They are persisted in something like a map, where the template names are keys and the values are the template bodies. We can then use `ExecuteTemplate` to execute the corresponding sub-templates, so that the header and footer are independent and content contains them both. Note that if we try to execute `s1.Execute`, nothing will be outputted because there is no default sub-template available.
@@ -385,12 +385,12 @@ Templates in one set know each other, but you must parse them for every single s
Some times you want to contextualize templates, for instance you have a `_head.html`, you might have a header who's value you have to populate based on which data you are loading for instance for a todo list manager you can have three categories `pending`, `completed`, `deleted`. for this suppose you have an if statement like this
```html
- {{if eq .Navigation "pending"}} Tasks
- {{ else if eq .Navigation "completed"}}Completed
- {{ else if eq .Navigation "deleted"}}Deleted
- {{ else if eq .Navigation "edit"}} Edit
- {{end}}
-
+{{if eq .Navigation "pending"}} Tasks
+ {{ else if eq .Navigation "completed"}}Completed
+ {{ else if eq .Navigation "deleted"}}Deleted
+ {{ else if eq .Navigation "edit"}} Edit
+ {{end}}
+
```
Note: Go templates follow the Polish notation while performing the comparison where you give the operator first and the comparison value and the value to be compared with. The else if part is pretty straight forward
@@ -402,27 +402,27 @@ Typically we use a `{{ range }}` operator to loop through the context variable w
```
We get the context object from the database as a struct object, the definition is as below
```Go
- //Task is the struct used to identify tasks
- type Task struct {
- Id int
- Title string
- Content string
- Created string
- }
- //Context is the struct passed to templates
- type Context struct {
- Tasks []Task
- Navigation string
- Search string
- Message string
- }
-
- //present in database package
- var task []types.Task
- var context types.Context
- context = types.Context{Tasks: task, Navigation: status}
-
- //This line is in the database package where the context is returned back to the view.
+//Task is the struct used to identify tasks
+type Task struct {
+ Id int
+ Title string
+ Content string
+ Created string
+}
+//Context is the struct passed to templates
+type Context struct {
+ Tasks []Task
+ Navigation string
+ Search string
+ Message string
+}
+
+//present in database package
+var task []types.Task
+var context types.Context
+context = types.Context{Tasks: task, Navigation: status}
+
+//This line is in the database package where the context is returned back to the view.
```
We use the task array and the Navigation in our templates, we saw how we use the Navigation in the template,
we'll see how we'll use the actual task array in our template.
@@ -434,29 +434,29 @@ start with the Range operator, then we can give any member of that struct as `{{
Title and a Content, (please note the capital T and C, they are exported names and they need to be capitalised unless you
want to make them private).
```Go
- {{ range .Tasks }}
- {{ .Title }}
- {{ .Content }}
- {{ end }}
+{{ range .Tasks }}
+ {{ .Title }}
+ {{ .Content }}
+{{ end }}
```
This block of code will print each title and content of the Task array. Below is a full example from github.com/thewhitetulip/Tasks home.html template.
```html
-