Overview¶

Package template implements data-driven templates for generating textual output.

To generate HTML output, seehtml/template, which has the same interfaceas this package but automatically secures HTML output against certain attacks.

Templates are executed by applying them to a data structure. Annotations in thetemplate refer to elements of the data structure (typically a field of a structor a key in a map) to control execution and derive values to be displayed.Execution of the template walks the structure and sets the cursor, representedby a period '.' and called "dot", to the value at the current location in thestructure as execution proceeds.

The security model used by this package assumes that template authors aretrusted. The package does not auto-escape output, so injecting code intoa template can lead to arbitrary code execution if the template is executedby an untrusted source.

The input text for a template is UTF-8-encoded text in any format."Actions"--data evaluations or control structures--are delimited by"{{" and "}}"; all text outside actions is copied to the output unchanged.

Once parsed, a template may be executed safely in parallel, although if parallelexecutions share a Writer the output may be interleaved.

Here is a trivial example that prints "17 items are made of wool".

type Inventory struct {Material stringCount    uint}sweaters := Inventory{"wool", 17}tmpl, err := template.New("test").Parse("{{.Count}} items are made of {{.Material}}")if err != nil { panic(err) }err = tmpl.Execute(os.Stdout, sweaters)if err != nil { panic(err) }

More intricate examples appear below.

Text and spaces¶

By default, all text between actions is copied verbatim when the template isexecuted. For example, the string " items are made of " in the example aboveappears on standard output when the program is run.

However, to aid in formatting template source code, if an action's leftdelimiter (by default "{{") is followed immediately by a minus sign and whitespace, all trailing white space is trimmed from the immediately preceding text.Similarly, if the right delimiter ("}}") is preceded by white space and a minussign, all leading white space is trimmed from the immediately following text.In these trim markers, the white space must be present:"{{- 3}}" is like "{{3}}" but trims the immediately preceding text, while"{{-3}}" parses as an action containing the number -3.

For instance, when executing the template whose source is

"{{23 -}} < {{- 45}}"

the generated output would be

"23<45"

For this trimming, the definition of white space characters is the same as in Go:space, horizontal tab, carriage return, and newline.

Actions¶

Here is the list of actions. "Arguments" and "pipelines" are evaluations ofdata, defined in detail in the corresponding sections that follow.

{{/* a comment */}}{{- /* a comment with white space trimmed from preceding and following text */ -}}A comment; discarded. May contain newlines.Comments do not nest and must start and end at thedelimiters, as shown here.{{pipeline}}The default textual representation (the same as would beprinted by fmt.Print) of the value of the pipeline is copiedto the output.{{if pipeline}} T1 {{end}}If the value of the pipeline is empty, no output is generated;otherwise, T1 is executed. The empty values are false, 0, anynil pointer or interface value, and any array, slice, map, orstring of length zero.Dot is unaffected.{{if pipeline}} T1 {{else}} T0 {{end}}If the value of the pipeline is empty, T0 is executed;otherwise, T1 is executed. Dot is unaffected.{{if pipeline}} T1 {{else if pipeline}} T0 {{end}}To simplify the appearance of if-else chains, the else actionof an if may include another if directly; the effect is exactlythe same as writing{{if pipeline}} T1 {{else}}{{if pipeline}} T0 {{end}}{{end}}{{range pipeline}} T1 {{end}}The value of the pipeline must be an array, slice, map, iter.Seq,iter.Seq2, integer or channel.If the value of the pipeline has length zero, nothing is output;otherwise, dot is set to the successive elements of the array,slice, or map and T1 is executed. If the value is a map and thekeys are of basic type with a defined order, the elements will bevisited in sorted key order.{{range pipeline}} T1 {{else}} T0 {{end}}The value of the pipeline must be an array, slice, map, iter.Seq,iter.Seq2, integer or channel.If the value of the pipeline has length zero, dot is unaffected andT0 is executed; otherwise, dot is set to the successive elementsof the array, slice, or map and T1 is executed.{{break}}The innermost {{range pipeline}} loop is ended early, stopping thecurrent iteration and bypassing all remaining iterations.{{continue}}The current iteration of the innermost {{range pipeline}} loop isstopped, and the loop starts the next iteration.{{template "name"}}The template with the specified name is executed with nil data.{{template "name" pipeline}}The template with the specified name is executed with dot setto the value of the pipeline.{{block "name" pipeline}} T1 {{end}}A block is shorthand for defining a template{{define "name"}} T1 {{end}}and then executing it in place{{template "name" pipeline}}The typical use is to define a set of root templates that arethen customized by redefining the block templates within.{{with pipeline}} T1 {{end}}If the value of the pipeline is empty, no output is generated;otherwise, dot is set to the value of the pipeline and T1 isexecuted.{{with pipeline}} T1 {{else}} T0 {{end}}If the value of the pipeline is empty, dot is unaffected and T0is executed; otherwise, dot is set to the value of the pipelineand T1 is executed.{{with pipeline}} T1 {{else with pipeline}} T0 {{end}}To simplify the appearance of with-else chains, the else actionof a with may include another with directly; the effect is exactlythe same as writing{{with pipeline}} T1 {{else}}{{with pipeline}} T0 {{end}}{{end}}

Arguments¶

An argument is a simple value, denoted by one of the following.

• A boolean, string, character, integer, floating-point, imaginaryor complex constant in Go syntax. These behave like Go's untypedconstants. Note that, as in Go, whether a large integer constantoverflows when assigned or passed to a function can depend on whetherthe host machine's ints are 32 or 64 bits.

• The keyword nil, representing an untyped Go nil.

• The character '.' (period):

  .

  The result is the value of dot.

• A variable name, which is a (possibly empty) alphanumeric stringpreceded by a dollar sign, such as

  $piOver2

  or

  $

  The result is the value of the variable.Variables are described below.

• The name of a field of the data, which must be a struct, precededby a period, such as

  .Field

  The result is the value of the field. Field invocations may bechained:

  .Field1.Field2

  Fields can also be evaluated on variables, including chaining:

  $x.Field1.Field2

• The name of a key of the data, which must be a map, precededby a period, such as

  .Key

  The result is the map element value indexed by the key.Key invocations may be chained and combined with fields to anydepth:

  .Field1.Key1.Field2.Key2

  Although the key must be an alphanumeric identifier, unlike withfield names they do not need to start with an upper case letter.Keys can also be evaluated on variables, including chaining:

  $x.key1.key2

• The name of a niladic method of the data, preceded by a period,such as

  .Method

  The result is the value of invoking the method with dot as thereceiver, dot.Method(). Such a method must have one return value (ofany type) or two return values, the second of which is an error.If it has two and the returned error is non-nil, execution terminatesand an error is returned to the caller as the value of Execute.Method invocations may be chained and combined with fields and keysto any depth:

  .Field1.Key1.Method1.Field2.Key2.Method2

  Methods can also be evaluated on variables, including chaining:

  $x.Method1.Field

• The name of a niladic function, such as

  fun

  The result is the value of invoking the function, fun(). The returntypes and values behave as in methods. Functions and functionnames are described below.

• A parenthesized instance of one the above, for grouping. The resultmay be accessed by a field or map key invocation.

  print (.F1 arg1) (.F2 arg2)(.StructValuedMethod "arg").Field

Arguments may evaluate to any type; if they are pointers the implementationautomatically indirects to the base type when required.If an evaluation yields a function value, such as a function-valuedfield of a struct, the function is not invoked automatically, but itcan be used as a truth value for an if action and the like. To invokeit, use the call function, defined below.

Pipelines¶

A pipeline is a possibly chained sequence of "commands". A command is a simplevalue (argument) or a function or method call, possibly with multiple arguments:

ArgumentThe result is the value of evaluating the argument..Method [Argument...]The method can be alone or the last element of a chain but,unlike methods in the middle of a chain, it can take arguments.The result is the value of calling the method with thearguments:dot.Method(Argument1, etc.)functionName [Argument...]The result is the value of calling the function associatedwith the name:function(Argument1, etc.)Functions and function names are described below.

A pipeline may be "chained" by separating a sequence of commands with pipelinecharacters '|'. In a chained pipeline, the result of each command ispassed as the last argument of the following command. The output of the finalcommand in the pipeline is the value of the pipeline.

The output of a command will be either one value or two values, the second ofwhich has type error. If that second value is present and evaluates tonon-nil, execution terminates and the error is returned to the caller ofExecute.

Variables¶

A pipeline inside an action may initialize a variable to capture the result.The initialization has syntax

$variable := pipeline

where $variable is the name of the variable. An action that declares avariable produces no output.

Variables previously declared can also be assigned, using the syntax

$variable = pipeline

If a "range" action initializes a variable, the variable is set to thesuccessive elements of the iteration. Also, a "range" may declare twovariables, separated by a comma:

range $index, $element := pipeline

in which case $index and $element are set to the successive values of thearray/slice index or map key and element, respectively. Note that if there isonly one variable, it is assigned the element; this is opposite to theconvention in Go range clauses.

A variable's scope extends to the "end" action of the control structure ("if","with", or "range") in which it is declared, or to the end of the template ifthere is no such control structure. A template invocation does not inheritvariables from the point of its invocation.

When execution begins, $ is set to the data argument passed to Execute, that is,to the starting value of dot.

Examples¶

Here are some example one-line templates demonstrating pipelines and variables.All produce the quoted word "output":

{{"\"output\""}}A string constant.{{`"output"`}}A raw string constant.{{printf "%q" "output"}}A function call.{{"output" | printf "%q"}}A function call whose final argument comes from the previouscommand.{{printf "%q" (print "out" "put")}}A parenthesized argument.{{"put" | printf "%s%s" "out" | printf "%q"}}A more elaborate call.{{"output" | printf "%s" | printf "%q"}}A longer chain.{{with "output"}}{{printf "%q" .}}{{end}}A with action using dot.{{with $x := "output" | printf "%q"}}{{$x}}{{end}}A with action that creates and uses a variable.{{with $x := "output"}}{{printf "%q" $x}}{{end}}A with action that uses the variable in another action.{{with $x := "output"}}{{$x | printf "%q"}}{{end}}The same, but pipelined.

Functions¶

During execution functions are found in two function maps: first in thetemplate, then in the global function map. By default, no functions are definedin the template but the Funcs method can be used to add them.

Predefined global functions are named as follows.

andReturns the boolean AND of its arguments by returning thefirst empty argument or the last argument. That is,"and x y" behaves as "if x then y else x."Evaluation proceeds through the arguments left to rightand returns when the result is determined.callReturns the result of calling the first argument, whichmust be a function, with the remaining arguments as parameters.Thus "call .X.Y 1 2" is, in Go notation, dot.X.Y(1, 2) whereY is a func-valued field, map entry, or the like.The first argument must be the result of an evaluationthat yields a value of function type (as distinct froma predefined function such as print). The function mustreturn either one or two result values, the second of whichis of type error. If the arguments don't match the functionor the returned error value is non-nil, execution stops.htmlReturns the escaped HTML equivalent of the textualrepresentation of its arguments. This function is unavailablein html/template, with a few exceptions.indexReturns the result of indexing its first argument by thefollowing arguments. Thus "index x 1 2 3" is, in Go syntax,x[1][2][3]. Each indexed item must be a map, slice, or array.sliceslice returns the result of slicing its first argument by theremaining arguments. Thus "slice x 1 2" is, in Go syntax, x[1:2],while "slice x" is x[:], "slice x 1" is x[1:], and "slice x 1 2 3"is x[1:2:3]. The first argument must be a string, slice, or array.jsReturns the escaped JavaScript equivalent of the textualrepresentation of its arguments.lenReturns the integer length of its argument.notReturns the boolean negation of its single argument.orReturns the boolean OR of its arguments by returning thefirst non-empty argument or the last argument, that is,"or x y" behaves as "if x then x else y".Evaluation proceeds through the arguments left to rightand returns when the result is determined.printAn alias for fmt.SprintprintfAn alias for fmt.SprintfprintlnAn alias for fmt.SprintlnurlqueryReturns the escaped value of the textual representation ofits arguments in a form suitable for embedding in a URL query.This function is unavailable in html/template, with a fewexceptions.

The boolean functions take any zero value to be false and a non-zerovalue to be true.

There is also a set of binary comparison operators defined asfunctions:

eqReturns the boolean truth of arg1 == arg2neReturns the boolean truth of arg1 != arg2ltReturns the boolean truth of arg1 < arg2leReturns the boolean truth of arg1 <= arg2gtReturns the boolean truth of arg1 > arg2geReturns the boolean truth of arg1 >= arg2

For simpler multi-way equality tests, eq (only) accepts two or morearguments and compares the second and subsequent to the first,returning in effect

arg1==arg2 || arg1==arg3 || arg1==arg4 ...

(Unlike with || in Go, however, eq is a function call and all thearguments will be evaluated.)

The comparison functions work on any values whose type Go defines ascomparable. For basic types such as integers, the rules are relaxed:size and exact type are ignored, so any integer value, signed or unsigned,may be compared with any other integer value. (The arithmetic value is compared,not the bit pattern, so all negative integers are less than all unsigned integers.)However, as usual, one may not compare an int with a float32 and so on.

Associated templates¶

Each template is named by a string specified when it is created. Also, eachtemplate is associated with zero or more other templates that it may invoke byname; such associations are transitive and form a name space of templates.

A template may use a template invocation to instantiate another associatedtemplate; see the explanation of the "template" action above. The name must bethat of a template associated with the template that contains the invocation.

Nested template definitions¶

When parsing a template, another template may be defined and associated with thetemplate being parsed. Template definitions must appear at the top level of thetemplate, much like global variables in a Go program.

The syntax of such definitions is to surround each template declaration with a"define" and "end" action.

The define action names the template being created by providing a stringconstant. Here is a simple example:

{{define "T1"}}ONE{{end}}{{define "T2"}}TWO{{end}}{{define "T3"}}{{template "T1"}} {{template "T2"}}{{end}}{{template "T3"}}

This defines two templates, T1 and T2, and a third T3 that invokes the other twowhen it is executed. Finally it invokes T3. If executed this template willproduce the text

ONE TWO

By construction, a template may reside in only one association. If it'snecessary to have a template addressable from multiple associations, thetemplate definition must be parsed multiple times to create distinct *Templatevalues, or must be copied withTemplate.Clone orTemplate.AddParseTree.

Parse may be called multiple times to assemble the various associated templates;seeParseFiles,ParseGlob,Template.ParseFiles andTemplate.ParseGlobfor simple ways to parse related templates stored in files.

A template may be executed directly or throughTemplate.ExecuteTemplate, which executesan associated template identified by name. To invoke our example above, wemight write,

err := tmpl.Execute(os.Stdout, "no data needed")if err != nil {log.Fatalf("execution failed: %s", err)}

or to invoke a particular template explicitly by name,

err := tmpl.ExecuteTemplate(os.Stdout, "T2", "no data needed")if err != nil {log.Fatalf("execution failed: %s", err)}

Index¶

• func HTMLEscape(w io.Writer, b []byte)
• func HTMLEscapeString(s string) string
• func HTMLEscaper(args ...any) string
• func IsTrue(val any) (truth, ok bool)
• func JSEscape(w io.Writer, b []byte)
• func JSEscapeString(s string) string
• func JSEscaper(args ...any) string
• func URLQueryEscaper(args ...any) string
• type ExecError
• • func (e ExecError) Error() string
  • func (e ExecError) Unwrap() error
• type FuncMap
• type Template
• • func Must(t *Template, err error) *Template
  • func New(name string) *Template
  • func ParseFS(fsys fs.FS, patterns ...string) (*Template, error)
  • func ParseFiles(filenames ...string) (*Template, error)
  • func ParseGlob(pattern string) (*Template, error)
• • func (t *Template) AddParseTree(name string, tree *parse.Tree) (*Template, error)
  • func (t *Template) Clone() (*Template, error)
  • func (t *Template) DefinedTemplates() string
  • func (t *Template) Delims(left, right string) *Template
  • func (t *Template) Execute(wr io.Writer, data any) error
  • func (t *Template) ExecuteTemplate(wr io.Writer, name string, data any) error
  • func (t *Template) Funcs(funcMap FuncMap) *Template
  • func (t *Template) Lookup(name string) *Template
  • func (t *Template) Name() string
  • func (t *Template) New(name string) *Template
  • func (t *Template) Option(opt ...string) *Template
  • func (t *Template) Parse(text string) (*Template, error)
  • func (t *Template) ParseFS(fsys fs.FS, patterns ...string) (*Template, error)
  • func (t *Template) ParseFiles(filenames ...string) (*Template, error)
  • func (t *Template) ParseGlob(pattern string) (*Template, error)
  • func (t *Template) Templates() []*Template

Examples¶

• Template
• Template (Block)
• Template (Func)
• Template (Funcs)
• Template (Glob)
• Template (Helpers)
• Template (If)
• Template (Share)

This section is empty.

This section is empty.