update

Author: CC11001100

README.md

@@ -1,32 +1,8 @@
-能够让任何类型参与比较，而不是仅仅只是comparable
+# Comparator 
 
-Go语言内置的比较支持：
 
 
 
-| Type      | Comparable | Ordered | Description                                                  |
-| --------- | ---------- | ------- | ------------------------------------------------------------ |
-| Boolean   | ✅          | ❌       |                                                              |
-| Integer   | ✅          | ✅       |                                                              |
-| Float     | ✅          | ✅       |                                                              |
-| Complex   | ✅          | ❌       | 分别比较实数和虚数，同时相等则两个复数相等。 如果需要比较大小，需要开发者分别比较实数和虚数。 |
-| String    | ✅          | ✅       | 基于字节逐个比较。                                           |
-| Pointer   | ✅          | ❌       | 如果两个指针指向同一个对象或者都为 nil，则两者相等。         |
-| Channel   | ✅          | ❌       | 类似 Pointer，两个 Channel 变量只有都为 nil，或者指向同一个 Channel 的时候才相等。 |
-| Interface | ✅          | ❌       | 两个 interface 的 Type 和 Value 值同时相等时，两者才相等。   |
-| Struct    | ⚠️          | ❌       | 仅当 Struct 内所有成员都是 Comparable，这个 Struct 才是 Comparable 的。 如果两个 struct 类型相同，且所有非空成员变量都相等，则两者相等。 |
-| Array     | ⚠️          | ❌       | 仅当成员为 Comparable，Array 才是 Comparable 的。 如果两个 Array 中的每一个元素一一相等时，则两个 Array 相等。 |
-| Map       | ❌          | ❌       |                                                              |
-| Slice     | ❌          | ❌       |                                                              |
-| Func      | ❌          | ❌       |                                                              |
-
-
-
-对原生的功能做扩展，提供更强大的比较支持：
-
-- 大小
-- 相等 
-
 
 
 

comparable.go

@@ -6,11 +6,11 @@ import "reflect"
 type Comparable[T any] interface {
 
 	// CompareTo 用来做比较的方法
-	CompareTo(target *T) int
+	CompareTo(target T) int
 }
 
 // IsComparable 判断是否是可比较类型
-func IsComparable[T any](v *T) bool {
+func IsComparable[T any](v T) bool {
 	reflectValue := reflect.ValueOf(v)
 	if !reflectValue.CanInterface() {
 		return false
@@ -20,7 +20,7 @@ func IsComparable[T any](v *T) bool {
 }
 
 // CastToComparable 把给定的值转为Comparable接口类型，如果无法转换则会返回error
-func CastToComparable[T any](value *T) (Comparable[T], error) {
+func CastToComparable[T any](value T) (Comparable[T], error) {
 	reflectValue := reflect.ValueOf(value)
 	if !reflectValue.CanInterface() {
 		return nil, ErrCastFailed

comparator.go

@@ -3,19 +3,19 @@ package compare_anything
 import (
 	"github.com/golang-infrastructure/go-gtypes"
 	"math"
-	"reflect"
 	"strings"
 )
 
 // ------------------------------------------------ ---------------------------------------------------------------------
 
 // Comparator 比较器的接口定义，一个类型要想参与比较必须先实现比较器
-type Comparator[T any] func(a T, b T) int
+type Comparator[T any] func(a, b T) int
 
 // ------------------------------------------------ ---------------------------------------------------------------------
 
+// OrderedComparator 为支持排序的类型生成比较器
 func OrderedComparator[T gtypes.Ordered]() Comparator[T] {
-	return func(a T, b T) int {
+	return func(a, b T) int {
 		if a == b {
 			return 0
 		} else if a < b {
@@ -26,11 +26,47 @@ func OrderedComparator[T gtypes.Ordered]() Comparator[T] {
 	}
 }
 
+// ReverseOrderedComparator 对可比较类型逆序比较的比较器，会把较大的放在前面
+func ReverseOrderedComparator[T gtypes.Ordered]() Comparator[T] {
+	return ReverseComparator[T](OrderedComparator[T]())
+}
+
+// ------------------------------------------------ ---------------------------------------------------------------------
+
+// OrderedPointerComparator 为支持排序的类型生成比较器
+func OrderedPointerComparator[T *gtypes.Ordered]() Comparator[T] {
+	return func(a, b T) int {
+		// 1. 先比较指针
+		if a == nil && b != nil {
+			return -1
+		} else if a != nil && b == nil {
+			return 1
+		} else if a == nil && b == nil {
+			return 0
+		}
+		// 2. 再比较实际的值
+		aValue := *a
+		bValue := *b
+		if aValue == bValue {
+			return 0
+		} else if aValue < bValue {
+			return -1
+		} else {
+			return +1
+		}
+	}
+}
+
+// ReverseOrderedPointerComparator 对可比较类型逆序比较的比较器，会把较大的放在前面
+func ReverseOrderedPointerComparator[T *gtypes.Ordered]() Comparator[T] {
+	return ReverseComparator[T](OrderedPointerComparator[T]())
+}
+
 // ------------------------------------------------ ---------------------------------------------------------------------
 
 // ReverseComparator 将比较结果按原点取反以达到逆序的效果
 func ReverseComparator[T any](comparator Comparator[T]) Comparator[T] {
-	return func(a T, b T) int {
+	return func(a, b T) int {
 		return comparator(a, b) * -1
 	}
 }
@@ -129,49 +165,49 @@ func BoolComparator() Comparator[bool] {
 
 // ------------------------------------------------ ---------------------------------------------------------------------
 
-func ArrayComparator[T any]() Comparator[[]T] {
-	return func(a []T, b []T) int {
-		for index := 0; ; index++ {
-			if index >= len(a) {
-
-			}
-		}
-		// 对应位置先没元素的认为更小
-
-		// 如果都有元素的话，则看元素的值
-
-	}
-}
+//// OrderedArrayComparator 承载可比较元素的数组或切片使用的比较器
+//func OrderedArrayComparator[T gtypes.Ordered]() Comparator[[]T] {
+//	return func(a, b []T) int {
+//		for index := 0; ; index++ {
+//			// 对应位置先没元素的认为更小
+//
+//			// 如果都有元素的话，则看元素的值
+//			if index >= len(a) {
+//
+//			}
+//		}
+//	}
+//}
 
 // ------------------------------------------------ ---------------------------------------------------------------------
 
-func SliceComparator[T any]() Comparator[T] {
-	return func(a T, b T) int {
-
-		// a和b都是切片，通过反射来获取它们的值
-		reflectA := reflect.ValueOf(a)
-		reflectB := reflect.ValueOf(b)
-		if !reflectA.IsValid() && reflectB.IsValid() {
-			return 0
-		} else if !reflectA.IsValid() {
-			return -1
-		} else if !reflectB.IsValid() {
-			return 1
-		}
-
-		// 两个切片都是可用的，那就开始挨个比较吧
-		//for index := 0; ; index++ {
-		//	valueA := reflectA.Index(index)
-		//	kind, err := GenComparatorFromKind(valueA.Kind())
-		//
-		//}
-
-		// 对应位置先没元素的认为更小
-
-		// 如果都有元素的话，则看元素的值，为元素生成比较器来比较
-
-		return 0
-	}
-}
+//func SliceComparator[T any]() Comparator[T] {
+//	return func(a T, b T) int {
+//
+//		// a和b都是切片，通过反射来获取它们的值
+//		reflectA := reflect.ValueOf(a)
+//		reflectB := reflect.ValueOf(b)
+//		if !reflectA.IsValid() && reflectB.IsValid() {
+//			return 0
+//		} else if !reflectA.IsValid() {
+//			return -1
+//		} else if !reflectB.IsValid() {
+//			return 1
+//		}
+//
+//		// 两个切片都是可用的，那就开始挨个比较吧
+//		//for index := 0; ; index++ {
+//		//	valueA := reflectA.Index(index)
+//		//	kind, err := GenComparatorFromKind(valueA.Kind())
+//		//
+//		//}
+//
+//		// 对应位置先没元素的认为更小
+//
+//		// 如果都有元素的话，则看元素的值，为元素生成比较器来比较
+//
+//		return 0
+//	}
+//}
 
 // ------------------------------------------------ ---------------------------------------------------------------------