✨ feat: Update Slice function parameters, add noConv to control type …

…conversion

ztype/slice.go

@@ -2,6 +2,7 @@ package ztype
 
 import (
 	"encoding/json"
+	"reflect"
 
 	"github.com/sohaha/zlsgo/zreflect"
 )
@@ -72,8 +73,8 @@ func (s SliceType) Maps() Maps {
 // }
 
 // Deprecated: please use ToSlice
-func Slice(value interface{}) SliceType {
-	return ToSlice(value)
+func Slice(value interface{}, noConv ...bool) SliceType {
+	return ToSlice(value, noConv...)
 }
 
 // SliceStrToAny  []string to []interface{}
@@ -85,10 +86,10 @@ func SliceStrToAny(slice []string) []interface{} {
 	return ss
 }
 
-func ToSlice(value interface{}) SliceType {
-	s := SliceType{}
+func ToSlice(value interface{}, noConv ...bool) (s SliceType) {
+	s = SliceType{}
 	if value == nil {
-		return s
+		return
 	}
 
 	switch val := value.(type) {
@@ -102,19 +103,38 @@ func ToSlice(value interface{}) SliceType {
 		for i := range val {
 			s = append(s, New(val[i]))
 		}
-	case string:
-		if val != "" {
-			s = append(s, New(val))
+	case []int:
+		s = make(SliceType, 0, len(val))
+		for i := range val {
+			s = append(s, New(val[i]))
+		}
+	case []int64:
+		s = make(SliceType, 0, len(val))
+		for i := range val {
+			s = append(s, New(val[i]))
 		}
 	default:
 		var nval []interface{}
-		if conv.to("", value, zreflect.ValueOf(&nval)) == nil {
-			s = make(SliceType, 0, len(nval))
-			for i := range nval {
-				s = append(s, New(nval[i]))
+		vof := zreflect.ValueOf(&nval)
+		to := func() {
+			if conv.to("", value, vof) == nil {
+				s = make(SliceType, 0, len(nval))
+				for i := range nval {
+					s = append(s, New(nval[i]))
+				}
+			}
+		}
+
+		switch vof.Type().Kind() {
+		case reflect.Slice:
+			to()
+		default:
+			if len(noConv) > 0 && noConv[0] {
+				return
 			}
+			to()
 		}
 	}
 
-	return s
+	return
 }

ztype/slice_test.go

@@ -1,6 +1,7 @@
 package ztype
 
 import (
+	"encoding/json"
 	"testing"
 
 	"github.com/sohaha/zlsgo"
@@ -9,7 +10,7 @@ import (
 func TestSlice(t *testing.T) {
 	tt := zlsgo.NewTest(t)
 	value := "ddd"
-	res := Slice(value)
+	res := Slice(value, false)
 	tt.Log(res)
 
 	res = Slice([]interface{}{"1", 2, 3.0})
@@ -23,11 +24,18 @@ func TestSlice(t *testing.T) {
 	tt.Equal([]int{0}, res.Int())
 	tt.Equal([]string{`{"h":"ddd"}`}, res.String())
 	tt.Equal(map[string]interface{}{"h": "ddd"}, res.Index(0).Value())
+	tt.Equal("10086", res.Index(110).String("10086"))
+
+	tt.Equal([]string{"1", "2"}, ToSlice([]int{1, 2}).String())
+	tt.Equal([]string{"1", "2"}, ToSlice([]int64{1, 2}).String())
 
 	rmaps := res.Maps()
 	tt.Equal(Maps{{"h": "ddd"}}, rmaps)
 
 	tt.Equal("[]interface {}", GetType(res.Value()))
+
+	j, _ := json.Marshal(res)
+	tt.Equal(`[{"h":"ddd"}]`, string(j))
 }
 
 func TestSliceStrToIface(t *testing.T) {
@@ -37,3 +45,39 @@ func TestSliceStrToIface(t *testing.T) {
 	tt.Equal(len(value), len(res))
 	t.Log(res)
 }
+
+func TestSliceForce(t *testing.T) {
+	tt := zlsgo.NewTest(t)
+
+	value := "test"
+
+	tt.Equal([]string{"test"}, ToSlice(value).String())
+	tt.Equal([]string{}, ToSlice(value, true).String())
+}
+
+func BenchmarkSlice(b *testing.B) {
+
+	b.Run("str", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			ToSlice("test").String()
+		}
+	})
+
+	b.Run("str_no", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			ToSlice("test", true).String()
+		}
+	})
+
+	b.Run("int", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			ToSlice([]int{1, 2, 3}).String()
+		}
+	})
+
+	b.Run("any", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			ToSlice([]interface{}{1, 2, 3}).String()
+		}
+	})
+}

ztype/type.go

@@ -138,23 +138,23 @@ func (t Type) Maps() Maps {
 	return t.Slice().Maps()
 }
 
-func (t Type) Slice() SliceType {
+func (t Type) Slice(noConv ...bool) SliceType {
 	if t.v == nil {
 		return SliceType{}
 	}
-	return ToSlice(t.v)
+	return ToSlice(t.v, noConv...)
 }
 
-func (t Type) SliceValue() []interface{} {
-	return t.Slice().Value()
+func (t Type) SliceValue(noConv ...bool) []interface{} {
+	return t.Slice(noConv...).Value()
 }
 
-func (t Type) SliceString() []string {
-	return t.Slice().String()
+func (t Type) SliceString(noConv ...bool) []string {
+	return t.Slice(noConv...).String()
 }
 
-func (t Type) SliceInt() []int {
-	return t.Slice().Int()
+func (t Type) SliceInt(noConv ...bool) []int {
+	return t.Slice(noConv...).Int()
 }
 
 func (t Type) Exists() bool {