Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
\\nPrice : 23.99 $
\\n{{ .Price }}
\\n<\\n{{ $.Price }}
\")])]),_c('p',[_vm._v(\"We have two notations \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\".Price\")])]),_vm._v(\" and \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"$.Price\")])]),_vm._v(\" point to the same value. The dot gives you access to the global data context of the template.\")]),_c('p',[_vm._v(\"Inside an iteration, the dot is equal to the current iteration value :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"{{range .ShippingOptions}}\\n{{.Description}}
\\nPrice : {{.Price}} $
\\n42 {{\\\"hello !\\\"}}
\")])]),_c('p',[_vm._v(\"Will output : “42 hello !”. But :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"42 {{- \\\"hello !\\\"}}
\")])]),_c('p',[_vm._v(\"Will output “42hello !”\")]),_c('div',{staticClass:\"anchor\",attrs:{\"id\":\"print-dates\"}}),_c('h1',{attrs:{\"data-number\":\"10\"}},[_c('span',{staticClass:\"header-section-number\"},[_vm._v(\"10\")]),_vm._v(\" Print dates \"),_c('a',{attrs:{\"href\":\"#print-dates\"}},[_c('b-icon-link45deg',{staticClass:\"heading-link-icon\",attrs:{\"font-scale\":\"0.7\"}})],1)]),_c('p',[_vm._v(\"Dates are very common on web pages. You can pass a \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"time.Time\")])]),_vm._v(\" value to a template. Let’s add the field \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"ShippingDate\")])]),_vm._v(\" to our type struct :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"type Product struct {\\n Name string\\n Price string\\n Description string\\n ShippingDate time.Time\\n}\")])]),_c('p',[_vm._v(\"Next, we add it to the \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"teaPot\")])]),_vm._v(\" variable :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"teaPot := Product{Name: \\\"Red Tea Pot 250ml\\\", Description: \\\"Test\\\", Price: \\\"19.99\\\", ShippingDate: time.Now()}\")])]),_c('p',[_vm._v(\"We can use it in our template with the following syntax :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"Shipping Date : {{.ShippingDate}}
\")])]),_c('p',[_vm._v(\"But when the template got executed, the following string appears :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"Shipping Date : 2018-12-20 13:00:02.338064 +0100 CET m=+20.349586416\")])]),_c('p',[_vm._v(\"This is not a very user-friendly way of format a date! With templates you can call the \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"Format\")])]),_vm._v(\" method :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"Shipping Date : {{.ShippingDate.Format \\\"2006-01-02\\\"}}
\")])]),_c('p',[_vm._v(\"This action will output the following line :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"Shipping Date: 2018-12-20\")])]),_c('p',[_vm._v(\"Here \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"\\\"2006-01-02\\\"\")])]),_vm._v(\" is the date layout. You can adapt it for your needs.\")]),_c('div',{staticClass:\"anchor\",attrs:{\"id\":\"nested-templates\"}}),_c('h1',{attrs:{\"data-number\":\"11\"}},[_c('span',{staticClass:\"header-section-number\"},[_vm._v(\"11\")]),_vm._v(\" Nested templates \"),_c('a',{attrs:{\"href\":\"#nested-templates\"}},[_c('b-icon-link45deg',{staticClass:\"heading-link-icon\",attrs:{\"font-scale\":\"0.7\"}})],1)]),_c('p',[_vm._v(\"If your site has more than 1 page, you might consider using nested templates. Why? To avoid repeating yourself when coding templates. For instance, on each page of your website, you will have (practically) the same header, the same footer, the same navbar.\")]),_c('p',[_vm._v(\"If you choose to copy-paste the code of the navbar on each page of the site you miss one of the most interesting features of a templating engine : nested templates (also called “partials” on some publications).\")]),_c('div',{staticClass:\"anchor\",attrs:{\"id\":\"define-a-template\"}}),_c('h4',{attrs:{\"data-number\":\"11.0.0.1\"}},[_c('span',{staticClass:\"header-section-number\"},[_vm._v(\"11.0.0.1\")]),_vm._v(\" Define a template \"),_c('a',{attrs:{\"href\":\"#define-a-template\"}},[_c('b-icon-link45deg',{staticClass:\"heading-link-icon\",attrs:{\"font-scale\":\"0.7\"}})],1)]),_c('p',[_vm._v(\"It is possible to load a template into another template with a specific syntax. Let’s define two templates: the footer template and the header template. The first defines the header of the HTML page, with the head tag, its title, and the opening body tag :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"// views/header.html\\n{{ define \\\"header\\\" }}\\n \\n \\n \\n{{.Description}}
\\nPrice : {{.Price}} $
\\nShipping Date : {{.ShippingDate.Format \\\"2006-01-02\\\"}}
\\n{{ $var2 }}
\")])]),_c('p',[_vm._v(\"Here we define the variable \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"$var2\")])]),_vm._v(\" “inside” an if statement. The variable \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"$var2\")])]),_vm._v(\" only exists in the scope of the if statement. After the \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"{{end}}\")])]),_vm._v(\" the variable cannot be used.\")]),_c('div',{staticClass:\"anchor\",attrs:{\"id\":\"call-a-method\"}}),_c('h1',{attrs:{\"data-number\":\"13\"}},[_c('span',{staticClass:\"header-section-number\"},[_vm._v(\"13\")]),_vm._v(\" Call a method \"),_c('a',{attrs:{\"href\":\"#call-a-method\"}},[_c('b-icon-link45deg',{staticClass:\"heading-link-icon\",attrs:{\"font-scale\":\"0.7\"}})],1)]),_c('p',[_vm._v(\"We can call methods into templates. Not all methods can be called :\")]),_c('ul',[_c('li',[_c('p',[_vm._v(\"The method should have only \"),_c('strong',[_vm._v(\"one\")]),_vm._v(\" or \"),_c('strong',[_vm._v(\"two\")]),_vm._v(\" return values\")]),_c('ul',[_c('li',[_c('strong',[_vm._v(\"If two\")]),_vm._v(\" values are returned, the \"),_c('strong',[_vm._v(\"second\")]),_vm._v(\" one must be of type \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"error\")])]),_vm._v(\".\")])])])]),_c('p',[_vm._v(\"Let’s take an example. We will define the methods \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"Foo\")])]),_vm._v(\" and \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"Bar\")])]),_vm._v(\" with a \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"Product\")])]),_vm._v(\" receiver :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"// template/method-call/main.go \\n//...\\n\\ntype Product struct {\\n //...\\n}\\n\\nfunc (p Product) Foo() string {\\n return \\\"FOO\\\"\\n}\\n\\nfunc (p Product) Bar(test string) string {\\n return fmt.Sprintf(\\\"Bar : %s\\\", test)\\n}\")])]),_c('p',[_vm._v(\"Then you can call the \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"Foo\")])]),_vm._v(\" function this way :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"{{.Foo}}
\\n{{.Bar \\\"lol\\\"}}
\")])]),_c('p',[_vm._v(\"When the template is executed, it will output :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"FOO
\\nBar : lol
\")])]),_c('div',{staticClass:\"anchor\",attrs:{\"id\":\"predefined-global-functions\"}}),_c('h1',{attrs:{\"data-number\":\"14\"}},[_c('span',{staticClass:\"header-section-number\"},[_vm._v(\"14\")]),_vm._v(\" Predefined global functions \"),_c('a',{attrs:{\"href\":\"#predefined-global-functions\"}},[_c('b-icon-link45deg',{staticClass:\"heading-link-icon\",attrs:{\"font-scale\":\"0.7\"}})],1)]),_c('p',[_vm._v(\"The template engine has builtin functions that we can use:\")]),_c('div',{staticClass:\"list\"},[_c('p',[_vm._v(\"This is a variadic function. It will check the “boolean” value of each argument. When it encounters a false, it will return it directly. When all arguments are true, the function will return the last argument.\")])]),_c('div',{staticClass:\"anchor\",attrs:{\"id\":\"the-definition-of-true\"}}),_c('h4',{attrs:{\"data-number\":\"14.0.0.1\"}},[_c('span',{staticClass:\"header-section-number\"},[_vm._v(\"14.0.0.1\")]),_vm._v(\" The definition of true \"),_c('a',{attrs:{\"href\":\"#the-definition-of-true\"}},[_c('b-icon-link45deg',{staticClass:\"heading-link-icon\",attrs:{\"font-scale\":\"0.7\"}})],1)]),_c('p',[_vm._v(\"The answer is not obvious. The function \"),_c('strong',[_vm._v(\"and\")]),_vm._v(\" for instance, will check the boolean value of each of its argument.\"),_c('strong',[_c('u',[_vm._v(\"True\")])]),_vm._v(\" means :\")]),_c('ul',[_c('li',[_c('p',[_vm._v(\"An \"),_c('strong',[_vm._v(\"Array\")]),_vm._v(\", a \"),_c('strong',[_vm._v(\"Map\")]),_vm._v(\", a \"),_c('strong',[_vm._v(\"Slice\")]),_vm._v(\" a \"),_c('strong',[_vm._v(\"String\")]),_vm._v(\" \"),_c('strong',[_c('u',[_vm._v(\"not empty\")])]),_vm._v(\" (length > 0)\")])]),_c('li',[_c('p',[_vm._v(\"A \"),_c('strong',[_vm._v(\"complex\")]),_vm._v(\" number \"),_c('strong',[_c('u',[_vm._v(\"not equal to 0\")])])])]),_c('li',[_c('p',[_vm._v(\"A \"),_c('strong',[_vm._v(\"function\")]),_vm._v(\", a \"),_c('strong',[_vm._v(\"channel\")]),_vm._v(\", a \"),_c('strong',[_vm._v(\"pointer\")]),_vm._v(\", an \"),_c('strong',[_vm._v(\"interface\")]),_vm._v(\" that is \"),_c('strong',[_vm._v(\"not nil\")])])]),_c('li',[_c('p',[_vm._v(\"An integer (signed or unsigned) that is \"),_c('strong',[_c('u',[_vm._v(\"not equal to 0.\")])])])]),_c('li',[_c('p',[_vm._v(\"A float \"),_c('strong',[_c('u',[_vm._v(\"not equal to 0\")])])])]),_c('li',[_c('p',[_vm._v(\"A struct (struct are always true)\")])])]),_c('div',{staticClass:\"anchor\",attrs:{\"id\":\"example\"}}),_c('h4',{attrs:{\"data-number\":\"14.0.0.2\"}},[_c('span',{staticClass:\"header-section-number\"},[_vm._v(\"14.0.0.2\")]),_vm._v(\" Example: \"),_c('a',{attrs:{\"href\":\"#example\"}},[_c('b-icon-link45deg',{staticClass:\"heading-link-icon\",attrs:{\"font-scale\":\"0.7\"}})],1)]),_c('p',[_vm._v(\"Let’s add the property \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"Sale\")])]),_vm._v(\" (bool) and \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"SaleImagePath\")])]),_vm._v(\" (slice of strings) to the data struct type (\"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"Product\")])]),_vm._v(\"). The idea is to add an image to the page if the product is on sale and if we have at least an image to display.\")]),_c('p',[_vm._v(\"We will initialize the value of the property \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"Sale\")])]),_vm._v(\" to true and the property \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"SaleImagePath\")])]),_vm._v(\" with a slice of strings containing one string. The function call :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"and .Sale .SaleImagePath\")])]),_c('p',[_vm._v(\"Will return \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\".SaleImagePath\")])]),_vm._v(\" because :\")]),_c('ul',[_c('li',[_c('p',[_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\".Sale\")])]),_vm._v(\" is \"),_c('strong',[_vm._v(\"true\")])])]),_c('li',[_c('p',[_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\".SaleImagePath\")])]),_vm._v(\" is \"),_c('strong',[_vm._v(\"not an empty slice\")]),_vm._v(\".\")])])]),_c('p',[_vm._v(\"We can use \"),_c('strong',[_vm._v(\"and\")]),_vm._v(\" \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\".Sale\")])]),_vm._v(\" \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\".SaleImagePath\")])]),_vm._v(\" in an if statement\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"{{ if and .Sale .SaleImagePath}}\\nMy super image
\\n \\n{{ end }}\")])]),_c('div',{staticClass:\"list\"},[_c('p',[_vm._v(\"The first argument of this function is... a function/method name. Call allows you to use a function directly inside the template. There are some limitations to the function. It must return one or two values (if two, the second argument must be an error). The function can have as many arguments as you want.\")])]),_c('p',[_vm._v(\"For example, we define the function \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"Bar\")])]),_vm._v(\" :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"// template/functions/main.go \\n\\nfunc Bar(a string, b string) string {\\n buf := bytes.NewBufferString(a)\\n buf.WriteString(b)\\n return buf.String()\\n}\")])]),_c('p',[_vm._v(\"This function concatenates to string (with a \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"bytes.Buffer\")])]),_vm._v(\"). If we want to call it inside our template, we must modify our data struct and add the function to it.\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"// template/functions/main.go \\n\\ntype Product struct {\\n //...\\n MyFunc func(string, string)string\\n}\")])]),_c('p',[_vm._v(\"We name this property \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"MyFunc\")])]),_vm._v(\". Then we create a new instance of \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"Product\")])]),_vm._v(\", and we assign to \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"MyFunc\")])]),_vm._v(\" the \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"Bar\")])]),_vm._v(\" function :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\" teaPot := Product{\\n //...\\n MyFunc:Bar}\")])]),_c('p',[_vm._v(\"Then inside the template, we can call it :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"{{call .MyFunc \\\"first\\\" \\\"second\\\"}}
\")])]),_c('p',[_vm._v(\"Which outputs :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"firstsecond
\")])]),_c('div',{staticClass:\"list\"},[_c('p',[_vm._v(\"Will return the index of an element in a map\")]),_c('p',[_vm._v(\"Allow you to escape javascript code\")]),_c('p',[_vm._v(\"Will return the length of a slice, array, map...\")]),_c('p',[_vm._v(\"Can be used to print something; the functions called behind are the ones from the fmt package (\"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"fmt.Sprint\")])]),_vm._v(\", \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"fmt.Sprintf\")])]),_vm._v(\", \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"fmt.Sprintln\")])]),_vm._v(\").\")]),_c('p',[_vm._v(\"This function takes a variable number of arguments. It will build a string from those arguments and then make a call to a function of the package url : \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"QueryEscape\")])]),_c('strong',[_vm._v(\".\")]),_vm._v(\" This function allows you to build complex query parts of URLs directly into your template\")])]),_c('p',[_vm._v(\"The complete list of builtin function can be found here:\")]),_c('ul',[_c('li',[_vm._v(\"https://golang.org/pkg/text/template/#hdr-Functions\")])]),_c('div',{staticClass:\"anchor\",attrs:{\"id\":\"custom-template-functions\"}}),_c('h1',{attrs:{\"data-number\":\"15\"}},[_c('span',{staticClass:\"header-section-number\"},[_vm._v(\"15\")]),_vm._v(\" Custom template functions \"),_c('a',{attrs:{\"href\":\"#custom-template-functions\"}},[_c('b-icon-link45deg',{staticClass:\"heading-link-icon\",attrs:{\"font-scale\":\"0.7\"}})],1)]),_c('p',[_vm._v(\"The template package provides you the ability to use custom functions inside your template. You have to create your functions first, then pass them to the template \"),_c('strong',[_vm._v(\"before\")]),_vm._v(\" parsing and execution.\")]),_c('p',[_vm._v(\"We will create a \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"template.FuncMap\")])]),_c('strong',[_vm._v(\".\")]),_vm._v(\" The type behind \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"FuncMap\")])]),_vm._v(\" is \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"map[string]interface{}\")])]),_vm._v(\" . It’s a map of strings to empty interface. Then we can add to our map the functions we want to add to the template:\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"var capitalizeFirstLetter = func(text string)string{return strings.Title(text)}\")])]),_c('p',[_vm._v(\"Here we create an anonymous function that will wrap the function \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"string.Title\")])]),_vm._v(\" (which capitalize the first letter of every word of a sentence). The function is stored into a variable named \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"capitalizeFirstLetter\")])]),_vm._v(\".\")]),_c('p',[_vm._v(\"Then we add the function to the map :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"funcs := template.FuncMap{\\\"capitalizeFirstLetter\\\": capitalizeFirstLetter}\")])]),_c('p',[_vm._v(\"The key of this map is the name that will be exposed into the template, the second argument is the function itself. We can not directly call \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"ParseFiles\")])]),_vm._v(\", because the functions have to be added to the template \"),_c('strong',[_vm._v(\"before\")]),_vm._v(\" parsing :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"// template/custom-functions/main.go \\n//...\\n\\ntmpl, err := template.New(\\\"product-dynamic.html\\\").Funcs(funcs).ParseFiles(\\\"./views/product-dynamic.html\\\")\\n// check error...\")])]),_c('p',[_vm._v(\"Then we can use the function inside the template :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"{{capitalizeFirstLetter \\\"test\\\"}}
\")])]),_c('p',[_vm._v(\"Will output :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"Test\")])]),_c('div',{staticClass:\"anchor\",attrs:{\"id\":\"conditionnals\"}}),_c('BuyCopyInvite'),_c('h1',{attrs:{\"data-number\":\"16\"}},[_c('span',{staticClass:\"header-section-number\"},[_vm._v(\"16\")]),_vm._v(\" Conditionnals \"),_c('a',{attrs:{\"href\":\"#conditionnals\"}},[_c('b-icon-link45deg',{staticClass:\"heading-link-icon\",attrs:{\"font-scale\":\"0.7\"}})],1)]),_c('p',[_vm._v(\"You can use conditional structures (if, then else).\")]),_c('p',[_vm._v(\"Let’s take an example: In our previous product example, we will add a field to the type struct Product :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"type Product struct {\\n Name string\\n Price string\\n Description string\\n ShippingDate time.Time\\n Sale bool\\n}\")])]),_c('p',[_vm._v(\"The field is named \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"Sale\")])]),_vm._v(\". It’s a boolean that will flag a product if it’s on sale. We want to display something special on our page for this occasion, but only if the product is on sale :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"{{ if .Sale }}\\nNot in sale, sorry
\\n{{ end }}\")])]),_c('p',[_vm._v(\"For more complex comparisons, you can use the eleseif action :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"{{ if .Sale }}\\n //...\\n{{ elseif .ExtraDiscount }}\\n //...\\n{{ else }}\\n //...\\n{{ end }}\")])]),_c('div',{staticClass:\"anchor\",attrs:{\"id\":\"comparison-operators\"}}),_c('h1',{attrs:{\"data-number\":\"17\"}},[_c('span',{staticClass:\"header-section-number\"},[_vm._v(\"17\")]),_vm._v(\" Comparison operators \"),_c('a',{attrs:{\"href\":\"#comparison-operators\"}},[_c('b-icon-link45deg',{staticClass:\"heading-link-icon\",attrs:{\"font-scale\":\"0.7\"}})],1)]),_c('figure',[_c('b-img',{staticClass:\"img-book\",attrs:{\"src\":require('@/assets/images/template_comparison.png'),\"alt\":\"Comparison syntax and binary operators\",\"fluid\":\"\",\"thumbnail\":\"\"}}),_c('figcaption',{attrs:{\"aria-hidden\":\"true\"}},[_vm._v(\"Comparison syntax and binary operators\")])],1),_c('p',[_vm._v(\"You can compare two variables together by using the six existing operators. The syntax is not usual for comparisons. You first specify the comparison operators, and then you specify the two operands. For instance, if you want to compare \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\".Price\")])]),_vm._v(\" and \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"100.00\")])]),_vm._v(\" together the syntax is \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"eq .Price 100.00\")])]),_vm._v(\":\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"{{ if eq .Price 100.00 }}\\nOnly 100$
\\n{{ else }}\\nGive yourself a treat
\\n{{ end }}\")])]),_c('p',[_vm._v(\"Those comparisons will return boolean values that can be used safely with conditionals statements.\")]),_c('div',{staticClass:\"anchor\",attrs:{\"id\":\"warning\"}}),_c('h4',{attrs:{\"data-number\":\"17.0.0.1\"}},[_c('span',{staticClass:\"header-section-number\"},[_vm._v(\"17.0.0.1\")]),_vm._v(\" Warning ! \"),_c('a',{attrs:{\"href\":\"#warning\"}},[_c('b-icon-link45deg',{staticClass:\"heading-link-icon\",attrs:{\"font-scale\":\"0.7\"}})],1)]),_c('ul',[_c('li',[_vm._v(\"It’s better to compare variables that have only the same type. The package allows comparing variables that have not the same type. I do not recommend that because it can lead to errors :\")])]),_c('p',[_vm._v(\"Let’s take a concrete example : \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\".Price\")])]),_vm._v(\" is of type \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"float64\")])]),_vm._v(\" (defined in our data struct), \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"100\")])]),_vm._v(\" is parsed as an integer. The two types are not the same. The result of the comparison is false (event if \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\".Price\")])]),_vm._v(\" has the value one hundred). The text \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"Only 100$ it's a deal!
\")])]),_vm._v(\"* will not appear on the HTML page when the template will execute.\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"{{ if eq .Price 100 }}\\nOnly 100$ it's a deal!
\\n{{ end }}\")])]),_c('ul',[_c('li',[_c('p',[_vm._v(\"The comparison operands may have the following types :\")]),_c('ul',[_c('li',[_c('p',[_vm._v(\"bool\")])]),_c('li',[_c('p',[_vm._v(\"int, int8, int16, int64\")])]),_c('li',[_c('p',[_vm._v(\"uint, uint8, uint16, uint64\")])]),_c('li',[_c('p',[_vm._v(\"uintptr\")])]),_c('li',[_c('p',[_vm._v(\"float32, float64\")])]),_c('li',[_c('p',[_vm._v(\"complex64, complex128\")])]),_c('li',[_c('p',[_vm._v(\"string\")])])])]),_c('li',[_c('p',[_vm._v(\"We can use named types in comparisons.\")])])]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"type LogLevel int\")])]),_c('p',[_vm._v(\"You can define a variable of type \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"LogLevel\")])]),_vm._v(\" and use it in your template to make comparisons\")]),_c('div',{staticClass:\"anchor\",attrs:{\"id\":\"iteration\"}}),_c('h1',{attrs:{\"data-number\":\"18\"}},[_c('span',{staticClass:\"header-section-number\"},[_vm._v(\"18\")]),_vm._v(\" Iteration \"),_c('a',{attrs:{\"href\":\"#iteration\"}},[_c('b-icon-link45deg',{staticClass:\"heading-link-icon\",attrs:{\"font-scale\":\"0.7\"}})],1)]),_c('p',[_vm._v(\"Comments, reviews, delivery options... etc. Data to display in a template often comes in the form of lists. The Go template engine has actions dedicated to iteration.\")]),_c('p',[_vm._v(\"For instance, let’s add the property \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"ShippingOptions\")])]),_vm._v(\" to our \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"Product\")])]),_vm._v(\" type struct (the data that we will pass to the template) :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"// template/iteration/main.go \\n\\n//...\\n\\ntype Product struct {\\n //...\\n ShippingOptions []string\\n}\\n//...\\nteaPot := Product{\\n //...\\n ShippingOptions: []string{\\\"Extra Priority\\\", \\\"Normal\\\", \\\"Low Priority\\\"}}\\nerr = tmpl.Execute(w, teaPot)\")])]),_c('p',[_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"ShippingOptions\")])]),_vm._v(\" is a slice of strings. Then in our template, we can iterate through this slice with the \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"range\")])]),_vm._v(\" action :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"// template\\nFirst delivery option is {{ $firstDelOpt }}
\")])]),_c('p',[_vm._v(\"The value of \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\".ShippingOptions[0]\")])]),_vm._v(\". is assigned to the variable \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"$firstDelOpt\")])]),_vm._v(\". We can then use this variable in the rest of the template.\")]),_c('p',[_vm._v(\"This template will output :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"First delivery option is Extra Priority
\")])]),_c('p',[_vm._v(\"We can use the index function with multi-dimensional slices. Let’s add a property \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"Notes\")])]),_vm._v(\" (a two-dimensional slice) to our type struct \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"Product\")])]),_vm._v(\" :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"type Product struct {\\n //..\\n Notes [][]int\\n}\")])]),_c('p',[_vm._v(\"This 2D slice represents the notes of users for a product. Each row represent a notation, each column represents the note for a criterion :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"notes := [][]int{}\\nnote1 := []int{1, 2, 3}\\nnote2 := []int{4, 5, 6}\\nnotes = append(notes, note1)\\nnotes = append(notes, note2)\")])]),_c('p',[_vm._v(\"Here we have two notes (\"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"note1\")])]),_vm._v(\" and \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"note2\")])]),_vm._v(\") with three criteria each. To retrieve the second criterion of the first note inside our template we can use the \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"index\")])]),_vm._v(\" function like this :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"{{ $note := index .Notes 0 1}}\\nFirst note, second criterion : {{$note}}
\")])]),_c('p',[_vm._v(\"Here we provide three arguments to index; the first one is our 2D slice the two others are the indices. Here the value of \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\".Notes[0][1]\")])]),_vm._v(\" is retrieved (the first element of a slice is at index 0, then second at index 1).\")]),_c('div',{staticClass:\"anchor\",attrs:{\"id\":\"embed-template-files-into-the-go-binary\"}}),_c('BuyCopyInvite'),_c('h1',{attrs:{\"data-number\":\"20\"}},[_c('span',{staticClass:\"header-section-number\"},[_vm._v(\"20\")]),_vm._v(\" Embed template files into the Go Binary \"),_c('a',{attrs:{\"href\":\"#embed-template-files-into-the-go-binary\"}},[_c('b-icon-link45deg',{staticClass:\"heading-link-icon\",attrs:{\"font-scale\":\"0.7\"}})],1)]),_c('p',[_vm._v(\"Go 1.16 introduce a new standard package named \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"embed\")])]),_vm._v(\". With this package, you can include in your program binary your template files (or other files).\")]),_c('p',[_vm._v(\"Let’s say that your template files are located in a views dir. You can embed all files located into the views directory with the \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"//go:embed views/*\")])]),_vm._v(\" directive.\")]),_c('p',[_vm._v(\"When the program is compiled, Go will populate \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"views\")])]),_vm._v(\" with all files located into the \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"views\")])]),_vm._v(\" directory.\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"// template/basic-embed/main.go \\npackage main\\n\\nimport (\\n \\\"embed\\\"\\n \\\"html/template\\\"\\n \\\"net/http\\\"\\n \\\"time\\\"\\n)\\n\\n//go:embed views/*\\nvar views embed.FS\\n\\nfunc main {\\n tmpl, err := template.ParseFS(views, \\\"views/product.html\\\")\\n if err != nil {\\n http.Error(w, \\\"Something went wrong\\\", http.StatusInternalServerError)\\n return\\n }\\n // use the template\\n}\")])]),_c('p',[_vm._v(\"Then you can use the function \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"template.ParseFS\")])]),_vm._v(\" to load and parse your template files.\")]),_c('div',{staticClass:\"anchor\",attrs:{\"id\":\"debugging-a-template\"}}),_c('h1',{attrs:{\"data-number\":\"21\"}},[_c('span',{staticClass:\"header-section-number\"},[_vm._v(\"21\")]),_vm._v(\" Debugging a template \"),_c('a',{attrs:{\"href\":\"#debugging-a-template\"}},[_c('b-icon-link45deg',{staticClass:\"heading-link-icon\",attrs:{\"font-scale\":\"0.7\"}})],1)]),_c('p',[_vm._v(\"During the development phase, you can use this technique to improve your productivity :\")]),_c('p',[_vm._v(\"Inside the template, add this line :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"{{ printf \\\"%#v\\\" . }}\")])]),_c('p',[_vm._v(\"This will output (in a human-readable mode) the properties keys and values passed to the template engine. Here is an example :\")]),_c('pre',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\"}},[_vm._v(\"main.Product{Name:\\\"Red Tea Pot 250ml\\\", Price:\\\"19.99\\\", Description:\\\"Test\\\", ShippingDate:time.Time{wall:0xbeffc6aedb25e3e0, ext:18903963863, loc:(*time.Location)(0x164dd40)}, Sale:true, SaleImagePath:[]string{\\\"img.jpg\\\"}}\")])]),_c('div',{staticClass:\"anchor\",attrs:{\"id\":\"test-yourself\"}}),_c('h1',{attrs:{\"data-number\":\"22\"}},[_c('span',{staticClass:\"header-section-number\"},[_vm._v(\"22\")]),_vm._v(\" Test yourself \"),_c('a',{attrs:{\"href\":\"#test-yourself\"}},[_c('b-icon-link45deg',{staticClass:\"heading-link-icon\",attrs:{\"font-scale\":\"0.7\"}})],1)]),_c('div',{staticClass:\"anchor\",attrs:{\"id\":\"questions\"}}),_c('h2',{attrs:{\"data-number\":\"22.1\"}},[_c('span',{staticClass:\"header-section-number\"},[_vm._v(\"22.1\")]),_vm._v(\" Questions \"),_c('a',{attrs:{\"href\":\"#questions\"}},[_c('b-icon-link45deg',{staticClass:\"heading-link-icon\",attrs:{\"font-scale\":\"0.7\"}})],1)]),_c('ol',{attrs:{\"type\":\"1\"}},[_c('li',[_c('p',[_vm._v(\"When you iterate over a slice with \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"range\")])]),_vm._v(\" how to print the slice elements values?\")])]),_c('li',[_c('p',[_vm._v(\"True or False. To generate web pages templates, you can use the two following packages: \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"text/template\")])]),_vm._v(\" and \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"html/template\")])]),_vm._v(\".\")])]),_c('li',[_c('p',[_vm._v(\"How to load a template stored on a file?\")])]),_c('li',[_c('p',[_vm._v(\"How to load a template stored inside a variable?\")])]),_c('li',[_c('p',[_vm._v(\"How to print a date into a template with the format -01-02?\")])]),_c('li',[_c('p',[_vm._v(\"How to inject a template into another template?\")])]),_c('li',[_c('p',[_vm._v(\"How to embed templates file in your Go binary?\")])])]),_c('div',{staticClass:\"anchor\",attrs:{\"id\":\"answers\"}}),_c('h2',{attrs:{\"data-number\":\"22.2\"}},[_c('span',{staticClass:\"header-section-number\"},[_vm._v(\"22.2\")]),_vm._v(\" Answers \"),_c('a',{attrs:{\"href\":\"#answers\"}},[_c('b-icon-link45deg',{staticClass:\"heading-link-icon\",attrs:{\"font-scale\":\"0.7\"}})],1)]),_c('ol',{attrs:{\"type\":\"1\"}},[_c('li',[_c('p',[_vm._v(\"When you iterate over a slice with a range, how to print the slice elements values?\")]),_c('ol',{attrs:{\"type\":\"1\"}},[_c('li',[_c('p',[_vm._v(\"With \"),_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"{{ . }}\")])])])]),_c('li',[_c('p',[_c('span',{directives:[{name:\"highlightjs\",rawName:\"v-highlightjs\"}]},[_c('code',{pre:true,attrs:{\"class\":\"go\",\"style\":\"display: inline\"}},[_vm._v(\"{{range .ShippingOptions}}What is a template?
How to create a template.
How to inject dynamic data into templates.
How to print items from a collection (slice, array, map).
How to embed a template file into your Go binary.
template
nesting / nested
binary
A template is the skeleton of a web page. It defines its layout and where dynamic data will be injected when a user sends a request to the web server.
\nTo better understand this definition, we will take the example of an e-commerce website. As a developer, you are instructed to create product pages. The website has only three products to show. That’s pretty easy; you will create three pages (with HTML and CSS) to present the products. You will ask the marketing team to produce the commercial texts and give you pictures of the products. This task will not take you long days to perform.
\nImagine now that the marketing guy comes to you ten months later and announces that they will introduce 100 new products to the catalog. You are asked to develop the pages for the products.
\nYou have two options :
\nYou code manually 100 pages
You use some kind of automatism
The first solution will take a lot of time for you and the whole team, whereas the second solution seems smarter.
\nThe idea is to develop just one product page. For the product name, you will put a placeholder, for the description another one, and for the price another one. Then this idea is to inject product data into the right placeholders dynamically.
\nA template represents the model of some kind of page (for instance, the product page) or part of a web page (the navigation bar). Data are injected into a template into placeholders. The underlying data often comes from the application’s persistence layer (a database, a cache system...). This data is structured to be used easily in the template.
\nYou can also use templates to generate emails, pdfs, or other documents. In this chapter, we will focus on the web use case.
\n\nIt allows you to gain considerable time when you develop a website. You do not have to repeat yourself.
The designers are often taught in school to create and maintain templates. Many templating engines exist (for each language) with their specialties, but they share common features that are easy to understand.
Designers and programmers can work independently after they have specified the data structure passed to the template.
Go has two main packages for handling templating :
\ntext/template
html/template
The first one can be used for text output when there is no injection risk. You can use the second one for formatting HTML pages. In the second one, Go provides a protection mechanism against bad users that will inject code into their input to attack your website.
\nIf you plan to generate HTML, you should use the html/template package an NOT the text/template !
Note also that you should always validate data injected into templates. You should never trust data generated by users.
\n\nIn the next section, we will take the example of an e-commerce website with a database of thousands of products.
\nThe first thing to do is to create the template. Firstly, we will look at a standard HTML page for a product page.
\n\n<!--views/product.html-->\n<!DOCTYPE html>\n<html>\n<head>\n <title>Red Tea Pot 250ml</title>\n</head>\n<body>\n <h1>Red Tea Pot 250ml</h1>\n <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. </p>\n <p>Price : <strong>23.99</strong> $</p>\n <h2>Delivery options</h2>\n <ul>\n <li>Express + 2$ </li>\n <li>Ultra Express + 5$</li>\n <li>Normal</li>\n </ul>\n <h3>This was a {{.}}</h3>\n</body>\n\n</html>This page contains details about our product. We have the product name, description, price, and delivery options. We will store this file in the directory “views”. This name is common in the web industry (it makes an implicit reference to the MVC model: Model View Controller).
\nTake a close look at the line :
\n<h3>This was a {{.}}</h3>The notation you see (the double curly braces) refers to a template variable. We will see in the next sect how go handles it.
\n\nLet’s create the web server of our website :
\n// template/basic/main.go \n\nfunc main() {\n http.HandleFunc("/red-tea-pot", redTeaPotHandler)\n if err := http.ListenAndServe("localhost:8080", nil); err != nil {\n panic(err)\n }\n}We will listen to incoming connexions on the localhost on port 8080.
\n\nIf we receive a request to the route /red-tea-pot the redTeaPotHandler function will be launched :
// template/basic/main.go \nfunc redTeaPotHandler(w http.ResponseWriter, r *http.Request) {\n tmpl, err := template.ParseFiles("./views/product.html")\n if err != nil{\n http.Error(w, "Something went wrong", http.StatusInternalServerError)\n return\n }\n\n err = tmpl.Execute(w, "test")\n // handle error\n}We have defined a request handler for our server in the last code snippet. It takes as argument a http.ResponseWriter and a pointer to a http.Request.
It’s a classical HTTP handler. If you want to get more information about how to create a web server take a look at the dedicated chapter ([chap:Basic-HTTP-Server]).
\n\nThe first operation to do is to load the template file and parse it. For this operation, we will use the function template.ParseFiles. This function can take as argument more than one file path. In the example, we only take a single file path \"./views/product.html\". The method returns a pointer to a variable of type template.Template.
For each of the file paths in arguments, the function template.ParseFiles will :
Load the file from the filesystem (it uses ioutil.ReadFile)
Generate the name of the template based on the last element of its path. In our case, the name will be “product.html”
Allocate the new HTML Template
The template will then be parsed
Then once we have loaded and parsed our template, we will call the methodExecute. It takes to arguments an io.Writer and a second one which represents the data to inject into the template.
We have nothing to inject in our example because our template is not dynamic; every element is fixed.
\n\nIn a template, you can add “actions” that will indicate to the system to do something. The official definition of actions are “data evaluations or control structures”.
\nAll actions are delimited by double curly braces.
\nLet’s take an example of the simplest action inside a template:
\n<h3>This was a {{.}}</h3>Here we are asking the templating engine to print the value of the second argument of the template.Execute method. {{ . }} is a template directive. The template engine defines a pseudo-scripting language. You will see that this scripting language is very close to Go.
The dot sign represents the data passed to the template. To access a property, you just have to write a dot then the property’s name. For instance, if I want to access to the property Price from the data passed to the template, I use the following syntax :
{{.Price}}In this configuration with the dot notation, we are using the global context. This is not always true. When you use the dot inside an iteration, the dot do NOT represent the global context, but the iteration context. Let’s take an example you will understand immediately.
\nIf you have defined the property Price, you can access it from everywhere in the template like this :
\n<p>{{ .Price }}</p>\n<<!-- Equivalent notation -->\n<p>{{ $.Price }}</p>We have two notations .Price and $.Price point to the same value. The dot gives you access to the global data context of the template.
Inside an iteration, the dot is equal to the current iteration value :
\n{{range .ShippingOptions}}\n <li>{{ . }}</li>\n{{end}}Here the dot is equal for the first iteration to \"Extra Priority\" then to \"Normal\" and finally to \"Low Priority\". The template engine will output :
<li>Extra Priority</li>\n<li>Normal</li>\n<li>Low Priority</li>But what if you want to access the property Price (which is in the global context)? With the $ sign you can access the global context
{{range .ShippingOptions}}\n <li>Product Price : {{ $.Price}} : {{ . }}</li>\n{{end}}The previous template will output :
\n<li>Product Price : 100 : Extra Priority</li>\n<li>Product Price : 100 : Normal</li>\n<li>Product Price : 100 : Low Priority</li>This is the main usage of a template. The backend gives you a dataset, and you have to inject it into an HTML file.
\nThe first thing to do is to define a type struct that will structure the data :
\ntype Product struct {\n Name string\n Price string\n Description string\n}We have a very simple type struct with three text fields. Then we create a variable of this type :
\nteaPot := Product{Name: "Red Tea Pot 250ml", Description: "Test", Price: "19.99"}The variable teaPot contains all the data necessary to fill a product page :
<!DOCTYPE html>\n<html>\n<head>\n <title>{{.Name}}</title>\n</head>\n<body>\n<h1>{{.Name}}</h1>\n<p>{{.Description}}</p>\n<p>Price : <strong>{{.Price}}</strong> $</p>\n<h2>Delivery options</h2>\n<ul>\n <li>Express + 2$ </li>\n <li>Ultra Express + 5$</li>\n <li>Normal</li>\n</ul>\n</body>\n\n</html>Note that each action begins with a point \".\". We will inject the property Name into the HTML tag title.Name is also injected into the tag h1.
To inject the value of the property Foo we just have to use the following action :
{{.Foo}}Once our view and the data variable are ready, we just have to pass them to the Execute method :
\nerr = tmpl.Execute(w, teaPot)You can see the template execution result in the figure 1.
\nIf you want to remove white spaces (space, horizontal tab, carriage return, and newline) in the test that exactly precede your template directive, you can use the syntax :
\n{{- .MyVar}}To remove white spaces in what follows your directive, use this syntax :
\n{{.MyVar -}}Note that it will not trim the variable MyVar but the text surrounding the action.
\nLet’s take an example :
\n<p>42 {{"hello !"}}</p>Will output : “42 hello !”. But :
\n<p>42 {{- "hello !"}}</p>Will output “42hello !”
\n\nDates are very common on web pages. You can pass a time.Time value to a template. Let’s add the field ShippingDate to our type struct :
type Product struct {\n Name string\n Price string\n Description string\n ShippingDate time.Time\n}Next, we add it to the teaPot variable :
teaPot := Product{Name: "Red Tea Pot 250ml", Description: "Test", Price: "19.99", ShippingDate: time.Now()}We can use it in our template with the following syntax :
\n<p>Shipping Date : {{.ShippingDate}}</p>But when the template got executed, the following string appears :
\nShipping Date : 2018-12-20 13:00:02.338064 +0100 CET m=+20.349586416This is not a very user-friendly way of format a date! With templates you can call the Format method :
<p>Shipping Date : {{.ShippingDate.Format "2006-01-02"}}</p>This action will output the following line :
\nShipping Date: 2018-12-20Here \"2006-01-02\" is the date layout. You can adapt it for your needs.
If your site has more than 1 page, you might consider using nested templates. Why? To avoid repeating yourself when coding templates. For instance, on each page of your website, you will have (practically) the same header, the same footer, the same navbar.
\nIf you choose to copy-paste the code of the navbar on each page of the site you miss one of the most interesting features of a templating engine : nested templates (also called “partials” on some publications).
\n\nIt is possible to load a template into another template with a specific syntax. Let’s define two templates: the footer template and the header template. The first defines the header of the HTML page, with the head tag, its title, and the opening body tag :
\n// views/header.html\n{{ define "header" }}\n <!DOCTYPE html>\n <html>\n <head>\n <title>{{ .PageTitle }}</title>\n </head>\n <body>\n{{ end }}The footer template is closing the body tag and closing the HTML tag :
{{ define "footer" }}\n </body>\n </html>\n{{end}}Note that we used a new action : define. With it, you can define the contents of a named template :
{{ define "X" }}\n <!--Content of the template named X -->\n{{ end }}Once we have defined the header and footer, it’s time to call them into our main template. As you can see in figure 2 the page comprises three sections: the header section, the product section , and the footer section.
\n// views/product.html\n{{ template "header" . }}\n<h1>{{.Name}}</h1>\n<p>{{.Description}}</p>\n<p>Price : <strong>{{.Price}}</strong> $</p>\n<p>Shipping Date : {{.ShippingDate.Format "2006-01-02"}}</p>\n<h2>Delivery options</h2>\n<ul>\n <li>Express + 2$ </li>\n <li>Ultra Express + 5$</li>\n <li>Normal</li>\n</ul>\n{{ template "footer" . }}To call a specific template (by its name), we are using the following action syntax :
\n{{ template "header" . }}Where we are calling the template named \"header\" and we are giving it the dot context. This way the “header” template can have access to all variables that are defined in this context. The product page is defined afterward. At the end of the page, we are calling the “footer” template with a similar syntax.
In the backend, do not forget to load and parse the three templates to make this works :
\n// template/nested/main.go \n// ...\n\ntmpl, err := template.ParseFiles("./views/product.html","./views/header.html","./views/footer.html")Note that here we are loading the product template first. If you load one of the two others first, you will end up will a blank page if you use the following syntax into your handler :
\nerr = tmpl.Execute(w, teaPot)If you want to specify which template to execute (to avoid the blank page error), use this syntax instead :
\nerr = tmpl.ExecuteTemplate(w,"product.html", teaPot)Here we are telling go to execute the template named \"product.html\" (the default name of a template is the last part of its path).
Sometimes it’s useful to store something in a variable for future use. Variable names start with the dollar sign \"$\". You can use the short assignment statement to create a variable :
{{ $myVar := .Name }}In the previous code snippet, we created the variable $myVar and assigned to it the value contained in .Name. The left part of the assignment can be more complex. In the official documentation, we name the left part of the assignment a “pipeline”.
You can change the value of an existing variable using the following syntax :
\n{{ $myVar = .Price }}Here we are assigning to $myVar a float value.
\n\nAny variable is defined inside a scope. The scope represents the lifetime of a variable. When the scope ends, the variable no longer exists.
\nBy default, a variable is defined inside the scope of the template.
If you define a variable inside a complex structure (for instance, an if statement) then the variable exists only inside the scope of that structure :
{{ if .Price}}\n {{ $var2 := .Name}}\n // $var2 exists\n{{ end}}\n// $var2 no longer exists\n<p>{{ $var2 }}</p>Here we define the variable $var2 “inside” an if statement. The variable $var2 only exists in the scope of the if statement. After the {{end}} the variable cannot be used.
We can call methods into templates. Not all methods can be called :
\nThe method should have only one or two return values
\nerror.Let’s take an example. We will define the methods Foo and Bar with a Product receiver :
// template/method-call/main.go \n//...\n\ntype Product struct {\n //...\n}\n\nfunc (p Product) Foo() string {\n return "FOO"\n}\n\nfunc (p Product) Bar(test string) string {\n return fmt.Sprintf("Bar : %s", test)\n}Then you can call the Foo function this way :
<p>{{.Foo}}</p>\n<p>{{.Bar "lol"}}</p>When the template is executed, it will output :
\n<p>FOO</p>\n<p>Bar : lol</p>The template engine has builtin functions that we can use:
\nThis is a variadic function. It will check the “boolean” value of each argument. When it encounters a false, it will return it directly. When all arguments are true, the function will return the last argument.
\nThe answer is not obvious. The function and for instance, will check the boolean value of each of its argument.True means :
\nAn Array, a Map, a Slice a String not empty (length > 0)
A complex number not equal to 0
A function, a channel, a pointer, an interface that is not nil
An integer (signed or unsigned) that is not equal to 0.
A float not equal to 0
A struct (struct are always true)
Let’s add the property Sale (bool) and SaleImagePath (slice of strings) to the data struct type (Product). The idea is to add an image to the page if the product is on sale and if we have at least an image to display.
We will initialize the value of the property Sale to true and the property SaleImagePath with a slice of strings containing one string. The function call :
and .Sale .SaleImagePathWill return .SaleImagePath because :
.Sale is true
.SaleImagePath is not an empty slice.
We can use and .Sale .SaleImagePath in an if statement
{{ if and .Sale .SaleImagePath}}\n <p>My super image</p>\n <!--Add image here-->\n{{ end }}The first argument of this function is... a function/method name. Call allows you to use a function directly inside the template. There are some limitations to the function. It must return one or two values (if two, the second argument must be an error). The function can have as many arguments as you want.
\nFor example, we define the function Bar :
// template/functions/main.go \n\nfunc Bar(a string, b string) string {\n buf := bytes.NewBufferString(a)\n buf.WriteString(b)\n return buf.String()\n}This function concatenates to string (with a bytes.Buffer). If we want to call it inside our template, we must modify our data struct and add the function to it.
// template/functions/main.go \n\ntype Product struct {\n //...\n MyFunc func(string, string)string\n}We name this property MyFunc. Then we create a new instance of Product, and we assign to MyFunc the Bar function :
teaPot := Product{\n //...\n MyFunc:Bar}Then inside the template, we can call it :
\n<p>{{call .MyFunc "first" "second"}}</p>Which outputs :
\n<p>firstsecond</p>Will return the index of an element in a map
\nAllow you to escape javascript code
\nWill return the length of a slice, array, map...
\nCan be used to print something; the functions called behind are the ones from the fmt package (fmt.Sprint, fmt.Sprintf, fmt.Sprintln).
This function takes a variable number of arguments. It will build a string from those arguments and then make a call to a function of the package url : QueryEscape. This function allows you to build complex query parts of URLs directly into your template
The complete list of builtin function can be found here:
\nThe template package provides you the ability to use custom functions inside your template. You have to create your functions first, then pass them to the template before parsing and execution.
\nWe will create a template.FuncMap. The type behind FuncMap is map[string]interface{} . It’s a map of strings to empty interface. Then we can add to our map the functions we want to add to the template:
var capitalizeFirstLetter = func(text string)string{return strings.Title(text)}Here we create an anonymous function that will wrap the function string.Title (which capitalize the first letter of every word of a sentence). The function is stored into a variable named capitalizeFirstLetter.
Then we add the function to the map :
\nfuncs := template.FuncMap{"capitalizeFirstLetter": capitalizeFirstLetter}The key of this map is the name that will be exposed into the template, the second argument is the function itself. We can not directly call ParseFiles, because the functions have to be added to the template before parsing :
// template/custom-functions/main.go \n//...\n\ntmpl, err := template.New("product-dynamic.html").Funcs(funcs).ParseFiles("./views/product-dynamic.html")\n// check error...Then we can use the function inside the template :
\n<p>{{capitalizeFirstLetter "test"}}</p>Will output :
\nTestYou can use conditional structures (if, then else).
\nLet’s take an example: In our previous product example, we will add a field to the type struct Product :
\ntype Product struct {\n Name string\n Price string\n Description string\n ShippingDate time.Time\n Sale bool\n}The field is named Sale. It’s a boolean that will flag a product if it’s on sale. We want to display something special on our page for this occasion, but only if the product is on sale :
{{ if .Sale }}\n <h3>Exclusive Sale Today !</h3>\n{{ end }}When the template is executed, the engine will check if the value of Sale is not empty. The “empty” condition covers the following case :
false
0
a nil pointer
an interface value
array, slice, map, or string of length zero.
The “if” can be completed with an “else” action :
\n{{ if .Sale }}\n <h3>Exclusive Sale Today !</h3>\n{{ else }}\n <p>Not in sale, sorry</p>\n{{ end }}For more complex comparisons, you can use the eleseif action :
\n{{ if .Sale }}\n //...\n{{ elseif .ExtraDiscount }}\n //...\n{{ else }}\n //...\n{{ end }}You can compare two variables together by using the six existing operators. The syntax is not usual for comparisons. You first specify the comparison operators, and then you specify the two operands. For instance, if you want to compare .Price and 100.00 together the syntax is eq .Price 100.00:
{{ if eq .Price 100.00 }}\n <p>Only 100$</p>\n{{ else }}\n <p>Give yourself a treat</p>\n{{ end }}Those comparisons will return boolean values that can be used safely with conditionals statements.
\n\nLet’s take a concrete example : .Price is of type float64 (defined in our data struct), 100 is parsed as an integer. The two types are not the same. The result of the comparison is false (event if .Price has the value one hundred). The text <p>Only 100$ it's a deal!</p>* will not appear on the HTML page when the template will execute.
{{ if eq .Price 100 }}\n <p>Only 100$ it's a deal!</p>\n{{ end }}The comparison operands may have the following types :
\nbool
int, int8, int16, int64
uint, uint8, uint16, uint64
uintptr
float32, float64
complex64, complex128
string
We can use named types in comparisons.
type LogLevel intYou can define a variable of type LogLevel and use it in your template to make comparisons
Comments, reviews, delivery options... etc. Data to display in a template often comes in the form of lists. The Go template engine has actions dedicated to iteration.
\nFor instance, let’s add the property ShippingOptions to our Product type struct (the data that we will pass to the template) :
// template/iteration/main.go \n\n//...\n\ntype Product struct {\n //...\n ShippingOptions []string\n}\n//...\nteaPot := Product{\n //...\n ShippingOptions: []string{"Extra Priority", "Normal", "Low Priority"}}\nerr = tmpl.Execute(w, teaPot)ShippingOptions is a slice of strings. Then in our template, we can iterate through this slice with the range action :
// template\n<ul>\n {{range $index, $element := .ShippingOptions}}\n <li>{{ $element }}</li>\n {{end}}\n</ul>The range action will launch an iteration over the elements of ShippingOptions. After range, you have to provide two variables names; the first is for the index ($index), the second is for the element under that index ($element).
We can then use those two variables inside the range loop (which is delimited by a end action). The variables $index and $element are defined in the scope of the range loop.
The previous template will output :
\n<ul>\n <li>Extra Priority</li>\n <li>Normal</li>\n <li>Low Priority</li>\n</ul>You can also use a shorter version to iterate over a slice in a template :
\n{{range .ShippingOptions}}\n <li>{{ . }}</li>\n{{end}}The index builtin allows you to get the value from an array, a slice, or a map from its index. To make this more clear, let’s take an example. If you want to get the element at index 0 into the slice .ShippingOptions you can use this syntax :
//template\n{{ $firstDelOpt := index .ShippingOptions 0}}\n<p>First delivery option is {{ $firstDelOpt }}</p>The value of .ShippingOptions[0]. is assigned to the variable $firstDelOpt. We can then use this variable in the rest of the template.
This template will output :
\n<p>First delivery option is Extra Priority</p>We can use the index function with multi-dimensional slices. Let’s add a property Notes (a two-dimensional slice) to our type struct Product :
type Product struct {\n //..\n Notes [][]int\n}This 2D slice represents the notes of users for a product. Each row represent a notation, each column represents the note for a criterion :
\nnotes := [][]int{}\nnote1 := []int{1, 2, 3}\nnote2 := []int{4, 5, 6}\nnotes = append(notes, note1)\nnotes = append(notes, note2)Here we have two notes (note1 and note2) with three criteria each. To retrieve the second criterion of the first note inside our template we can use the index function like this :
{{ $note := index .Notes 0 1}}\n<p>First note, second criterion : {{$note}}</p>Here we provide three arguments to index; the first one is our 2D slice the two others are the indices. Here the value of .Notes[0][1] is retrieved (the first element of a slice is at index 0, then second at index 1).
Go 1.16 introduce a new standard package named embed. With this package, you can include in your program binary your template files (or other files).
Let’s say that your template files are located in a views dir. You can embed all files located into the views directory with the //go:embed views/* directive.
When the program is compiled, Go will populate views with all files located into the views directory.
// template/basic-embed/main.go \npackage main\n\nimport (\n "embed"\n "html/template"\n "net/http"\n "time"\n)\n\n//go:embed views/*\nvar views embed.FS\n\nfunc main {\n tmpl, err := template.ParseFS(views, "views/product.html")\n if err != nil {\n http.Error(w, "Something went wrong", http.StatusInternalServerError)\n return\n }\n // use the template\n}Then you can use the function template.ParseFS to load and parse your template files.
During the development phase, you can use this technique to improve your productivity :
\nInside the template, add this line :
\n{{ printf "%#v" . }}This will output (in a human-readable mode) the properties keys and values passed to the template engine. Here is an example :
\nmain.Product{Name:"Red Tea Pot 250ml", Price:"19.99", Description:"Test", ShippingDate:time.Time{wall:0xbeffc6aedb25e3e0, ext:18903963863, loc:(*time.Location)(0x164dd40)}, Sale:true, SaleImagePath:[]string{"img.jpg"}}When you iterate over a slice with range how to print the slice elements values?
True or False. To generate web pages templates, you can use the two following packages: text/template and html/template.
How to load a template stored on a file?
How to load a template stored inside a variable?
How to print a date into a template with the format -01-02?
How to inject a template into another template?
How to embed templates file in your Go binary?
When you iterate over a slice with a range, how to print the slice elements values?
\nWith {{ . }}
{{range .ShippingOptions}} <li>{{ . }}</li>{{end}}
True or False. To generate web pages template, you can use the two following packages: text/template and html/template.
It is technically true.
However, this is not recommended.
The package html/template offers an extra layer of security (sanitization of data injected into the templates)
How to load a template written on a file?
\ntmpl, err := template.ParseFiles(\"./views/product-dynamic.html\")How to load a template stored inside a variable?
\ntmpl, err := template.New(\"test\").Parse(\"Hello {{.}}\")How to print a date into a template with the format -01-02?
\nGiven that you have a field ShippingDate of type time.Time you can do the following :
{{.ShippingDate.Format \"2006-01-02\"}}
How to inject a template into another template?
\n{{ template \"header\" . }}How to embed templates file in your Go binary?
\n//go:embed views/*Go has a built-in template engine.
A template engine will combine a template with data to produce a final document.
The package template/html is designed to produce HTML documents
This package offers a security layer to protect your generated documents against common attacks.
You should always validate data generated by the user against restrictive rules.
template/text is designed to produce text documents. It does not offer the same security features as template/html
To print a field of a type struct use the notation {{ .NameOfField }}
You can call methods in templates : {{ .MyFunc \"arg1\"\"arg2\" }}. Arguments follow the name of the method
A variable of type time.Time can be formatted easily : {{ .CreateTime.Format \"2006-01-02\" }}
Templates can be nested. A template can be included in another template.
To define a template use define : {{ define \"header\" }} your template {{ end }}
Then you can “inject” this template into another one with : {{ template \"header\" . }}
You can declare variables with the following syntax : {{ $var2 := .Name}}
To iterate over a slice and array or a map, you can use range
<ul>\n {{range $index, $element := .ShippingOptions}}\n <li>{{ $element }}</li>\n {{end}}\n</ul>You can use predeclared global functions : and, or, not, .… a complete list can be found here : https://golang.org/pkg/text/template/#hdr-Functions
You can add custom functions to your templates :
\nfuncs := template.FuncMap{"capitalizeFirstLetter": capitalizeFirstLetter}\n\ntmpl, err := template.New("product-dynamic.html").Funcs(funcs).ParseFiles("./views/product-dynamic.html")\n// check error...From Go 1.16, you can easily embed your templates into your binary file with //go:embed
//go:embed views/*\nvar views embed.FS\n\n//...\n\ntmpl, err := template.ParseFS(views, "views/product.html")\n//...Previous
\n\t\t\t\t\t\t\t\t\tLogging
\n\t\t\t\t\t\t\t\tNext
\n\t\t\t\t\t\t\t\t\tApplication Configuration
\n\t\t\t\t\t\t\t\t