Defining functions

The templates use the string representation of an object to insert values, using the fmt package to convert the object to a string. Sometimes this isn’t what is needed. For example, to avoid spammers getting hold of email addresses it is quite common to see the symbol '@' replaced by the word " at ", as in "jan at newmarch.name". If we want to use a template to display email addresses in that form, then we have to build a custom function to do this transformation.

Each template function has a name that is used in the templates themselves, and an associated Go function. These are linked by the type

  1. type FuncMap map[string]interface{}

For example, if we want our template function to be "emailExpand" which is linked to the Go function EmailExpander then we add this to the functions in a template by

  1. t = t.Funcs(template.FuncMap{"emailExpand": EmailExpander})

The signature for EmailExpander is typically

  1. func EmailExpander(args ...interface{}) string

In the use we are interested in, there should only be one argument to the function which will be a string. Existing functions in the Go template library have some initial code to handle non-conforming cases, so we just copy that. Then it is just simple string manipulation to change the format of the email address. A program is

  1. /**
  2.  * PrintEmails
  3.  */
  5. package main
  7. import (
  8.     "fmt"
  9.     "os"
  10.     "strings"
  11.     "text/template"
  12. )
  14. type Person struct {
  15.     Name   string
  16.     Emails []string
  17. }
  19. const templ = `The name is {{.Name}}.
  20. {{range .Emails}}
  21.         An email is "{{. | emailExpand}}"
  22. {{end}}
  23. `
  25. func EmailExpander(args ...interface{}) string {
  26.     ok := false
  27.     var s string
  28.     if len(args) == 1 {
  29.         s, ok = args[0].(string)
  30.     }
  31.     if !ok {
  32.         s = fmt.Sprint(args...)
  33.     }
  35.     // find the @ symbol
  36.     substrs := strings.Split(s, "@")
  37.     if len(substrs) != 2 {
  38.         return s
  39.     }
  40.     // replace the @ by " at "
  41.     return (substrs[0] + " at " + substrs[1])
  42. }
  44. func main() {
  45.     person := Person{
  46.         Name:   "jan",
  47.         Emails: []string{"jan@newmarch.name", "jan.newmarch@gmail.com"},
  48.     }
  50.     t := template.New("Person template")
  52.     // add our function
  53.     t = t.Funcs(template.FuncMap{"emailExpand": EmailExpander})
  55.     t, err := t.Parse(templ)
  57.     checkError(err)
  59.     err = t.Execute(os.Stdout, person)
  60.     checkError(err)
  61. }
  63. func checkError(err error) {
  64.     if err != nil {
  65.         fmt.Println("Fatal error ", err.Error())
  66.         os.Exit(1)
  67.     }
  68. }

The output is

  1. The name is jan.
  3. An email is "jan at newmarch.name"
  5. An email is "jan.newmarch at gmail.com"