Memastikan perbandingan yang ketat pada masa penyusunan dalam Go 1.20?

editor php Baicao memperkenalkan kepada anda ciri penting dalam bahasa Go versi 1.20 - kebolehbandingan yang ketat pada masa penyusunan. Dalam bahasa Go versi 1.20, bendera pengkompil baharu diperkenalkan untuk memastikan bahawa fail binari yang dijana semasa penyusunan adalah setanding di bawah persekitaran kompilasi yang berbeza. Ini bermakna binari yang dijana di bawah persekitaran kompilasi yang berbeza akan mempunyai gelagat dan keputusan yang sama, mengurangkan potensi masalah yang disebabkan oleh persekitaran kompilasi yang berbeza. Pengenalan ciri ini akan meningkatkan lagi kebolehpercayaan dan kestabilan bahasa Go dan memberikan pembangun pengalaman pembangunan yang lebih baik.

Kandungan soalan

Dalam Go 1.18 dan Go 1.19, saya boleh memastikan pada masa penyusunan bahawa sesuatu jenis adalah setanding ketat, iaitu ia menyokong == 和 != pengendali, dan dijamin tidak panik semasa menjalankan pengendali ini .

Ini berguna, sebagai contoh, untuk mengelakkan penambahan medan secara tidak sengaja pada struktur, menyebabkan panik yang tidak perlu.

Saya baru sahaja cuba membuat instantiat dengan

:comparable

// supports == and != but comparison could panic at run time
type Foo struct {
    SomeField any
}

func ensureComparable[T comparable]() {
    // no-op
}

var _ = ensureComparable[Foo] // doesn't compile because Foo comparison may panic

Ini mungkin dalam Go 1.18 dan 1.19 kerana takrifan

kekangan: comparable

The predeclared interface type comparable denotes the set of all non-interface types that are comparable

Walaupun spesifikasi Go 1.18 dan 1.19 tidak menyebut jenis yang bukan antara muka tetapi tidak boleh dibandingkan dengan ketat, seperti [2]fmt.Stringer atau struct { foo any } , gc compilation Pengkompil menolak ini sebagai hujah kepada

. [2]fmt.Stringer 或 struct { foo any }，gc 编译器确实拒绝将这些作为 comparable

Taman permainan dengan beberapa contoh: https://go.dev/play/p/_Ggfdnn6OzZ

Dalam Go 1.20, instantiasi

akan selaras dengan konsep kebolehbandingan yang lebih luas. Ini menjadikan ensureComparable[Foo] menyusun comparable 将与更广泛的可比性概念保持一致。这使得 ensureComparable[Foo] walaupun saya tidak mahukannya .

Adakah terdapat cara untuk memastikan perbandingan yang ketat dengan Go 1.20 secara statik?

Penyelesaian

Untuk menguji sama ada Foo benar-benar setanding dalam Go 1.20, nyatakan ensureComparablemenggunakan parameter

typeFoo 在 Go 1.20 中是否严格可比，请使用受 Foo 约束的类型参数实例化 ensureComparabledikekang oleh Foo >.

// unchanged
type Foo struct {
    SomeField any
}

// unchanged
func ensureComparable[T comparable]() {}

// T constrained by Foo, instantiate ensureComparable with T
func ensureStrictlyComparable[T Foo]() {
    _ = ensureComparable[T] // <---- doesn't compile
}

_{Penyelesaian ini pada asalnya dicadangkan oleh Robert Griesemer di sini a>.}

Jadi bagaimana ia berfungsi?

Go 1.20 memperkenalkan melaksanakanantara muka dan memuaskan kekangan:

Perkara kedua adalah untuk membenarkan pengecualian untuk antara muka dan jenis dengan antara muka untuk dijadikan instantiated comparable.

Kini dalam Go 1.20, taip Foo itu sendiri boleh dijadikan instantiated Foo 本身可以实例化 comparable 。但类型参数 T 不是 Foo disebabkan oleh pengecualian kepuasan. Tetapi parameter jenis T bukanlah Foo. Takrifan keserasian untuk parameter jenis berbeza :

T's type set mengandungi jenis Foo yang tidak boleh dibandingkan dengan ketat (kerana ia mempunyai medan antara muka), jadi T tidak memenuhi T 的类型集包含一个不严格可比的类型 Foo （因为它有一个接口字段），因此 T 不满足 comparable。即使 Foo. Ini benar walaupun untuk Foo itu sendiri.

Helah ini dengan berkesan menjadikan atur cara gagal untuk menyusun jika pengendali Foo Foo 的运算符 == 和 != mungkin panik semasa masa jalan.

Atas ialah kandungan terperinci Memastikan perbandingan yang ketat pada masa penyusunan dalam Go 1.20?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!