FET is a go template engineer that can translate code to html/template
code.
FET means Friendly, Easily for Templating.html/template
has a basic support for templating, but it's not easy to use, so you need FET.
- Expression support
- Use
incldue
with defined variables scopes - Use
extends
inherit base template with defined variables scopes - Extends support for
for
loop, e.g
it's more like the php template engineer smarty.
-
inherit
{%extends "base.html"%}
-
blocks for inherit
{%block "header"%} <div>some code here</div> {%/block%}
-
include
{%include "header.html"%}
-
loop, do not support keyword
break
continue
// for Gofet mode {%for item,key in list%} // output {%/for%} {%for i = 0, j = 10; i < j; i++%} // output {%/for%} // for Smarty mode {%foreach $list as $key => $item%} // output {%/foreach%} // for {%for $i = 0, $j = 10; $i < $j; $i++%} // output {%/for%}
-
if condition
{%if $num > 100%} {%elseif $num < 50%} {%else%} {%/if%}
-
output
{%$item.url%}
-
pipe funcs
{%$item.title|truncate:30%}
-
variable define
{%$title = "this is a title"%}
-
capture
{%capture "hello"%} {%/capture%} {%$fet.capture.hello%}
-
static variables
{%$fet.capture.xxx%} {%$fet.config.leftDelimiter%} {%$fet.config.rightDelimiter%} {%$fet.config.templateDir%} {%$fet.config.compileDir%} {%$fet.now%} {%$fet.debug%} // will output all the variables that assigned in the template<include variables that difined in the template by yourself> to the js devtools's Console panel.
-
special variables
{%$ROOT%} // will output $ {%$fet%} // will output .
-
operators
+ - * / % ! ** == >= <= != && || & ^
-
keyword operators
and
&&or
||not
!eq
==ne
!=gt
>ge
>=lt
<le
<=
bitor
for "|" -
pipe
|
pipeline funcs
:
set arguments for pipeline funcs -
numbers
hex:0xffff
octal:0o777
binary:0b1000
scientific notation1e10
Be careful of the and
and or
operators, they don't have short circuit with conditions.
{% $sayHello = "world" %}
{% "hello `$sayHello`"%} // output "hello world"
use ``
for variable or expression in strings. do not use +
.
-
Math
min
max
floor
ceil
-
Helpers
number_format
truncate
-
Assert
empty
-
Length
count
-
Output
safe
- types.Smarty
the variable and field must begin with$
, useforeach
tag for loops.
- types.Gofet
the variable and field mustn't begin with$
, usefor
tag for loops.
# install command line tool `fetc`
go get -v github.com/fefit/fetc
# then init the config, will make a config file `fet.config.json`
fetc init
# then watch the file change, compile your fet template file immediately
fetc watch
package main
import (
"os"
"github.com/fefit/fet"
"github.com/fefit/fet/types"
)
func main(){
conf := &fet.Config{
LeftDelimiter: "{%", // default "{%"
RightDelimiter: "%}", // default "%}"
TemplateDir: "tmpls", // default "templates"
CompileDir: "views", // default "templates_c",
Ignores: []string{"inc/*"}, // ignore compile,paths and files that will be included and extended. use filepath.Match() method.
UcaseField: false, // default false, if true will auto uppercase field name to uppercase.
CompileOnline: false, // default false, you should compile your template files offline
Glob: false, // default false, if true, will add {{define "xxx"}}{{end}} to wrap the compiled content,"xxx" is the relative pathname base on your templateDir, without the file extname.
AutoRoot: false, // default false,if true, if the variable is not assign in the scope, will treat it as the root field of template data, otherwise you need use '$ROOT' to index the data field.
Mode: types.Smarty, // default types.Smarty, also can be "types.Gofet"
}
fet, _ := fet.New(conf)
// assign data
data := map[string]interface{}{
"Hello": "World"
}
// the index.html {%$ROOT.Hello%}
// Display
fet.Display("index.html", data, os.Stdout)
// will output: World
}
-
fet.LoadConf(configFile string) (*types.FetConfig, error)
if you use the command line
fetc
build a config filefet.config.json
, then you can usefet.LoadConf
to get the config. -
fet.New(config *types.FetConfig) (instance *Fet, error)
get a fet instance.
-
instance.Compile(tpl string, createFile bool) (result string, err error)
compile a template file, if
createFile
is true, will create the compiled file. -
instance.CompileAll() error
compile all files need to compile.
-
instance.Display(tpl string, data interface{}, output io.Wirter) error
render the parsed html code into
output
. -
instance.Fetch(tpl string, data interface{}) (result string, err error)
just get the parsed
string
code, it always useCompileOnline
mode.
-
compile mode
just use fet compile your template files offline, and add the FuncMap
lib/funcs/funcs.go
to your project. -
install mode
install
fet
,and usefet.Display(tpl, data, io.Writer)
to render the template file.