CN.1875084792839892:699d29e5c3139b2c78a122f205653347_692eb5bd4e3c2243f51002eb.692eb9124e3c2243f5100431.692eb9124901274f8a90ef36:Trae CN.T(2025/12/2 18:01:54)

Author: ahl5esoft

i-enumerable.go

@@ -32,8 +32,8 @@ type IEnumerable interface {
 	MapMany(selector interface{}) IEnumerable
 	MapManyBy(fieldName string) IEnumerable
 	Object() IEnumerable
-	Order(selector interface{}) IEnumerable
-	OrderBy(fieldName string) IEnumerable
+	Order(selectors ...interface{}) IEnumerable
+	OrderBy(fieldNames ...string) IEnumerable
 	Reduce(fn interface{}, memo interface{}) IEnumerable
 	Reject(predicate interface{}) IEnumerable
 	RejectBy(fields map[string]interface{}) IEnumerable

order.go

@@ -2,25 +2,29 @@ package underscore
 
 import "sort"
 
-func (m enumerable) Order(selector interface{}) IEnumerable {
+func (m enumerable) Order(selectors ...interface{}) IEnumerable {
 	return enumerable{
 		Enumerator: func() IEnumerator {
 			s := new(sorter)
 			s.Sort(
 				m.GetEnumerator(),
-				selector,
+				selectors...,
 			)
 			sort.Sort(s)
 			return chainFromValue(s.ValuesValue).GetEnumerator()
 		},
 	}
 }
 
-func (m enumerable) OrderBy(fieldName string) IEnumerable {
-	getter := FieldValue(fieldName)
-	return m.Order(func(value, _ interface{}) facade {
-		return facade{
-			getter(value),
+func (m enumerable) OrderBy(fieldNames ...string) IEnumerable {
+	selectors := make([]interface{}, len(fieldNames))
+	for i, fieldName := range fieldNames {
+		getter := FieldValue(fieldName)
+		selectors[i] = func(value, _ interface{}) facade {
+			return facade{
+				getter(value),
+			}
 		}
-	})
+	}
+	return m.Order(selectors...)
 }

sorter.go

@@ -3,28 +3,30 @@ package underscore
 import "reflect"
 
 type sorter struct {
-	KeysValue   reflect.Value
+	KeysValues  []reflect.Value
 	ValuesValue reflect.Value
 }
 
 func (m sorter) Len() int {
-	if m.KeysValue.IsValid() {
-		return m.KeysValue.Len()
+	if len(m.KeysValues) > 0 && m.KeysValues[0].IsValid() {
+		return m.KeysValues[0].Len()
 	}
 
 	return 0
 }
 
 func (m sorter) Swap(i, j int) {
-	temp := m.KeysValue.Index(i).Interface()
-	m.KeysValue.Index(i).Set(
-		m.KeysValue.Index(j),
-	)
-	m.KeysValue.Index(j).Set(
-		reflect.ValueOf(temp),
-	)
+	for _, keysValue := range m.KeysValues {
+		temp := keysValue.Index(i).Interface()
+		keysValue.Index(i).Set(
+			keysValue.Index(j),
+		)
+		keysValue.Index(j).Set(
+			reflect.ValueOf(temp),
+		)
+	}
 
-	temp = m.ValuesValue.Index(i).Interface()
+	temp := m.ValuesValue.Index(i).Interface()
 	m.ValuesValue.Index(i).Set(
 		m.ValuesValue.Index(j),
 	)
@@ -34,39 +36,71 @@ func (m sorter) Swap(i, j int) {
 }
 
 func (m sorter) Less(i, j int) bool {
-	thisRV := m.KeysValue.Index(i)
-	thatRV := m.KeysValue.Index(j)
-	switch thisRV.Kind() {
-	case reflect.Float32, reflect.Float64:
-		return thisRV.Float() < thatRV.Float()
-	case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64:
-		return thisRV.Int() < thatRV.Int()
-	case reflect.String:
-		return thisRV.String() < thatRV.String()
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return thisRV.Uint() < thatRV.Uint()
-	default:
-		return false
+	for _, keysValue := range m.KeysValues {
+		thisRV := keysValue.Index(i)
+		thatRV := keysValue.Index(j)
+		
+		var less bool
+		equal := false
+		
+		switch thisRV.Kind() {
+		case reflect.Float32, reflect.Float64:
+			thisVal := thisRV.Float()
+			thatVal := thatRV.Float()
+			less = thisVal < thatVal
+			equal = thisVal == thatVal
+		case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64:
+			thisVal := thisRV.Int()
+			thatVal := thatRV.Int()
+			less = thisVal < thatVal
+			equal = thisVal == thatVal
+		case reflect.String:
+			thisVal := thisRV.String()
+			thatVal := thatRV.String()
+			less = thisVal < thatVal
+			equal = thisVal == thatVal
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+			thisVal := thisRV.Uint()
+			thatVal := thatRV.Uint()
+			less = thisVal < thatVal
+			equal = thisVal == thatVal
+		default:
+			return false
+		}
+		
+		if !equal {
+			return less
+		}
 	}
+	
+	// All fields are equal
+	return false
 }
 
-func (m *sorter) Sort(iterator IEnumerator, selector interface{}) {
-	selectorValue := reflect.ValueOf(selector)
+func (m *sorter) Sort(iterator IEnumerator, selectors ...interface{}) {
+	selectorValues := make([]reflect.Value, len(selectors))
+	for i, selector := range selectors {
+		selectorValues[i] = reflect.ValueOf(selector)
+	}
+	
 	for ok := iterator.MoveNext(); ok; ok = iterator.MoveNext() {
-		keyValue := getReturnValue(selectorValue, iterator)
 		if m.Len() == 0 {
-			keysType := reflect.SliceOf(
-				keyValue.Type(),
-			)
-			m.KeysValue = reflect.MakeSlice(keysType, 0, 0)
-
-			valuesType := reflect.SliceOf(
-				iterator.GetValue().Type(),
-			)
+			m.KeysValues = make([]reflect.Value, len(selectors))
+			for i, selectorValue := range selectorValues {
+				keyValue := getReturnValue(selectorValue, iterator)
+				keysType := reflect.SliceOf(keyValue.Type())
+				m.KeysValues[i] = reflect.MakeSlice(keysType, 0, 0)
+			}
+			
+			valuesType := reflect.SliceOf(iterator.GetValue().Type())
 			m.ValuesValue = reflect.MakeSlice(valuesType, 0, 0)
 		}
-
-		m.KeysValue = reflect.Append(m.KeysValue, keyValue)
+		
+		for i, selectorValue := range selectorValues {
+			keyValue := getReturnValue(selectorValue, iterator)
+			m.KeysValues[i] = reflect.Append(m.KeysValues[i], keyValue)
+		}
+		
 		m.ValuesValue = reflect.Append(
 			m.ValuesValue,
 			iterator.GetValue(),