base

var CheckCnEnNumStr = func(str interface{}) bool {

	match, _ := regexp.MatchString(`^[\w\p{Han}\s\,\.\!\?\+\-\(\)\\、，。！？（）@#￥%/|]+$`, fmt.Sprint(str))
	return match
}

var CheckDirExistsWithCreate = func(p string) bool {
	if !PathExists(p) {
		return MakeDirs(p)
	}
	return true
}

var CheckEmail = func(str interface{}) bool {
	match, _ := regexp.MatchString(`^[a-zA-Z0-9]+([._\-][a-zA-Z0-9]+)*@([a-zA-Z0-9]+([._\-][a-zA-Z0-9]+))+$`, fmt.Sprint(str))
	return match
}

var CheckEnStr = func(str interface{}) bool {
	match, _ := regexp.MatchString(`^[a-zA-Z\d]$+`, fmt.Sprint(str))
	return match
}

var CheckInt = func(str interface{}) bool {
	match, _ := regexp.MatchString(`^\d+$`, fmt.Sprint(str))
	return match
}

var CheckInts = func(str interface{}) bool {
	match, _ := regexp.MatchString(`^\d*(\d+\,)*\d+$`, fmt.Sprint(str))
	return match
}

var CheckPhone = func(str interface{}) bool {
	match, _ := regexp.MatchString(`^1[\d]{10}$`, fmt.Sprint(str))
	return match
}

var CheckTimestamp = func(str interface{}) bool {
	match, _ := regexp.MatchString(`^\d{10}$`, fmt.Sprint(str))
	return match
}

var CheckUniqueStr = func(str interface{}) bool {
	match, _ := regexp.MatchString(`^[\w\-]+$`, fmt.Sprint(str))
	return match
}

var CheckUniqueStrWithLen = func(str interface{}, len int) bool {
	match, _ := regexp.MatchString(fmt.Sprintf(`^[\w\-]{%d}$`, len), fmt.Sprint(str))
	return match
}

var CheckUniqueStrWithRan = func(str interface{}, min int, max int) bool {
	match, _ := regexp.MatchString(fmt.Sprintf(`^[\w\-]{%d,%d}$`, min, max), fmt.Sprint(str))
	return match
}

var CheckWStr = func(str interface{}) bool {
	match, _ := regexp.MatchString(`^\w+$`, fmt.Sprint(str))
	return match
}

var CheckWStrWithLen = func(str interface{}, len int) bool {
	match, _ := regexp.MatchString(fmt.Sprintf(`^\w{%d}$`, len), fmt.Sprint(str))
	return match
}

var CheckWStrWithRan = func(str interface{}, min int, max int) bool {
	match, _ := regexp.MatchString(fmt.Sprintf(`^\w{%d,%d}$`, min, max), fmt.Sprint(str))
	return match
}

var FileMd5 = func(path string) string {
	f, e := os.Open(path)
	if e != nil {
		return ""
	}
	defer f.Close()
	m := md5.New()
	io.Copy(m, f)
	return hex.EncodeToString(m.Sum(nil))
}

var InterfaceToFloat32 = func(val interface{}) float32 {
	return float32(InterfaceToFloat64(val))
}

var InterfaceToFloat64 = func(val interface{}) float64 {
	f, _ := strconv.ParseFloat(InterfaceToString(val), 64)
	return f
}

var InterfaceToInt = func(val interface{}) int {
	return int(InterfaceToInt64(val))
}

var InterfaceToInt32 = func(val interface{}) int32 {
	return int32(InterfaceToInt64(val))
}

var InterfaceToInt64 = func(val interface{}) int64 {
	i, _ := strconv.ParseInt(InterfaceToString(val), 10, 64)
	return i
}

var InterfaceToMapWithStringInterface = func(val interface{}) map[string]interface{} {

	if reflect.TypeOf(val).Kind() == reflect.Map {
		return val.(map[string]interface{})
	}
	return map[string]interface{}{}
}

var InterfaceToString = func(val interface{}) string {
	tf := reflect.TypeOf(val)
	if tf == nil {
		return ""
	}
	switch tf.Kind() {
	case reflect.Map:
		fmt.Println("Map:", val)
		return ""
	case reflect.Chan:
		fmt.Println("Map:", val)
		return ""
	}
	fmt.Println("反射类型", reflect.TypeOf(val))
	fmt.Println("反射类型", reflect.TypeOf(val).Kind())
	return fmt.Sprint(val)
}

var MakeDirs = func(path string) bool {
	err := os.MkdirAll(path, os.ModePerm)
	if err != nil {
		return false
	}
	return true
}

var PathExists = func(path string) bool {
	_, err := os.Stat(path)
	if err != nil {
		if os.IsNotExist(err) {
			return false
		}
	}
	return true
}

var RebuildScienceNumToString = func(numStr string) string {
	if strings.Contains(numStr, "e+") {

		decimalNum, err := decimal.NewFromString(numStr)
		if err != nil {
			Error("获取科学计数数值出错", err)
			return numStr
		}
		decimalStr := decimalNum.String()
		return decimalStr
	}
	return numStr
}

var RunRootPath = func() (string, error) {
	f, e := os.Executable()

	if e != nil {
		return "", e
	}
	p := filepath.Dir(f)
	return p, nil
}