Merge pull request #261 from spf13/float-string

Support converting float string numbers to integer types

Author: sagikazarmark

number.go

@@ -10,6 +10,7 @@ import (
 	"errors"
 	"fmt"
 	"strconv"
+	"strings"
 	"time"
 )
 
@@ -391,7 +392,7 @@ func parseNumber[T Number](s string) (T, error) {
 }
 
 func parseInt[T integer](s string) (T, error) {
-	v, err := strconv.ParseInt(trimZeroDecimal(s), 0, 0)
+	v, err := strconv.ParseInt(trimDecimal(s), 0, 0)
 	if err != nil {
 		return 0, err
 	}
@@ -400,7 +401,7 @@ func parseInt[T integer](s string) (T, error) {
 }
 
 func parseUint[T unsigned](s string) (T, error) {
-	v, err := strconv.ParseUint(trimZeroDecimal(s), 0, 0)
+	v, err := strconv.ParseUint(trimDecimal(s), 0, 0)
 	if err != nil {
 		return 0, err
 	}
@@ -506,3 +507,15 @@ func trimZeroDecimal(s string) string {
 	}
 	return s
 }
+
+// trimming decimals seems significantly faster than parsing to float first
+//
+// see BenchmarkDecimal
+func trimDecimal(s string) string {
+	// trim the decimal part (if any)
+	if i := strings.Index(s, "."); i >= 0 {
+		s = s[:i]
+	}
+
+	return s
+}

number_internal_test.go

@@ -6,6 +6,7 @@
 package cast
 
 import (
+	"strconv"
 	"testing"
 
 	qt "github.com/frankban/quicktest"
@@ -42,3 +43,49 @@ func TestTrimZeroDecimal(t *testing.T) {
 	c.Assert(trimZeroDecimal("0.0000000000"), qt.Equals, "0")
 	c.Assert(trimZeroDecimal("0.00000000001"), qt.Equals, "0.00000000001")
 }
+
+func TestTrimDecimal(t *testing.T) {
+	c := qt.New(t)
+
+	c.Assert(trimDecimal("10.0"), qt.Equals, "10")
+	c.Assert(trimDecimal("10.00"), qt.Equals, "10")
+	c.Assert(trimDecimal("10.010"), qt.Equals, "10")
+	c.Assert(trimDecimal("0.0000000000"), qt.Equals, "0")
+	c.Assert(trimDecimal("0.00000000001"), qt.Equals, "0")
+}
+
+func BenchmarkDecimal(b *testing.B) {
+	testCases := []string{"10.0", "10.00", "10.010", "0.0000000000", "0.0000000001", "10.0000000000", "10.0000000001", "10000000000000.0000000000"}
+
+	for _, testCase := range testCases {
+		// TODO: remove after minimum Go version is >=1.22
+		testCase := testCase
+
+		b.Run(testCase, func(b *testing.B) {
+			b.Run("ParseFloat", func(b *testing.B) {
+				// TODO: use b.Loop() once updated to Go 1.24
+				for i := 0; i < b.N; i++ {
+					v, err := strconv.ParseFloat(testCase, 64)
+					if err != nil {
+						b.Fatal(err)
+					}
+
+					n := int64(v)
+					_ = n
+				}
+			})
+
+			b.Run("TrimDecimal", func(b *testing.B) {
+				// TODO: use b.Loop() once updated to Go 1.24
+				for i := 0; i < b.N; i++ {
+					v, err := strconv.ParseInt(trimDecimal(testCase), 0, 0)
+					if err != nil {
+						b.Fatal(err)
+					}
+
+					_ = v
+				}
+			})
+		})
+	}
+}

number_test.go

@@ -204,19 +204,22 @@ func generateNumberTestCases(samples []any) []testCase {
 		{int64(-8), eightNegative, isUint},
 		{float32(-8.31), eightPoint31Negative_32, isUint},
 		{float64(-8.31), eightPoint31Negative, isUint},
-		{"-8", eightNegative, isUint},
 
 		// Other basic types
 		{true, one, false},
 		{false, zero, false},
 		{"8", eight, false},
+		{"-8", eightNegative, isUint},
+		{"8.31", eightPoint31, false},
+		{"-8.31", eightPoint31Negative, isUint},
 		{"", zero, false},
 		{nil, zero, false},
 
 		// JSON
 		{json.Number("8"), eight, false},
 		{json.Number("-8"), eightNegative, isUint},
-		{json.Number("8.0"), eight, false},
+		{json.Number("8.31"), eightPoint31, false},
+		{json.Number("-8.31"), eightPoint31Negative, isUint},
 		{json.Number(""), zero, false},
 
 		// Failure cases

time.go

@@ -29,7 +29,11 @@ func ToTimeInDefaultLocationE(i interface{}, location *time.Location) (tim time.
 	case string:
 		return StringToDateInDefaultLocation(v, location)
 	case json.Number:
-		s, err1 := ToInt64E(v)
+		// Originally this used ToInt64E, but adding string float conversion broke ToTime.
+		// the behavior of ToTime would have changed if we continued using it.
+		// For now, using json.Number's own Int64 method should be good enough to preserve backwards compatibility.
+		v = json.Number(trimZeroDecimal(string(v)))
+		s, err1 := v.Int64()
 		if err1 != nil {
 			return time.Time{}, fmt.Errorf("unable to cast %#v of type %T to Time", i, i)
 		}