180 lines
3.4 KiB
Go
180 lines
3.4 KiB
Go
package utils
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"reflect"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
"unicode"
|
|
)
|
|
|
|
func ReplaceDownLine(req string) (res string) {
|
|
for _, v := range req {
|
|
if 64 < v && v < 91 {
|
|
res = res + "_" + string(v+32)
|
|
} else {
|
|
res += string(v)
|
|
}
|
|
}
|
|
return strings.TrimRight(strings.TrimLeft(res, "_"), "_")
|
|
}
|
|
|
|
func String(data any) string {
|
|
if data == nil {
|
|
return ""
|
|
}
|
|
switch value := data.(type) {
|
|
case int:
|
|
return strconv.Itoa(value)
|
|
case int8:
|
|
return strconv.Itoa(int(value))
|
|
case int16:
|
|
return strconv.Itoa(int(value))
|
|
case int32:
|
|
return strconv.Itoa(int(value))
|
|
case int64:
|
|
return strconv.FormatInt(value, 10)
|
|
case uint:
|
|
return strconv.FormatUint(uint64(value), 10)
|
|
case uint8:
|
|
return strconv.FormatUint(uint64(value), 10)
|
|
case uint16:
|
|
return strconv.FormatUint(uint64(value), 10)
|
|
case uint32:
|
|
return strconv.FormatUint(uint64(value), 10)
|
|
case uint64:
|
|
return strconv.FormatUint(value, 10)
|
|
case float32:
|
|
return strconv.FormatFloat(float64(value), 'f', -1, 32)
|
|
case float64:
|
|
return strconv.FormatFloat(value, 'f', -1, 64)
|
|
case bool:
|
|
return strconv.FormatBool(value)
|
|
case string:
|
|
return value
|
|
case []byte:
|
|
return string(value)
|
|
case time.Time:
|
|
if value.IsZero() {
|
|
return ""
|
|
}
|
|
return value.String()
|
|
case *time.Time:
|
|
if value == nil {
|
|
return ""
|
|
}
|
|
return value.String()
|
|
default:
|
|
// Empty checks.
|
|
if value == nil {
|
|
return ""
|
|
}
|
|
var (
|
|
rv = reflect.ValueOf(value)
|
|
kind = rv.Kind()
|
|
)
|
|
switch kind {
|
|
case reflect.Chan,
|
|
reflect.Map,
|
|
reflect.Slice,
|
|
reflect.Func,
|
|
reflect.Ptr,
|
|
reflect.Interface,
|
|
reflect.UnsafePointer:
|
|
if rv.IsNil() {
|
|
return ""
|
|
}
|
|
case reflect.String:
|
|
return rv.String()
|
|
}
|
|
if kind == reflect.Ptr {
|
|
return String(rv.Elem().Interface())
|
|
}
|
|
// Finally, we use json.Marshal to convert.
|
|
jsonContent, err := json.Marshal(value)
|
|
if err != nil {
|
|
return fmt.Sprint(value)
|
|
} else {
|
|
return string(jsonContent)
|
|
}
|
|
}
|
|
}
|
|
|
|
func IsNumber(s string) bool {
|
|
_, err := strconv.ParseFloat(s, 64)
|
|
return err == nil
|
|
}
|
|
|
|
func ContainChinese(str string) bool {
|
|
for _, r := range str {
|
|
if unicode.Is(unicode.Scripts["Han"], r) || (regexp.MustCompile("[\u3002\uff1b\uff0c\uff1a\u201c\u201d\uff08\uff09\u3001\uff1f\u300a\u300b]").MatchString(string(r))) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func Contains(ids []string, id string) bool {
|
|
for _, v := range ids {
|
|
if strings.Compare(v, id) == 0 {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// contain one of subs
|
|
func ContainSub(str string, subs ...string) bool {
|
|
for _, sub := range subs {
|
|
if strings.Contains(str, sub) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// must contain all subs
|
|
func ContainSubs(str string, subs ...string) bool {
|
|
for _, sub := range subs {
|
|
if strings.Contains(str, sub) {
|
|
continue
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func Duplicate(slc []string) []string {
|
|
result := make([]string, 0)
|
|
tempMap := make(map[string]bool, len(slc))
|
|
for _, e := range slc {
|
|
if tempMap[e] == false {
|
|
tempMap[e] = true
|
|
result = append(result, e)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
func Capitalize(str string) string {
|
|
var upperStr string
|
|
vv := []rune(str)
|
|
for i := 0; i < len(vv); i++ {
|
|
if i == 0 {
|
|
if vv[i] >= 97 && vv[i] <= 122 {
|
|
vv[i] -= 32 // string的码表相差32位
|
|
upperStr += string(vv[i])
|
|
} else {
|
|
return str
|
|
}
|
|
} else {
|
|
upperStr += string(vv[i])
|
|
}
|
|
}
|
|
return upperStr
|
|
}
|