fasttemplate: github.com/valyala/fasttemplate Index | Examples | Files

package fasttemplate

import "github.com/valyala/fasttemplate"

Package fasttemplate implements simple and fast template library.

Fasttemplate is faster than text/template, strings.Replace and strings.Replacer.

Fasttemplate ideally fits for fast and simple placeholders' substitutions.

Index

Examples

Package Files

template.go unsafe.go

func Execute Uses

func Execute(template, startTag, endTag string, w io.Writer, m map[string]interface{}) (int64, error)

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.

This function is optimized for constantly changing templates. Use Template.Execute for frozen templates.

func ExecuteFunc Uses

func ExecuteFunc(template, startTag, endTag string, w io.Writer, f TagFunc) (int64, error)

ExecuteFunc calls f on each template tag (placeholder) occurrence.

Returns the number of bytes written to w.

This function is optimized for constantly changing templates. Use Template.ExecuteFunc for frozen templates.

func ExecuteFuncString Uses

func ExecuteFuncString(template, startTag, endTag string, f TagFunc) string

ExecuteFuncString calls f on each template tag (placeholder) occurrence and substitutes it with the data written to TagFunc's w.

Returns the resulting string.

This function is optimized for constantly changing templates. Use Template.ExecuteFuncString for frozen templates.

func ExecuteString Uses

func ExecuteString(template, startTag, endTag string, m map[string]interface{}) string

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

This function is optimized for constantly changing templates. Use Template.ExecuteString for frozen templates.

type TagFunc Uses

type TagFunc func(w io.Writer, tag string) (int, error)

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.

Code:

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 Uses

type Template struct {
    // contains filtered or unexported fields
}

Template implements simple template engine, which can be used for fast tags' (aka placeholders) substitution.

Code:

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 Uses

func New(template, startTag, endTag string) *Template

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 Uses

func NewTemplate(template, startTag, endTag string) (*Template, error)

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 Uses

func (t *Template) Execute(w io.Writer, m map[string]interface{}) (int64, error)

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 Uses

func (t *Template) ExecuteFunc(w io.Writer, f TagFunc) (int64, error)

ExecuteFunc calls f on each template tag (placeholder) occurrence.

Returns the number of bytes written to w.

This function is optimized for frozen templates. Use ExecuteFunc for constantly changing templates.

func (*Template) ExecuteFuncString Uses

func (t *Template) ExecuteFuncString(f TagFunc) string

ExecuteFuncString calls f on each template tag (placeholder) occurrence and substitutes it with the data written to TagFunc's w.

Returns the resulting string.

This function is optimized for frozen templates. Use ExecuteFuncString for constantly changing templates.

Code:

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 Uses

func (t *Template) ExecuteString(m map[string]interface{}) string

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

This function is optimized for frozen templates. Use ExecuteString for constantly changing templates.

func (*Template) Reset Uses

func (t *Template) Reset(template, startTag, endTag string) error

Reset resets the template t to new one defined by template, startTag and endTag.

Reset allows Template object re-use.

Reset may be called only if no other goroutines call t methods at the moment.

Package fasttemplate imports 6 packages (graph) and is imported by 93 packages. Updated 2018-02-05. Refresh now. Tools for package owners.