refactor

Author: ahl5esoft

README.md

@@ -0,0 +1,46 @@
+package underscore
+
+import "reflect"
+
+func (m enumerable) Distinct(selector interface{}) IEnumerable {
+	if selector == nil {
+		selector = func(value, _ interface{}) facade {
+			return facade{
+				reflect.ValueOf(value),
+			}
+		}
+	}
+
+	return enumerable{
+		Enumerator: func() IEnumerator {
+			iterator := m.GetEnumerator()
+			selectorRV := reflect.ValueOf(selector)
+			set := make(map[interface{}]bool)
+			return &enumerator{
+				MoveNextFunc: func() (valueRV reflect.Value, keyRV reflect.Value, ok bool) {
+					for ok = iterator.MoveNext(); ok; ok = iterator.MoveNext() {
+						valueRV = iterator.GetValue()
+						keyRV = iterator.GetKey()
+						v := getRV(
+							selectorRV.Call([]reflect.Value{valueRV, keyRV})[0],
+						).Interface()
+						if _, has := set[v]; !has {
+							set[v] = true
+							return
+						}
+					}
+					return
+				},
+			}
+		},
+	}
+}
+
+func (m enumerable) DistinctBy(fieldName string) IEnumerable {
+	getter := PropertyRV(fieldName)
+	return m.Distinct(func(value, _ interface{}) facade {
+		return facade{
+			getter(value),
+		}
+	})
+}

distinct.go

@@ -0,0 +1,36 @@
+package underscore
+
+import "testing"
+
+func Test_Distinct(t *testing.T) {
+	src := []int{1, 2, 1, 4, 1, 3}
+	dst := make([]int, 0)
+	Chain2(src).Distinct(func(n, _ int) (int, error) {
+		return n % 2, nil
+	}).Value(&dst)
+	if len(dst) != 2 {
+		t.Error(dst)
+	}
+}
+
+func Test_Distinct_SelectorIsNil(t *testing.T) {
+	src := []int{1, 2, 1, 4, 1, 3}
+	dst := make([]int, 0)
+	Chain2(src).Distinct(nil).Value(&dst)
+	if len(dst) != 4 {
+		t.Error(dst)
+	}
+}
+
+func Test_DistinctBy(t *testing.T) {
+	src := []testModel{
+		{ID: 1, Name: "a"},
+		{ID: 2, Name: "a"},
+		{ID: 3, Name: "a"},
+	}
+	dst := make([]testModel, 0)
+	Chain2(src).DistinctBy("name").Value(&dst)
+	if len(dst) != 1 {
+		t.Error(dst)
+	}
+}

distinct_test.go

@@ -16,11 +16,7 @@ func (m enumerator) GetKey() reflect.Value {
 }
 
 func (m enumerator) GetValue() reflect.Value {
-	if m.value.Type() == facadeRT {
-		return m.value.Interface().(facade).Real
-	}
-
-	return m.value
+	return getRV(m.value)
 }
 
 func (m *enumerator) MoveNext() (ok bool) {

enumerator.go

@@ -1,18 +1,15 @@
 package underscore
 
-import (
-	"reflect"
-)
+import "reflect"
 
-// FindIndex is 根据断言函数获取下标
-func FindIndex(source, predicate interface{}) int {
+func (m *query) FindIndex(predicate interface{}) int {
 	index := -1
 
-	if !IsArray(source) {
+	if !IsArray(m.Source) {
 		return index
 	}
 
-	each(source, predicate, func(okRV, _, keyRV reflect.Value) bool {
+	each(m.Source, predicate, func(okRV, _, keyRV reflect.Value) bool {
 		ok := okRV.Bool()
 		if ok {
 			index = int(keyRV.Int())
@@ -23,17 +20,33 @@ func FindIndex(source, predicate interface{}) int {
 	return index
 }
 
-// FindIndexBy is 根据字典获取下标
-func FindIndexBy(source interface{}, properties map[string]interface{}) int {
-	return FindIndex(source, func(item interface{}, _ int) bool {
+func (m *query) FindIndexBy(properties map[string]interface{}) int {
+	return m.FindIndex(func(item interface{}, _ int) bool {
 		return IsMatch(item, properties)
 	})
 }
 
-func (m *query) FindIndex(predicate interface{}) int {
-	return FindIndex(m.Source, predicate)
+func (m enumerable) FindIndex(predicate interface{}) int {
+	iterator := m.GetEnumerator()
+	predicateRV := reflect.ValueOf(predicate)
+	index := 0
+	for ok := iterator.MoveNext(); ok; ok = iterator.MoveNext() {
+		returnRVs := predicateRV.Call([]reflect.Value{
+			iterator.GetValue(),
+			iterator.GetKey(),
+		})
+		if returnRVs[0].Bool() {
+			return index
+		}
+
+		index++
+	}
+
+	return -1
 }
 
-func (m *query) FindIndexBy(properties map[string]interface{}) int {
-	return FindIndexBy(m.Source, properties)
+func (m enumerable) FindIndexBy(dict map[string]interface{}) int {
+	return m.FindIndex(func(v, _ interface{}) bool {
+		return IsMatch(v, dict)
+	})
 }

find-index.go

@@ -1,61 +1,47 @@
 package underscore
 
-import (
-	"testing"
-)
+import "testing"
 
-func Test_FindIndex(t *testing.T) {
-	arr := []testModel{
-		{ID: 1, Name: "one"},
-		{ID: 1, Name: "two"},
-		{ID: 1, Name: "three"},
-	}
-	i := FindIndex(arr, func(r testModel, _ int) bool {
-		return r.Name == arr[1].Name
-	})
-	if i != 1 {
-		t.Error("wrong")
+func Benchmark_FindIndex(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		Range(1, benchmarkSize, 1).FindIndex(func(r, _ int) bool {
+			return r == 200
+		})
 	}
 }
 
-func Test_FindIndexBy(t *testing.T) {
-	arr := []testModel{
-		{ID: 1, Name: "one"},
-		{ID: 2, Name: "two"},
-		{ID: 3, Name: "three"},
-	}
-	i := FindIndexBy(arr, map[string]interface{}{
-		"id": 1,
-	})
-	if i != 0 {
-		t.Error("wrong")
+func Benchmark_FindIndex_New(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		Range2(1, benchmarkSize, 1).FindIndex(func(r, _ int) bool {
+			return r == 200
+		})
 	}
 }
 
-func Test_Chain_FindIndex(t *testing.T) {
-	arr := []testModel{
+func Test_FindIndex(t *testing.T) {
+	src := []testModel{
 		{ID: 1, Name: "one"},
 		{ID: 2, Name: "two"},
 		{ID: 3, Name: "three"},
 	}
-	index := Chain(arr).FindIndex(func(r testModel, _ int) bool {
-		return r.Name == arr[1].Name
+	index := Chain2(src).FindIndex(func(r testModel, _ int) bool {
+		return r.Name == src[1].Name
 	})
 	if index != 1 {
 		t.Error("wrong")
 	}
 }
 
-func Test_Chain_FindIndexBy(t *testing.T) {
-	arr := []testModel{
+func Test_FindIndexBy(t *testing.T) {
+	src := []testModel{
 		{ID: 1, Name: "one"},
 		{ID: 2, Name: "two"},
 		{ID: 3, Name: "three"},
 	}
-	index := Chain(arr).FindIndexBy(map[string]interface{}{
+	index := Chain2(src).FindIndexBy(map[string]interface{}{
 		"id": 1,
 	})
-	if index == -1 || arr[index].ID != 1 {
+	if index == -1 || src[index].ID != 1 {
 		t.Error("wrong")
 	}
 }

find-index_test.go

@@ -6,14 +6,27 @@ type IEnumerable interface {
 	AllBy(dict map[string]interface{}) bool
 	Any(predicate interface{}) bool
 	AnyBy(dict map[string]interface{}) bool
+	Distinct(selector interface{}) IEnumerable
+	DistinctBy(fieldName string) IEnumerable
 	Each(action interface{})
 	Filter(predicate interface{}) IEnumerable
 	FilterBy(dict map[string]interface{}) IEnumerable
 	Find(predicate interface{}) IEnumerable
 	FindBy(dict map[string]interface{}) IEnumerable
+	FindIndex(predicate interface{}) int
+	FindIndexBy(dict map[string]interface{}) int
 	First() IEnumerable
 	GetEnumerator() IEnumerator
+	Keys() IEnumerable
+	Map(selector interface{}) IEnumerable
+	MapBy(fieldName string) IEnumerable
+	Object() IEnumerable
+	Select(selector interface{}) IEnumerable
+	SelectBy(fieldName string) IEnumerable
+	Uniq(selector interface{}) IEnumerable
+	UniqBy(fieldName string) IEnumerable
 	Value(res interface{})
+	Values() IEnumerable
 	Where(predicate interface{}) IEnumerable
 	WhereBy(dict map[string]interface{}) IEnumerable
 }

i-enumerable.go

@@ -1,21 +1,30 @@
 package underscore
 
-import (
-	"reflect"
-)
+import "reflect"
 
-// Keys is 获取map的所有key
-func Keys(source interface{}) interface{} {
-	sourceRV := reflect.ValueOf(source)
-	if sourceRV.Kind() != reflect.Map {
-		return nil
-	}
-	return Map(source, func(_, key interface{}) facade {
+func (m *query) Keys() IQuery {
+	m.Source = m.Map(func(_, key interface{}) facade {
 		return facade{reflect.ValueOf(key)}
 	})
+	return m
 }
 
-func (m *query) Keys() IQuery {
-	m.Source = Keys(m.Source)
-	return m
+func (m enumerable) Keys() IEnumerable {
+	return enumerable{
+		Enumerator: func() IEnumerator {
+			index := 0
+			iterator := m.GetEnumerator()
+			return &enumerator{
+				MoveNextFunc: func() (valueRV reflect.Value, keyRV reflect.Value, ok bool) {
+					if ok = iterator.MoveNext(); ok {
+						valueRV = iterator.GetKey()
+						keyRV = reflect.ValueOf(index)
+						index++
+					}
+
+					return
+				},
+			}
+		},
+	}
 }

keys.go

@@ -1,49 +1,30 @@
 package underscore
 
-import (
-	"testing"
-)
+import "testing"
 
 func Test_Keys_Array(t *testing.T) {
-	arr := []string{"aa"}
-	res := Keys(arr)
-	if res != nil {
-		t.Error(res)
+	src := []string{"aa", "bb", "cc"}
+	dst := make([]int, 0)
+	Chain2(src).Keys().Value(&dst)
+	if len(dst) != len(src) {
+		t.Fatal(dst)
 	}
-}
-
-func Test_Keys_Hash(t *testing.T) {
-	dict := map[int]string{
-		1: "a",
-		2: "b",
-		3: "c",
-		4: "d",
-	}
-	res := Keys(dict).([]int)
-	if len(res) != len(dict) {
-		t.Error(res)
-	}
-}
 
-func Test_Chain_Keys_Array(t *testing.T) {
-	arr := []string{"aa"}
-	res := make([]string, 0)
-	Chain(arr).Keys().Value(&res)
-	if len(res) != 0 {
-		t.Error(res)
+	if dst[0] != 0 {
+		t.Error(dst)
 	}
 }
 
-func Test_Chain_Keys_Hash(t *testing.T) {
-	dict := map[int]string{
+func Test_Keys_Map(t *testing.T) {
+	src := map[int]string{
 		1: "a",
 		2: "b",
 		3: "c",
 		4: "d",
 	}
-	res := make([]int, 0)
-	Chain(dict).Keys().Value(&res)
-	if len(res) != len(dict) {
-		t.Error("wrong")
+	dst := make([]int, 0)
+	Chain2(src).Keys().Value(&dst)
+	if len(dst) != len(src) {
+		t.Fatal(dst)
 	}
 }

keys_test.go

@@ -42,3 +42,11 @@ func (m *query) MapBy(property string) IQuery {
 	m.Source = MapBy(m.Source, property)
 	return m
 }
+
+func (m enumerable) Map(selector interface{}) IEnumerable {
+	return m.Select(selector)
+}
+
+func (m enumerable) MapBy(fieldName string) IEnumerable {
+	return m.SelectBy(fieldName)
+}