1 // Copyright 2011 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 /* 6 Package template implements data-driven templates for generating textual output. 7 8 To generate HTML output, see package html/template, which has the same interface 9 as this package but automatically secures HTML output against certain attacks. 10 11 Templates are executed by applying them to a data structure. Annotations in the 12 template refer to elements of the data structure (typically a field of a struct 13 or a key in a map) to control execution and derive values to be displayed. 14 Execution of the template walks the structure and sets the cursor, represented 15 by a period '.' and called "dot", to the value at the current location in the 16 structure as execution proceeds. 17 18 The input text for a template is UTF-8-encoded text in any format. 19 "Actions"--data evaluations or control structures--are delimited by 20 "{{" and "}}"; all text outside actions is copied to the output unchanged. 21 Except for raw strings, actions may not span newlines, although comments can. 22 23 Once parsed, a template may be executed safely in parallel, although if parallel 24 executions share a Writer the output may be interleaved. 25 26 Here is a trivial example that prints "17 items are made of wool". 27 28 type Inventory struct { 29 Material string 30 Count uint 31 } 32 sweaters := Inventory{"wool", 17} 33 tmpl, err := template.New("test").Parse("{{.Count}} items are made of {{.Material}}") 34 if err != nil { panic(err) } 35 err = tmpl.Execute(os.Stdout, sweaters) 36 if err != nil { panic(err) } 37 38 More intricate examples appear below. 39 40 Text and spaces 41 42 By default, all text between actions is copied verbatim when the template is 43 executed. For example, the string " items are made of " in the example above appears 44 on standard output when the program is run. 45 46 However, to aid in formatting template source code, if an action's left delimiter 47 (by default "{{") is followed immediately by a minus sign and ASCII space character 48 ("{{- "), all trailing white space is trimmed from the immediately preceding text. 49 Similarly, if the right delimiter ("}}") is preceded by a space and minus sign 50 (" -}}"), all leading white space is trimmed from the immediately following text. 51 In these trim markers, the ASCII space must be present; "{{-3}}" parses as an 52 action containing the number -3. 53 54 For instance, when executing the template whose source is 55 56 "{{23 -}} < {{- 45}}" 57 58 the generated output would be 59 60 "23<45" 61 62 For this trimming, the definition of white space characters is the same as in Go: 63 space, horizontal tab, carriage return, and newline. 64 65 Actions 66 67 Here is the list of actions. "Arguments" and "pipelines" are evaluations of 68 data, defined in detail in the corresponding sections that follow. 69 70 */ 71 // {{/* a comment */}} 72 // {{- /* a comment with white space trimmed from preceding and following text */ -}} 73 // A comment; discarded. May contain newlines. 74 // Comments do not nest and must start and end at the 75 // delimiters, as shown here. 76 /* 77 78 {{pipeline}} 79 The default textual representation (the same as would be 80 printed by fmt.Print) of the value of the pipeline is copied 81 to the output. 82 83 {{if pipeline}} T1 {{end}} 84 If the value of the pipeline is empty, no output is generated; 85 otherwise, T1 is executed. The empty values are false, 0, any 86 nil pointer or interface value, and any array, slice, map, or 87 string of length zero. 88 Dot is unaffected. 89 90 {{if pipeline}} T1 {{else}} T0 {{end}} 91 If the value of the pipeline is empty, T0 is executed; 92 otherwise, T1 is executed. Dot is unaffected. 93 94 {{if pipeline}} T1 {{else if pipeline}} T0 {{end}} 95 To simplify the appearance of if-else chains, the else action 96 of an if may include another if directly; the effect is exactly 97 the same as writing 98 {{if pipeline}} T1 {{else}}{{if pipeline}} T0 {{end}}{{end}} 99 100 {{range pipeline}} T1 {{end}} 101 The value of the pipeline must be an array, slice, map, or channel. 102 If the value of the pipeline has length zero, nothing is output; 103 otherwise, dot is set to the successive elements of the array, 104 slice, or map and T1 is executed. If the value is a map and the 105 keys are of basic type with a defined order ("comparable"), the 106 elements will be visited in sorted key order. 107 108 {{range pipeline}} T1 {{else}} T0 {{end}} 109 The value of the pipeline must be an array, slice, map, or channel. 110 If the value of the pipeline has length zero, dot is unaffected and 111 T0 is executed; otherwise, dot is set to the successive elements 112 of the array, slice, or map and T1 is executed. 113 114 {{template "name"}} 115 The template with the specified name is executed with nil data. 116 117 {{template "name" pipeline}} 118 The template with the specified name is executed with dot set 119 to the value of the pipeline. 120 121 {{block "name" pipeline}} T1 {{end}} 122 A block is shorthand for defining a template 123 {{define "name"}} T1 {{end}} 124 and then executing it in place 125 {{template "name" pipeline}} 126 The typical use is to define a set of root templates that are 127 then customized by redefining the block templates within. 128 129 {{with pipeline}} T1 {{end}} 130 If the value of the pipeline is empty, no output is generated; 131 otherwise, dot is set to the value of the pipeline and T1 is 132 executed. 133 134 {{with pipeline}} T1 {{else}} T0 {{end}} 135 If the value of the pipeline is empty, dot is unaffected and T0 136 is executed; otherwise, dot is set to the value of the pipeline 137 and T1 is executed. 138 139 Arguments 140 141 An argument is a simple value, denoted by one of the following. 142 143 - A boolean, string, character, integer, floating-point, imaginary 144 or complex constant in Go syntax. These behave like Go's untyped 145 constants. Note that, as in Go, whether a large integer constant 146 overflows when assigned or passed to a function can depend on whether 147 the host machine's ints are 32 or 64 bits. 148 - The keyword nil, representing an untyped Go nil. 149 - The character '.' (period): 150 . 151 The result is the value of dot. 152 - A variable name, which is a (possibly empty) alphanumeric string 153 preceded by a dollar sign, such as 154 $piOver2 155 or 156 $ 157 The result is the value of the variable. 158 Variables are described below. 159 - The name of a field of the data, which must be a struct, preceded 160 by a period, such as 161 .Field 162 The result is the value of the field. Field invocations may be 163 chained: 164 .Field1.Field2 165 Fields can also be evaluated on variables, including chaining: 166 $x.Field1.Field2 167 - The name of a key of the data, which must be a map, preceded 168 by a period, such as 169 .Key 170 The result is the map element value indexed by the key. 171 Key invocations may be chained and combined with fields to any 172 depth: 173 .Field1.Key1.Field2.Key2 174 Although the key must be an alphanumeric identifier, unlike with 175 field names they do not need to start with an upper case letter. 176 Keys can also be evaluated on variables, including chaining: 177 $x.key1.key2 178 - The name of a niladic method of the data, preceded by a period, 179 such as 180 .Method 181 The result is the value of invoking the method with dot as the 182 receiver, dot.Method(). Such a method must have one return value (of 183 any type) or two return values, the second of which is an error. 184 If it has two and the returned error is non-nil, execution terminates 185 and an error is returned to the caller as the value of Execute. 186 Method invocations may be chained and combined with fields and keys 187 to any depth: 188 .Field1.Key1.Method1.Field2.Key2.Method2 189 Methods can also be evaluated on variables, including chaining: 190 $x.Method1.Field 191 - The name of a niladic function, such as 192 fun 193 The result is the value of invoking the function, fun(). The return 194 types and values behave as in methods. Functions and function 195 names are described below. 196 - A parenthesized instance of one the above, for grouping. The result 197 may be accessed by a field or map key invocation. 198 print (.F1 arg1) (.F2 arg2) 199 (.StructValuedMethod "arg").Field 200 201 Arguments may evaluate to any type; if they are pointers the implementation 202 automatically indirects to the base type when required. 203 If an evaluation yields a function value, such as a function-valued 204 field of a struct, the function is not invoked automatically, but it 205 can be used as a truth value for an if action and the like. To invoke 206 it, use the call function, defined below. 207 208 Pipelines 209 210 A pipeline is a possibly chained sequence of "commands". A command is a simple 211 value (argument) or a function or method call, possibly with multiple arguments: 212 213 Argument 214 The result is the value of evaluating the argument. 215 .Method [Argument...] 216 The method can be alone or the last element of a chain but, 217 unlike methods in the middle of a chain, it can take arguments. 218 The result is the value of calling the method with the 219 arguments: 220 dot.Method(Argument1, etc.) 221 functionName [Argument...] 222 The result is the value of calling the function associated 223 with the name: 224 function(Argument1, etc.) 225 Functions and function names are described below. 226 227 A pipeline may be "chained" by separating a sequence of commands with pipeline 228 characters '|'. In a chained pipeline, the result of each command is 229 passed as the last argument of the following command. The output of the final 230 command in the pipeline is the value of the pipeline. 231 232 The output of a command will be either one value or two values, the second of 233 which has type error. If that second value is present and evaluates to 234 non-nil, execution terminates and the error is returned to the caller of 235 Execute. 236 237 Variables 238 239 A pipeline inside an action may initialize a variable to capture the result. 240 The initialization has syntax 241 242 $variable := pipeline 243 244 where $variable is the name of the variable. An action that declares a 245 variable produces no output. 246 247 Variables previously declared can also be assigned, using the syntax 248 249 $variable = pipeline 250 251 If a "range" action initializes a variable, the variable is set to the 252 successive elements of the iteration. Also, a "range" may declare two 253 variables, separated by a comma: 254 255 range $index, $element := pipeline 256 257 in which case $index and $element are set to the successive values of the 258 array/slice index or map key and element, respectively. Note that if there is 259 only one variable, it is assigned the element; this is opposite to the 260 convention in Go range clauses. 261 262 A variable's scope extends to the "end" action of the control structure ("if", 263 "with", or "range") in which it is declared, or to the end of the template if 264 there is no such control structure. A template invocation does not inherit 265 variables from the point of its invocation. 266 267 When execution begins, $ is set to the data argument passed to Execute, that is, 268 to the starting value of dot. 269 270 Examples 271 272 Here are some example one-line templates demonstrating pipelines and variables. 273 All produce the quoted word "output": 274 275 {{"\"output\""}} 276 A string constant. 277 {{`"output"`}} 278 A raw string constant. 279 {{printf "%q" "output"}} 280 A function call. 281 {{"output" | printf "%q"}} 282 A function call whose final argument comes from the previous 283 command. 284 {{printf "%q" (print "out" "put")}} 285 A parenthesized argument. 286 {{"put" | printf "%s%s" "out" | printf "%q"}} 287 A more elaborate call. 288 {{"output" | printf "%s" | printf "%q"}} 289 A longer chain. 290 {{with "output"}}{{printf "%q" .}}{{end}} 291 A with action using dot. 292 {{with $x := "output" | printf "%q"}}{{$x}}{{end}} 293 A with action that creates and uses a variable. 294 {{with $x := "output"}}{{printf "%q" $x}}{{end}} 295 A with action that uses the variable in another action. 296 {{with $x := "output"}}{{$x | printf "%q"}}{{end}} 297 The same, but pipelined. 298 299 Functions 300 301 During execution functions are found in two function maps: first in the 302 template, then in the global function map. By default, no functions are defined 303 in the template but the Funcs method can be used to add them. 304 305 Predefined global functions are named as follows. 306 307 and 308 Returns the boolean AND of its arguments by returning the 309 first empty argument or the last argument, that is, 310 "and x y" behaves as "if x then y else x". All the 311 arguments are evaluated. 312 call 313 Returns the result of calling the first argument, which 314 must be a function, with the remaining arguments as parameters. 315 Thus "call .X.Y 1 2" is, in Go notation, dot.X.Y(1, 2) where 316 Y is a func-valued field, map entry, or the like. 317 The first argument must be the result of an evaluation 318 that yields a value of function type (as distinct from 319 a predefined function such as print). The function must 320 return either one or two result values, the second of which 321 is of type error. If the arguments don't match the function 322 or the returned error value is non-nil, execution stops. 323 html 324 Returns the escaped HTML equivalent of the textual 325 representation of its arguments. This function is unavailable 326 in html/template, with a few exceptions. 327 index 328 Returns the result of indexing its first argument by the 329 following arguments. Thus "index x 1 2 3" is, in Go syntax, 330 x[1][2][3]. Each indexed item must be a map, slice, or array. 331 js 332 Returns the escaped JavaScript equivalent of the textual 333 representation of its arguments. 334 len 335 Returns the integer length of its argument. 336 not 337 Returns the boolean negation of its single argument. 338 or 339 Returns the boolean OR of its arguments by returning the 340 first non-empty argument or the last argument, that is, 341 "or x y" behaves as "if x then x else y". All the 342 arguments are evaluated. 343 print 344 An alias for fmt.Sprint 345 printf 346 An alias for fmt.Sprintf 347 println 348 An alias for fmt.Sprintln 349 urlquery 350 Returns the escaped value of the textual representation of 351 its arguments in a form suitable for embedding in a URL query. 352 This function is unavailable in html/template, with a few 353 exceptions. 354 355 The boolean functions take any zero value to be false and a non-zero 356 value to be true. 357 358 There is also a set of binary comparison operators defined as 359 functions: 360 361 eq 362 Returns the boolean truth of arg1 == arg2 363 ne 364 Returns the boolean truth of arg1 != arg2 365 lt 366 Returns the boolean truth of arg1 < arg2 367 le 368 Returns the boolean truth of arg1 <= arg2 369 gt 370 Returns the boolean truth of arg1 > arg2 371 ge 372 Returns the boolean truth of arg1 >= arg2 373 374 For simpler multi-way equality tests, eq (only) accepts two or more 375 arguments and compares the second and subsequent to the first, 376 returning in effect 377 378 arg1==arg2 || arg1==arg3 || arg1==arg4 ... 379 380 (Unlike with || in Go, however, eq is a function call and all the 381 arguments will be evaluated.) 382 383 The comparison functions work on basic types only (or named basic 384 types, such as "type Celsius float32"). They implement the Go rules 385 for comparison of values, except that size and exact type are 386 ignored, so any integer value, signed or unsigned, may be compared 387 with any other integer value. (The arithmetic value is compared, 388 not the bit pattern, so all negative integers are less than all 389 unsigned integers.) However, as usual, one may not compare an int 390 with a float32 and so on. 391 392 Associated templates 393 394 Each template is named by a string specified when it is created. Also, each 395 template is associated with zero or more other templates that it may invoke by 396 name; such associations are transitive and form a name space of templates. 397 398 A template may use a template invocation to instantiate another associated 399 template; see the explanation of the "template" action above. The name must be 400 that of a template associated with the template that contains the invocation. 401 402 Nested template definitions 403 404 When parsing a template, another template may be defined and associated with the 405 template being parsed. Template definitions must appear at the top level of the 406 template, much like global variables in a Go program. 407 408 The syntax of such definitions is to surround each template declaration with a 409 "define" and "end" action. 410 411 The define action names the template being created by providing a string 412 constant. Here is a simple example: 413 414 `{{define "T1"}}ONE{{end}} 415 {{define "T2"}}TWO{{end}} 416 {{define "T3"}}{{template "T1"}} {{template "T2"}}{{end}} 417 {{template "T3"}}` 418 419 This defines two templates, T1 and T2, and a third T3 that invokes the other two 420 when it is executed. Finally it invokes T3. If executed this template will 421 produce the text 422 423 ONE TWO 424 425 By construction, a template may reside in only one association. If it's 426 necessary to have a template addressable from multiple associations, the 427 template definition must be parsed multiple times to create distinct *Template 428 values, or must be copied with the Clone or AddParseTree method. 429 430 Parse may be called multiple times to assemble the various associated templates; 431 see the ParseFiles and ParseGlob functions and methods for simple ways to parse 432 related templates stored in files. 433 434 A template may be executed directly or through ExecuteTemplate, which executes 435 an associated template identified by name. To invoke our example above, we 436 might write, 437 438 err := tmpl.Execute(os.Stdout, "no data needed") 439 if err != nil { 440 log.Fatalf("execution failed: %s", err) 441 } 442 443 or to invoke a particular template explicitly by name, 444 445 err := tmpl.ExecuteTemplate(os.Stdout, "T2", "no data needed") 446 if err != nil { 447 log.Fatalf("execution failed: %s", err) 448 } 449 450 */ 451 package template 452