How to stop the repetition of code when parsing files

I am repeating the same code of html files in every function. I just changed the name of one file in every function and that is ui/html/home.html in indexHandler() and ui/html/signup.html in signup()

Other file names are the same and the code of ParseFiles() is also the same in each function. How to prevent the code from repeating every time.

func indexHandler(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path != "/" {
		http.NotFound(w, r)
		return
	}

	files := []string{"ui/html/home.html", "ui/html/footer.html", "ui/html/base.html",}    
	tmpl, err := template.ParseFiles(files...)
	if err != nil {
		panic(err)
	}
	tmpl.Execute(w, nil)
}

func signup(w http.ResponseWriter, r *http.Request) {
	files := []string{"ui/html/signup.html", "ui/html/footer.html", "ui/html/base.html",}
	tmpl, err := template.ParseFiles(files...)
	if err != nil {
		panic(err)
	}
	tmpl.Execute(w, nil)
}    

func main() {
	http.HandleFunc("/", indexHandler)
	http.HandleFunc("/signup", signup)
	log.Println("Starting the server at :4000")
	http.ListenAndServe(":4000", nil)
}

You can make it a package variable.

https://play.golang.org/p/haDmat_kzkg

package main

import (
	"fmt"
)

var (
	files = []string{"ui/html/home.html", "ui/html/footer.html", "ui/html/base.html"}
)

func indexHandler(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path != "/" {
		http.NotFound(w, r)
		return
	}

	tmpl, err := template.ParseFiles(files...)
	if err != nil {
		panic(err)
	}
	tmpl.Execute(w, nil)
}

func signup(w http.ResponseWriter, r *http.Request) {
	tmpl, err := template.ParseFiles(files...)
	if err != nil {
		panic(err)
	}
	tmpl.Execute(w, nil)
}

func main() {
	http.HandleFunc("/", indexHandler)
	http.HandleFunc("/signup", signup)
	log.Println("Starting the server at :4000")
	http.ListenAndServe(":4000", nil)
}

If you need to add a template for a specific handler, create a new slice out of the global variable and append to it.

tmpl, err := template.ParseFiles(append(files,[]string{"..."})...)

I think you have to read a bit about effective go in general, https://golang.org/doc/effective_go#initialization
or the go tour https://tour.golang.org/welcome/1

A tip to apply is to compile the template during initialization, rather during the request processing. This will speed up your program.

package main 

//...

var (
	indexTpml = template.Must(template.ParseFiles(files...))
)

https://play.golang.org/p/TgjZYCul9M6

Using some helper functions, one can write,

package main

import (
	"html/template"
	"log"
	"net/http"
)

func makeTpl(base string) *template.Template {
	files := []string{base, "ui/html/footer.html", "ui/html/base.html"}
	return template.Must(template.ParseFiles(files...))
}

var (
	indexTpml  = makeTpl("ui/html/home.html")
	signupTpml = makeTpl("ui/html/signup.html")
)

func indexHandler(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path != "/" {
		http.NotFound(w, r)
		return
	}
	indexTpml.Execute(w, nil)
}

func signup(w http.ResponseWriter, r *http.Request) {
	signupTpml.Execute(w, nil)
}

func main() {
	http.HandleFunc("/", indexHandler)
	http.HandleFunc("/signup", signup)
	log.Println("Starting the server at :4000")
	http.ListenAndServe(":4000", nil)
}