以下为Golang标准库的一些基础语法和基础函数,GoFrame框架对部分基础函数做了必要的改进。

变量可以使用符号 | 在函数间传递

  1. {{.value | Func1 | Func2}}

使用括号

  1. {{printf "nums is %s %d" (printf "%d %d" 1 2) 3}}

and

  1. {{and .X .Y .Z}}

and会逐一判断每个参数,将返回第一个为空的参数,否则就返回最后一个非空参数

call

  1. {{call .Field.Func .Arg1 .Arg2}}

call可以调用函数,并传入参数

调用的函数需要返回 1 个值 或者 2 个值,返回两个值时,第二个值用于返回error类型的错误。返回的错误不等于nil时,执行将终止。

index

index支持map, slice, array, string,读取指定类型对应下标的值。

  1. {{index .Maps "name"}}

len

  1. {{printf "The content length is %d" (.Content|len)}}

返回对应类型的长度,支持类型:map, slice, array, string, chan

not

not返回输入参数的否定值。

例如,判断是否变量是否为空:

  1. {{if not .Var}}
  2. // 执行为空操作(.Var为空, 如: nil, 0, "", 长度为0的slice/map)
  3. {{else}}
  4. // 执行非空操作(.Var不为空)
  5. {{end}}

or

  1. {{or .X .Y .Z}}

or会逐一判断每个参数,将返回第一个非空的参数,否则就返回最后一个参数。

print

fmt.Sprint

printf

fmt.Sprintf

println

fmt.Sprintln

urlquery

  1. {{urlquery "http://johng.cn"}}

将返回

  1. http%3A%2F%2Fjohng.cn

eq / ne / lt / le / gt / ge

这类函数一般配合在if中使用

  1. `eq`: arg1 == arg2
  2. `ne`: arg1 != arg2
  3. `lt`: arg1 < arg2
  4. `le`: arg1 <= arg2
  5. `gt`: arg1 > arg2
  6. `ge`: arg1 >= arg2

eq和其他函数不一样的地方是,支持多个参数。

  1. {{eq arg1 arg2 arg3 arg4}}

和下面的逻辑判断相同:

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

if一起使用

  1. {{if eq true .Var1 .Var2 .Var3}}...{{end}}
  1. {{if lt 100 200}}...{{end}}

例如,判断变量不为空时执行:

  1. {{if .Var}}
  2. // 执行非空操作(.Var不为空)
  3. {{else}}
  4. // 执行为空操作(.Var为空, 如: nil, 0, "", 长度为0的slice/map)
  5. {{end}}

对比函数改进

GoFrame框架模板引擎对标准库自带的对比模板函数eq/ne/lt/le/gt/ge做了必要的改进,以便支持任意数据类型的比较。例如,在标准库模板中的以下比较:

  1. {{eq 1 "1"}}

将会引发错误:

  1. panic: template: at <eq 1 "1">: error calling eq: incompatible types for comparison

由于比较的两个参数不是同一数据类型,因此引发了panic错误。

GoFrame框架的模板引擎中,将会自动将两个参数进行数据转换,转换为同一类型后再进行比较,这样的开发体验更好、灵活性更高。如果两个参数均为整型变量(或者整型字符串),那么将会转换为整型进行比较,否则转换为字符串变量进行比较(区分大小写)。

改进运行示例

我们来看一个GoFrame框架的模板引擎中的对比模板函数运行示例。

  1. package main
  2. import (
  3. "context"
  4. "fmt"
  5. "github.com/gogf/gf/v2/frame/g"
  6. )
  7. func main() {
  8. tplContent := `
  9. eq:
  10. eq "a" "a": {{eq "a" "a"}}
  11. eq "1" "1": {{eq "1" "1"}}
  12. eq 1 "1": {{eq 1 "1"}}
  13. ne:
  14. ne 1 "1": {{ne 1 "1"}}
  15. ne "a" "a": {{ne "a" "a"}}
  16. ne "a" "b": {{ne "a" "b"}}
  17. lt:
  18. lt 1 "2": {{lt 1 "2"}}
  19. lt 2 2 : {{lt 2 2 }}
  20. lt "a" "b": {{lt "a" "b"}}
  21. le:
  22. le 1 "2": {{le 1 "2"}}
  23. le 2 1 : {{le 2 1 }}
  24. le "a" "a": {{le "a" "a"}}
  25. gt:
  26. gt 1 "2": {{gt 1 "2"}}
  27. gt 2 1 : {{gt 2 1 }}
  28. gt "a" "a": {{gt "a" "a"}}
  29. ge:
  30. ge 1 "2": {{ge 1 "2"}}
  31. ge 2 1 : {{ge 2 1 }}
  32. ge "a" "a": {{ge "a" "a"}}
  33. `
  34. content, err := g.View().ParseContent(context.TODO(), tplContent, nil)
  35. if err != nil {
  36. panic(err)
  37. }
  38. fmt.Println(content)
  39. }

运行后,输出结果为:

  1. eq:
  2. eq "a" "a": true
  3. eq "1" "1": true
  4. eq 1 "1": true
  5. ne:
  6. ne 1 "1": false
  7. ne "a" "a": false
  8. ne "a" "b": true
  9. lt:
  10. lt 1 "2": true
  11. lt 2 2 : false
  12. lt "a" "b": true
  13. le:
  14. le 1 "2": true
  15. le 2 1 : false
  16. le "a" "a": true
  17. gt:
  18. gt 1 "2": false
  19. gt 2 1 : true
  20. gt "a" "a": false
  21. ge:
  22. ge 1 "2": false
  23. ge 2 1 : true
  24. ge "a" "a": true