Golang中有哪些比較操作符

Golang中有哪些比較操作符，相信很多沒有經驗的人對此束手無策，為此本文總結了問題出現的原因和解決方法，通過這篇文章希望你能解決這個問題。

package main
import "fmt"
type T struct {
  name string
}
func main() {
  s := struct{ name string }{"foo"}
  t := T{"foo"}
  fmt.Println(s == t) // true
}

這條規則顯著縮小了可選范圍：

var a int = 1
var b rune = '1'
fmt.Println(a == b)

類似的代碼在 Javascript 或 Python 中可以運行。但在 Go 中它是非法的，并且在編譯時會被檢測到。

src/github.com/mlowicki/lab/lab.go:8: invalid operation: a == b (mismatched types int and rune)

可賦值不是唯一要求。這是相等和順序操作符的規則……

相等操作符

操作數需要使用 == 或 != 操作符進行比較。哪些方法，哪些值可以被比較？Go 規范定義的非常明確：

boolean 值可比較（如果倆個值都是真或假，那么比較結果被認為 true）
整數和浮點數比較：

var a int = 1
var b int = 2
var c float32 = 3.3
var d float32 = 4.4
fmt.Println(a == b) // false
fmt.Println(c == d) // false

當編譯時 a == d 會拋出異常（ int 和 float32 類型不匹配）因為它不可能用 int 和 float 比較。

復數相等，如果他們的是實數和虛數部分都相等：

var a complex64 = 1 + 1i
var b complex64 = 1 + 2i
var c complex64 = 1 + 2i
fmt.Println(a == b) // false
fmt.Println(b == c) // true

字符串類型值可比較

指針類型值相等，如果他們都是 nil 或都指向相同的變量：

type T struct {
  name string
}
func main() {
  t1 := T{"foo"}
  t2 := T{"bar"}
  p1 := &t1
  p2 := &t1
  p3 := &t2
  fmt.Println(p1 == p2)  // true
  fmt.Println(p2 == p3)  // false
  fmt.Println(p3 == nil) // false
}

不同的 zero-size 變量可能具有相同的內存地址，因此我們不假設任何指向這些變量的指針相等。

a1 := [0]int{}
a2 := [0]int{}
p1 := &a1
p2 := &a2
fmt.Println(p1 == p2) // might be true or false. Don't rely on it!

通道類型值相等，如果他們確實一樣（被相同的內置 make 方法創建）或值都是 nil：

ch2 := make(chan int)
ch3 := make(chan int)
fmt.Println(ch2 == ch3) // false

接口類型是可比較。與通道和指針類型值比較一樣，如果是 nil 或 動態類型和動態值是相同的：

type I interface {
  m()
}
type J interface {
  m()
}
type T struct {
  name string
}
func (T) m() {}
type U struct {
  name string
}
func (U) m() {}
func main() {
  var i1, i2, i3, i4 I
  var j1 J
  i1 = T{"foo"}
  i2 = T{"foo"}
  i3 = T{"bar"}
  i4 = U{"foo"}
  fmt.Println(i1 == i2) // true
  fmt.Println(i1 == i3) // false
  fmt.Println(i1 == i4) // false
  fmt.Println(i1 == j1) // false
}

比較接口類型的方法集不能相交。

接口類型 I 的 i 和 非接口類型 T 的 t 可比較，如果 T 實現了 I 則 T 類型的值是可比較的。如果 I 的 動態類型和 T 是相同的，并且 i 的動態值和 t 也是相同的，那么值是相等的：

type I interface {
  m()
}
type T struct{}
func (T) m() {}
type S struct{}
func (S) m() {}
func main() {
  t := T{}
  s := S{}
  var i I
  i = T{}
  fmt.Println(t == i) // true
  fmt.Println(s == i) // false
}
結構類型可比較，所以字段都需要比較。所有非空白字段相等則他們等。
a := struct {
  name string
  _ int32
}{name: "foo"}
b := struct {
  name string
  _ int32
}{name: "foo"}
fmt.Println(a == b) // true

Go 中 數組是同質的 —— 只有同一類型（數組元素類型）的值可以被存儲其中。對于數組值比較，它們的元素類型需要可比較。如果對應的元素相同，數組就相等。

就是這樣。上面列表很長但并不充滿驚奇。嘗試了解它在 JavaScript 是如何工作的……

有三種類型不能比較 —— maps, slices 和 functions。Go 編譯器不允許這樣做，并且編譯比較 maps 的程序會引起一個錯誤 map can only be compared to nil. 。展示的錯誤告訴我們至少可以用 maps，slices 或 functions 和 nil 比較。

目前為止，我們知道接口值是可比較的，但 maps 是不可以的。如果接口值的動態類型是相同的，但是不能比較（如 maps），它會引起一個運行時錯誤：

type T struct {
  meta map[string]string
}
func (T) m() {}
func main() {
  var i1 I = T{}
  var i2 I = T{}
  fmt.Println(i1 == i2)
}
panic: runtime error: comparing uncomparable type main.T
goroutine 1 [running]:
panic(0x8f060, 0x4201a2030)
  /usr/local/go/src/runtime/panic.go:500 +0x1a1
main.main()
  ...

順序操作符

這些操作符只能應用在三種類型：整數，浮點數和字符串類型。這沒有什么特別的或 Go 特有的。值得注意的是字符串是按字典順序排列的。byte-wise 一次一個字節并沒有 Collation 算法。

fmt.Println("aaa" < "b") // true
fmt.Println("?" > "z")  // true

結果

任何比較操作符的結果都是無類型布爾常量（true 或 false）。因為它沒有類型，所以可以分配了給任何布爾變量：

var t T = true
t = 3.3 < 5
fmt.Println(t)

這段代碼輸出 true。另一個，嘗試分配 bool 類型的值：

var t T = true
var b bool = true
t = b
fmt.Println(t)

產生一個錯誤，不能使用 b （bool類型）分配給 T 類型。

看完上述內容，你們掌握Golang中有哪些比較操作符的方法了嗎？如果還想學到更多技能或想了解更多相關內容，歡迎關注億速云行業資訊頻道，感謝各位的閱讀！