golang text/template startswith function

I don't see any type of startswith function in the Go text/template package. Is this the best implementation?

{{if eq (slice $c 0 5) "begin"}}

There is no builtin startswith template function.

The cleanest is if you register a custom function with that functionality:

func main() {
	t := template.Must(template.New("").Funcs(template.FuncMap{
		"hasPrefix": strings.HasPrefix,
	}).Parse(src))

	for _, s := range []string{"foo", "begining"} {
		if err := t.Execute(os.Stdout, s); err != nil {
			panic(err)
		}
	}
}

const src = `{{.}}: {{if hasPrefix . "begin"}}yes{{else}}no{{end}}
`

This will output (try it on the Go Playground):

foo: no
begining: yes

If you can't or don't want to register a custom function, slice works for strings, but you must use it with care: if the input string is shorter than 5 bytes, you'll get a template execution error!

Instead (if you don't want to register a custom function), I suggest to use the builtin printf function with precision being the length of the string to compare to. printf will not panic if the input string is shorter:

{{if eq (printf "%.5s" .) "begin"}}yes{{else}}no{{end}}

This outputs the same. Try this one on the Go Playground.

Note that using hasPrefix is safer, cleaner and simpler as we don't have to hard-code the length of the prefix (5).

Note that using explicit argument indices we can also make this part dynamic:

{{$prefix := "begin"}}{{if eq (printf "%.[1]*s" (len $prefix) .) $prefix}}yes{{else}}no{{end}}

As you can see, we could get rid of the hard-coded length of 5 of the prefix. This again outputs the same, try it on the Go Playground.

One last thing to note: slicing a string interprets indices as byte-indices, while the precision used in a format string is interpreted as rune count!

I think that you are right. Go text/template package does not provide a built-in startswith function. To check if a string starts with a specific prefix in Go text/templates, you cannot directly use (slice $c 0 5) in combination with eq because the slice function returns a new slice, not a string.

Maybe an example of how to use a custom function would be like:

package main

import (
	"os"
	"strings"
	"text/template"
)

func StartsWithPrefix(str, prefix string) bool {
	return strings.HasPrefix(str, prefix)
}

func main() {
	tmpl := template.Must(template.New("").Funcs(template.FuncMap{
		"startswith": StartsWithPrefix,
	}).Parse(`{{if startswith .C "begin"}}(Chester's Bennington voice)It starts with "One Thing"{{end}}`))

	data := struct {
		C string
	}{
		C: "beginning bla bla",
	}

	err := tmpl.Execute(os.Stdout, data)
	if err != nil {
		panic(err)
	}
}

In this example, we define the StartsWithPrefix function, register it as startswith using template.FuncMap, and then use {{if startswith $c "begin"}} in the template to check if the value of $c starts with the prefix "begin". If it does, the message "(Chester's Bennington voice)It starts with 'One Thing'" will be printed.

You can also check it in Go playground https://go.dev/play/p/hEvhYo_iHhM