Feat：add common template functions (#976)

* Feat：增加常用模板函数

* Feat：修改增加模板函数的实现方式

Co-authored-by: tanxiao <tanxiao@asiainfo.com>

src/pkg/tplx/common.go

@@ -0,0 +1,157 @@
+package tplx
+
+import (
+	"fmt"
+	"html/template"
+	"math"
+	"regexp"
+	"strconv"
+	"time"
+)
+
+func Unescaped(str string) interface{} {
+	return template.HTML(str)
+}
+
+func Urlconvert(str string) interface{} {
+	return template.URL(str)
+}
+
+func Timeformat(ts int64, pattern ...string) string {
+	defp := "2006-01-02 15:04:05"
+	if len(pattern) > 0 {
+		defp = pattern[0]
+	}
+	return time.Unix(ts, 0).Format(defp)
+}
+
+func Timestamp(pattern ...string) string {
+	defp := "2006-01-02 15:04:05"
+	if len(pattern) > 0 {
+		defp = pattern[0]
+	}
+	return time.Now().Format(defp)
+}
+
+func Args(args ...interface{}) map[string]interface{} {
+	result := make(map[string]interface{})
+	for i, a := range args {
+		result[fmt.Sprintf("arg%d", i)] = a
+	}
+	return result
+}
+
+func ReReplaceAll(pattern, repl, text string) string {
+	re := regexp.MustCompile(pattern)
+	return re.ReplaceAllString(text, repl)
+}
+
+func Humanize(s string) string {
+	v, err := strconv.ParseFloat(s, 64)
+	if err != nil {
+		return s
+	}
+	if v == 0 || math.IsNaN(v) || math.IsInf(v, 0) {
+		return fmt.Sprintf("%.2f", v)
+	}
+	if math.Abs(v) >= 1 {
+		prefix := ""
+		for _, p := range []string{"k", "M", "G", "T", "P", "E", "Z", "Y"} {
+			if math.Abs(v) < 1000 {
+				break
+			}
+			prefix = p
+			v /= 1000
+		}
+		return fmt.Sprintf("%.2f%s", v, prefix)
+	}
+	prefix := ""
+	for _, p := range []string{"m", "u", "n", "p", "f", "a", "z", "y"} {
+		if math.Abs(v) >= 1 {
+			break
+		}
+		prefix = p
+		v *= 1000
+	}
+	return fmt.Sprintf("%.2f%s", v, prefix)
+}
+
+func Humanize1024(s string) string {
+	v, err := strconv.ParseFloat(s, 64)
+	if err != nil {
+		return s
+	}
+	if math.Abs(v) <= 1 || math.IsNaN(v) || math.IsInf(v, 0) {
+		return fmt.Sprintf("%.4g", v)
+	}
+	prefix := ""
+	for _, p := range []string{"ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi", "Yi"} {
+		if math.Abs(v) < 1024 {
+			break
+		}
+		prefix = p
+		v /= 1024
+	}
+	return fmt.Sprintf("%.4g%s", v, prefix)
+}
+
+func HumanizeDuration(s string) string {
+	v, err := strconv.ParseFloat(s, 64)
+	if err != nil {
+		return s
+	}
+	if math.IsNaN(v) || math.IsInf(v, 0) {
+		return fmt.Sprintf("%.4g", v)
+	}
+	if v == 0 {
+		return fmt.Sprintf("%.4gs", v)
+	}
+	if math.Abs(v) >= 1 {
+		sign := ""
+		if v < 0 {
+			sign = "-"
+			v = -v
+		}
+		seconds := int64(v) % 60
+		minutes := (int64(v) / 60) % 60
+		hours := (int64(v) / 60 / 60) % 24
+		days := int64(v) / 60 / 60 / 24
+		// For days to minutes, we display seconds as an integer.
+		if days != 0 {
+			return fmt.Sprintf("%s%dd %dh %dm %ds", sign, days, hours, minutes, seconds)
+		}
+		if hours != 0 {
+			return fmt.Sprintf("%s%dh %dm %ds", sign, hours, minutes, seconds)
+		}
+		if minutes != 0 {
+			return fmt.Sprintf("%s%dm %ds", sign, minutes, seconds)
+		}
+		// For seconds, we display 4 significant digits.
+		return fmt.Sprintf("%s%.4gs", sign, v)
+	}
+	prefix := ""
+	for _, p := range []string{"m", "u", "n", "p", "f", "a", "z", "y"} {
+		if math.Abs(v) >= 1 {
+			break
+		}
+		prefix = p
+		v *= 1000
+	}
+	return fmt.Sprintf("%.4g%ss", v, prefix)
+}
+
+func HumanizePercentage(s string) string {
+	v, err := strconv.ParseFloat(s, 64)
+	if err != nil {
+		return s
+	}
+	return fmt.Sprintf("%.2f%%", v*100)
+}
+
+func HumanizePercentageH(s string) string {
+	v, err := strconv.ParseFloat(s, 64)
+	if err != nil {
+		return s
+	}
+	return fmt.Sprintf("%.2f%%", v)
+}

src/pkg/tplx/tplx.go

@@ -2,24 +2,23 @@ package tplx
 
 import (
 	"html/template"
-	"time"
+	"regexp"
+	"strings"
 )
 
 var TemplateFuncMap = template.FuncMap{
-	"unescaped":  func(str string) interface{} { return template.HTML(str) },
+	"unescaped":           Unescaped,
-	"urlconvert": func(str string) interface{} { return template.URL(str) },
+	"urlconvert":          Urlconvert,
-	"timeformat": func(ts int64, pattern ...string) string {
+	"timeformat":          Timeformat,
-		defp := "2006-01-02 15:04:05"
+	"timestamp":           Timestamp,
-		if len(pattern) > 0 {
+	"args":                Args,
-			defp = pattern[0]
+	"reReplaceAll":        ReReplaceAll,
-		}
+	"match":               regexp.MatchString,
-		return time.Unix(ts, 0).Format(defp)
+	"toUpper":             strings.ToUpper,
-	},
+	"toLower":             strings.ToLower,
-	"timestamp": func(pattern ...string) string {
+	"humanize":            Humanize,
-		defp := "2006-01-02 15:04:05"
+	"humanize1024":        Humanize1024,
-		if len(pattern) > 0 {
+	"humanizeDuration":    HumanizeDuration,
-			defp = pattern[0]
+	"humanizePercentage":  HumanizePercentage,
-		}
+	"humanizePercentageH": HumanizePercentageH,
-		return time.Now().Format(defp)
-	},
 }