Pengenalan Template Function
Selain mengakses field
dalam template, kita juga bisa melakukan akses terhadap suatu fungsi atau function
dalam golang. Cara untuk mengakses function sama seperti halnya mengakses field
namun jika fungsi tersebut memiliki parameter maka kita bisa gunakan tambahan parameter yang dikirim ketika memanggil fungsi di template-nya tersebut.
Cara untuk melakukan pemanggilan tersebut yaitu dengan menggunakan {{.FunctionName}}
ini adalah memanggil field FunctionName
atau function FunctionName()
. Contoh cara lain lagi seperti {{.FunctionName "santekno","hello"}}
berarti ini sama halnya seperti memanggil function FunctionName("santekno","hello")
.
Cara Implementasi
Baik kita akan coba membuat suatu function yang nantinya akan kita akses dalam template. Sebelumnya kita buat terlebih dahulu struct
dibawah ini.
type MyPage struct {
Name string
}
func (myPage MyPage) SayHello(name string) string {
return "Hello " + name + " , My name is " + myPage.Name
}
Lalu kita buat handler yang mana kita akan mengirim functionnya ke dalam template yang akan kita buat.
func TemplateFunctionHandler(w http.ResponseWriter, r *http.Request) {
t := template.Must(template.New("FUNCTION").
Parse(`{{ .SayHello "Santekno" }}`))
t.ExecuteTemplate(w, "FUNCTION", Page{
Title: "Hello",
Name: "Santekno",
})
}
Setelah itu kita tambahkan juga fungsi handler tersebut ke dalam mux
function agar bisa diakses pada browser.
mux.HandleFunc("/template-function", TemplateFunctionHandler)
Jalankan program dan akses halaman yang sudah kita definisikan, maka akan muncul tampilan Hello Santekno , My name is Santekno
.
Global Function
Pada Golang template memiliki beberapa global function. Global function adalah function yang bisa digunakan secara langsung tanpa menggunakan template data. Berikut adalah beberapa global function Golang Template bisa diakses di sini. https://github.com/golang/go/blob/master/src/text/template/funcs.go
Baik kita akan coba menggunakan Global Function ini pada template dengan buat fungsi handler terlebih dahulu.
func TemplateGlobalFunctionHandler(w http.ResponseWriter, r *http.Request) {
t := template.Must(template.New("FUNCTION").
Parse(`{{ len .Name }}`))
t.ExecuteTemplate(w, "FUNCTION", Page{
Title: "Hello",
Name: "Santekno",
})
}
Lalu tambahkan lagi fungsi handler pada router.
mux.HandleFunc("/template-global-function", TemplateGlobalFunctionHandler)
Build ulang dan jalankan program kembali, maka akan menampilkan hasil 8
. Kalau dilihat karena variabel .Name
ini diisi oleh Santekno
maka jumlah huruf dari Santekno
itu adalah 8.
Menambahkan Manual Global Function
Kita juga bisa menambahkan global function secara manual dimana untuk menambahkan global function manual, kita bisa menggunakan method Funcs
pada template. Perlu diingat bahwa untuk menambahkan global function harus dilakukan sebelum melakukan parsing template.
Pertama, kita akan buat template handler-nya terlebih dahulu seperti dibawah ini.
func TemplateManualGlobalFunctionHandler(w http.ResponseWriter, r *http.Request) {
t := template.New("FUNCTION")
t.Funcs(template.FuncMap{
"upper": func(value string) string {
return strings.ToUpper(value)
},
})
t = template.Must(t.Parse(`{{ upper .Name }}`))
t.ExecuteTemplate(w, "FUNCTION", Page{
Title: "Hello",
Name: "Santekno",
})
}
lalu tambahkan juga handler-nya seperti dibawah ini.
mux.HandleFunc("/template-manual-global-function", TemplateManualGlobalFunctionHandler)
Terakhir kita jalankan apa yang sudah kita buat dengan perintah terminal
go build && ./learn-golang-web
Hasilnya pun akan menampilkan pada browser SANTEKNO
dengan huruf kapital semuanya karena kita sudah membuat custom function yang sudah didaftarkan pada template.
Function Pipelines
Golang template mendukung function pipelines yang mana hasil dari suatu function bisa dikirim ke function berikutnya. Jika kita ingin menggunakan function pipelines, kita bisa menggunakan tanda |
misalkan:
- {{ sayHello .Name | upper }} berarti kita akan memanggil global function
sayHello(Name)
lalu hasil dari fungsi tersebut akan dikirim ke dalam fungsiupper(Result)
. Dan pada Golang template ini kita bisa menambahkan function pipelines lebih dari satu.
Kita coba tambahkan lagi dengan membuat handler baru seperti dibawah ini.
func TemplateFunctionPipelinesHandler(w http.ResponseWriter, r *http.Request) {
t := template.New("FUNCTION")
t.Funcs(template.FuncMap{
"sayHello": func(name string) string {
return "Hello " + name
},
"upper": func(value string) string {
return strings.ToUpper(value)
},
})
t = template.Must(t.Parse(`{{ sayHello .Name | upper }}`))
t.ExecuteTemplate(w, "FUNCTION", Page{
Title: "Hello",
Name: "Santekno",
})
}
Lalu tambahkan juga pada router mux
mux.HandleFunc("/template-function-pipelines", TemplateFunctionPipelinesHandler)
Jalankan kembali program dan lihat hasilnya, maka akan menampilkan HELLO SANTEKNO
dengan huruf besar semuanya.