Documentation ¶
Overview ¶
Package femplate implements simple and fast template library.
Femplate is faster than text/template, strings.Replace and strings.Replacer.
Femplate ideally fits for fast and simple placeholders' substitutions.
Index ¶
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type TagFunc ¶
TagFunc can be used as a substitution value in the map passed to Execute*. Execute* functions pass tag (placeholder) name in 'tag' argument.
TagFunc must be safe to call from concurrently running goroutines.
TagFunc must write contents to w and return the number of bytes written.
Example ¶
template := "foo[baz]bar" t, err := NewTemplate(template, "[", "]") if err != nil { log.Fatalf("unexpected error when parsing template: %s", err) } bazSlice := [][]byte{[]byte("123"), []byte("456"), []byte("789")} m := map[string]interface{}{ // Always wrap the function into TagFunc. // // "baz" tag function writes bazSlice contents into w. "baz": TagFunc(func(w io.Writer, tag string) (int, error) { var nn int for _, x := range bazSlice { n, err := w.Write(x) if err != nil { return nn, err } nn += n } return nn, nil }), } s := t.ExecuteString(m) fmt.Printf("%s", s)
Output: foo123456789bar
type Template ¶
type Template struct {
// contains filtered or unexported fields
}
Template implements simple template engine, which can be used for fast tags' (aka placeholders) substitution.
Example ¶
template := "http://{{host}}/?foo={{bar}}{{bar}}&q={{query}}&baz={{baz}}" t := New(template, "{{", "}}") // Substitution map. // Since "baz" tag is missing in the map, it will be substituted // by an empty string. m := map[string]interface{}{ "host": "google.com", // string - convenient "bar": []byte("foobar"), // byte slice - the fastest // TagFunc - flexible value. TagFunc is called only if the given // tag exists in the template. "query": TagFunc(func(w io.Writer, tag string) (int, error) { return w.Write([]byte(url.QueryEscape(tag + "=world"))) }), } s := t.ExecuteString(m) fmt.Printf("%s", s)
Output: http://google.com/?foo=foobarfoobar&q=query%3Dworld&baz=
func New ¶
New parses the given template using the given startTag and endTag as tag start and tag end.
The returned template can be executed by concurrently running goroutines using Execute* methods.
New panics if the given template cannot be parsed. Use NewTemplate instead if template may contain errors.
func NewTemplate ¶
NewTemplate parses the given template using the given startTag and endTag as tag start and tag end.
The returned template can be executed by concurrently running goroutines using Execute* methods.
func (*Template) Execute ¶
Execute substitutes template tags (placeholders) with the corresponding values from the map m and writes the result to the given writer w.
Substitution map m may contain values with the following types:
- []byte - the fastest value type
- string - convenient value type
- TagFunc - flexible value type
Returns the number of bytes written to w.
func (*Template) ExecuteFunc ¶
ExecuteFunc calls f on each template tag (placeholder) occurrence.
Returns the number of bytes written to w.
func (*Template) ExecuteFuncString ¶
ExecuteFuncString call f on each template tag (placeholder) occurrence and substitutes it with the data written to TagFunc's w.
Returns the resulting string.
Example ¶
template := "Hello, [user]! You won [prize]!!! [foobar]" t, err := NewTemplate(template, "[", "]") if err != nil { log.Fatalf("unexpected error when parsing template: %s", err) } s := t.ExecuteFuncString(func(w io.Writer, tag string) (int, error) { switch tag { case "user": return w.Write([]byte("John")) case "prize": return w.Write([]byte("$100500")) default: return w.Write([]byte(fmt.Sprintf("[unknown tag %q]", tag))) } }) fmt.Printf("%s", s)
Output: Hello, John! You won $100500!!! [unknown tag "foobar"]
func (*Template) ExecuteString ¶
ExecuteString substitutes template tags (placeholders) with the corresponding values from the map m and returns the result.
Substitution map m may contain values with the following types:
- []byte - the fastest value type
- string - convenient value type
- TagFunc - flexible value type