feat: add xxOrErr convert func for str, math pkg

errorx/stack.go

@@ -146,7 +146,7 @@ var stdOpt = newErrOpt()
 func newErrOpt() *ErrStackOpt {
 	return &ErrStackOpt{
 		SkipDepth:  3,
-		TraceDepth: 6,
+		TraceDepth: 8,
 	}
 }
 

mathutil/convert.go

@@ -45,7 +45,12 @@ func IntOrPanic(in interface{}) int {
 	return val
 }
 
-// ToInt convert string to int
+// IntOrErr convert value to int, return error on failed
+func IntOrErr(in interface{}) (iVal int, err error) {
+	return ToInt(in)
+}
+
+// ToInt convert value to int, return error on failed
 func ToInt(in interface{}) (iVal int, err error) {
 	switch tVal := in.(type) {
 	case nil:
@@ -92,7 +97,7 @@ func ToInt(in interface{}) (iVal int, err error) {
  * convert value to uint
  *************************************************************/
 
-// Uint convert string to uint
+// Uint convert string to uint, return error on failed
 func Uint(in interface{}) (uint64, error) {
 	return ToUint(in)
 }
@@ -103,13 +108,18 @@ func QuietUint(in interface{}) uint64 {
 	return val
 }
 
-// MustUint convert string to uint
+// MustUint convert string to uint, will panic on error
 func MustUint(in interface{}) uint64 {
 	val, _ := ToUint(in)
 	return val
 }
 
-// ToUint convert string to uint
+// UintOrErr convert value to uint, return error on failed
+func UintOrErr(in interface{}) (uint64, error) {
+	return ToUint(in)
+}
+
+// ToUint convert value to uint, return error on failed
 func ToUint(in interface{}) (u64 uint64, err error) {
 	switch tVal := in.(type) {
 	case nil:
@@ -156,7 +166,7 @@ func ToUint(in interface{}) (u64 uint64, err error) {
  * convert value to int64
  *************************************************************/
 
-// Int64 convert string to int64
+// Int64 convert string to int64, return error on failed
 func Int64(in interface{}) (int64, error) {
 	return ToInt64(in)
 }
@@ -167,15 +177,20 @@ func QuietInt64(in interface{}) int64 {
 	return i64
 }
 
-// MustInt64 convert
+// MustInt64 convert value to int64, will panic on error
 func MustInt64(in interface{}) int64 {
 	i64, _ := ToInt64(in)
 	return i64
 }
 
 // TODO StrictInt64,AsInt64 strict convert to int64
 
-// ToInt64 convert string to int64
+// Int64OrErr convert string to int64, return error on failed
+func Int64OrErr(in interface{}) (int64, error) {
+	return ToInt64(in)
+}
+
+// ToInt64 convert string to int64, return error on failed
 func ToInt64(in interface{}) (i64 int64, err error) {
 	switch tVal := in.(type) {
 	case nil:
@@ -241,12 +256,17 @@ func MustFloat(in interface{}) float64 {
 	return val
 }
 
-// Float convert value to float64
+// Float convert value to float64, return error on failed
 func Float(in interface{}) (float64, error) {
 	return ToFloat(in)
 }
 
-// ToFloat convert value to float64
+// FloatOrErr convert value to float64, return error on failed
+func FloatOrErr(in interface{}) (float64, error) {
+	return ToFloat(in)
+}
+
+// ToFloat convert value to float64, return error on failed
 func ToFloat(in interface{}) (f64 float64, err error) {
 	switch tVal := in.(type) {
 	case nil:
@@ -352,11 +372,16 @@ func MustString(val interface{}) string {
 	return StringOrPanic(val)
 }
 
-// ToString convert intX/floatX value to string
+// ToString convert intX/floatX value to string, return error on failed
 func ToString(val interface{}) (string, error) {
 	return TryToString(val, true)
 }
 
+// StringOrErr convert intX/floatX value to string, return error on failed
+func StringOrErr(val interface{}) (string, error) {
+	return TryToString(val, true)
+}
+
 // QuietString convert intX/floatX value to string, other type convert by fmt.Sprint
 func QuietString(val interface{}) string {
 	str, _ := TryToString(val, false)

mathutil/convert_test.go

@@ -35,6 +35,10 @@ func TestToInt(t *testing.T) {
 	is.Nil(err)
 	is.Equal(-2, intVal)
 
+	intVal, err = IntOrErr("-2")
+	is.Nil(err)
+	is.Equal(-2, intVal)
+
 	is.Equal(-2, MustInt("-2"))
 	for _, in := range tests {
 		is.Equal(2, MustInt(in))
@@ -49,6 +53,10 @@ func TestToInt(t *testing.T) {
 	is.Nil(err)
 	is.Equal(uint64(2), uintVal)
 
+	uintVal, err = UintOrErr("2")
+	is.Nil(err)
+	is.Equal(uint64(2), uintVal)
+
 	_, err = ToUint("-2")
 	is.Error(err)
 
@@ -70,6 +78,10 @@ func TestToInt(t *testing.T) {
 	is.Nil(err)
 	is.Equal(int64(-2), i64Val)
 
+	i64Val, err = Int64OrErr("-2")
+	is.Nil(err)
+	is.Equal(int64(-2), i64Val)
+
 	for _, in := range tests {
 		is.Equal(int64(2), MustInt64(in))
 	}
@@ -101,6 +113,10 @@ func TestToString(t *testing.T) {
 		is.Equal("2", val)
 	}
 
+	val, err := StringOrErr(2)
+	is.NoError(err)
+	is.Equal("2", val)
+
 	is.Panics(func() {
 		MustString("2")
 	})
@@ -134,4 +150,8 @@ func TestToFloat(t *testing.T) {
 	fltVal, err = Float("-123.5")
 	is.Nil(err)
 	is.Equal(-123.5, fltVal)
+
+	fltVal, err = FloatOrErr("-123.5")
+	is.Nil(err)
+	is.Equal(-123.5, fltVal)
 }

strutil/convert.go

@@ -64,12 +64,17 @@ func QuietString(in interface{}) string {
 	return val
 }
 
-// MustString convert value to string
+// MustString convert value to string, TODO will panic on error
 func MustString(in interface{}) string {
 	val, _ := AnyToString(in, false)
 	return val
 }
 
+// StringOrErr convert value to string, return error on failed
+func StringOrErr(val interface{}) (string, error) {
+	return AnyToString(val, true)
+}
+
 // ToString convert value to string
 func ToString(val interface{}) (string, error) {
 	return AnyToString(val, true)

strutil/convert_test.go

@@ -97,6 +97,10 @@ func TestAnyToString(t *testing.T) {
 	is.NoError(err)
 	is.Equal("true", str)
 
+	str, err = strutil.StringOrErr(true)
+	is.NoError(err)
+	is.Equal("true", str)
+
 	str, err = strutil.String(nil)
 	is.NoError(err)
 	is.Equal("", str)

strutil/format.go

@@ -125,6 +125,7 @@ func Camel(s string, sep ...string) string {
 }
 
 // CamelCase convert string to camel case.
+//
 // Support:
 // 	"range_price" -> "rangePrice"
 // 	"range price" -> "rangePrice"