Wie kann festgestellt werden, ob ein generischer Typ zur Laufzeit „vergleichbar“ ist?

Frageninhalt

Ich möchte eine allgemeine equals Methode schreiben, die so funktioniert:

func equals[T any](a, b T) bool {
  if hasEqualsMethod(T) {
    return a.Equals(b)
  else if isComparable(T) {
    return a == b
  }
  panic("type cannot be compared")
} 

Dazu habe ich eine Schnittstelle erstellt comparable:

type Comparable[T any] interface {
    // Equals returns true if the receiver and the argument are equal.
    Equals(T) bool
}

Ich kann wie folgt überprüfen, ob der Parameter von equal diese comparable Schnittstelle implementiert:

func equals[T any](a, b T) bool {
    aComp, ok := any(a).(Comparable[T])
    if ok {
        return aComp.Equals(b)
    }
    ...

Allerdings war es für mich bisher unmöglich herauszufinden, ob a auch die a 是否也满足 comparable 约束并将其转换为可以使用 ==-Einschränkung erfüllt, und es in etwas umzuwandeln, das == verwenden kann.

Gibt es eine Möglichkeit, zur Laufzeit herauszufinden, ob ein generischer Typ T any T any 在运行时是否是 comparable ，如果是，则使用 == ist, und wenn ja, zum Vergleich == zu verwenden?

Ich könnte meinen gesamten Code so einschränken, dass er nur mit comparable 泛型类型，但我想让用户可以手动添加 equals 方法，如果他们的类型恰好不是 comparable （例如，因为它基于切片） ）。

正确答案

如果它使用相等运算符进行编译，则它是可比较的。受 any 约束的类型参数在定义上是不可比较的：它实际上可以是任何内容，包括 func() error generischen Typen funktioniert, aber ich möchte Benutzern erlauben,

Methoden manuell hinzuzufügen, wenn ihr Typ zufällig etwas anderes als

ist (z. B. weil er auf Slices basiert). equals 函数。您必须使用反射或仅接受实现“相等”接口的参数，例如您自己的 Comparable[T any]

Richtige Antwort

Sie ist vergleichbar, wenn sie mit dem Gleichheitsoperator kompiliert wird. Ein Typparameter, der any unterliegt, ist per Definition unvergleichbar: Er kann praktisch alles sein, einschließlich func() error. Value#Comparable Es ist daher unmöglich,

Funktionen mit statischen Typen zu schreiben. Sie müssen Reflection verwenden oder nur Parameter akzeptieren, die eine „Gleichheits“-Schnittstelle implementieren, wie z. B. Ihr eigenes Comparable[T any].

a 和 b 具有相同的确切类型，因此 v.Equal(u) 不是毫无意义的，而不是声明 equals(a, b any) Mit Reflexion können Sie

:🎜 verwenden

func equals[T any](a, b T) bool {
    v := reflect.ValueOf(a)
    if v.Comparable() {
        u := reflect.ValueOf(b)
        return v.Equal(u)
    }
    panic("type cannot be compared")
}

🎜In diesem Fall kann die Verwendung von Generika dazu beitragen, 🎜 zur Kompilierungszeit sicherzustellen. 🎜 🎜Um die „equaler“-Schnittstelle zu verwenden, müssen Sie einen benannten Typ bereitstellen, der ihn implementiert, um vordeklarierte Typen zu konvertieren und ihre Methoden aufzurufen: 🎜

func main() {
    fmt.Println(equals(EqualerFloat64(5.57), EqualerFloat64(5.57)))
}

type Equaler[T any] interface {
    Equal(T) bool
}

type EqualerFloat64 float64

func (f EqualerFloat64) Equal(f2 EqualerFloat64) bool {
    return f == f2
}

func equals[T Equaler[T]](a, b T) bool {
    return a.Equal(b)
}

Das obige ist der detaillierte Inhalt vonWie kann festgestellt werden, ob ein generischer Typ zur Laufzeit „vergleichbar“ ist?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!