关系运算符 #

一、运算符概述 #

Go语言支持以下关系运算符：

运算符	说明	示例
==	等于	a == b
!=	不等于	a != b
>	大于	a > b
<	小于	a < b
>=	大于等于	a >= b
<=	小于等于	a <= b

关系运算符返回布尔值true或false。

二、基本比较 #

2.1 等于运算 #

a := 10
b := 10
fmt.Println(a == b)  // true

s1 := "hello"
s2 := "hello"
fmt.Println(s1 == s2)  // true

2.2 不等于运算 #

a := 10
b := 20
fmt.Println(a != b)  // true

s1 := "hello"
s2 := "world"
fmt.Println(s1 != s2)  // true

2.3 大于运算 #

a := 20
b := 10
fmt.Println(a > b)  // true

2.4 小于运算 #

a := 10
b := 20
fmt.Println(a < b)  // true

2.5 大于等于运算 #

a := 10
b := 10
fmt.Println(a >= b)  // true

2.6 小于等于运算 #

a := 10
b := 20
fmt.Println(a <= b)  // true

三、数值比较 #

3.1 整数比较 #

a := 10
b := 20

fmt.Println(a == b)  // false
fmt.Println(a != b)  // true
fmt.Println(a > b)   // false
fmt.Println(a < b)   // true

3.2 浮点数比较 #

由于浮点数精度问题，不建议直接比较：

a := 0.1 + 0.2
b := 0.3
fmt.Println(a == b)  // false！

// 正确做法：使用误差范围
func floatEqual(a, b float64) bool {
    const epsilon = 1e-9
    return math.Abs(a-b) < epsilon
}

fmt.Println(floatEqual(a, b))  // true

3.3 类型必须一致 #

var a int = 10
var b int32 = 10

fmt.Println(a == b)  // 错误：类型不匹配
fmt.Println(a == int(b))  // 正确

四、字符串比较 #

4.1 基本比较 #

s1 := "apple"
s2 := "banana"

fmt.Println(s1 == s2)  // false
fmt.Println(s1 != s2)  // true
fmt.Println(s1 < s2)   // true（字典序）
fmt.Println(s1 > s2)   // false

4.2 字典序比较 #

fmt.Println("a" < "b")    // true
fmt.Println("ab" < "ac")  // true
fmt.Println("ab" < "abc") // true

4.3 大小写敏感 #

fmt.Println("A" == "a")  // false
fmt.Println("A" < "a")   // true（大写字母ASCII码更小）

五、布尔值比较 #

a := true
b := false

fmt.Println(a == b)  // false
fmt.Println(a != b)  // true

布尔值只能比较相等和不等：

fmt.Println(true > false)  // 错误：无效操作

六、指针比较 #

6.1 指针地址比较 #

a := 10
b := 10
p1 := &a
p2 := &a
p3 := &b

fmt.Println(p1 == p2)  // true（指向同一变量）
fmt.Println(p1 == p3)  // false（指向不同变量）

6.2 nil比较 #

var p *int
fmt.Println(p == nil)  // true

七、结构体比较 #

7.1 可比较的结构体 #

如果结构体所有字段都可比较，则结构体可比较：

type Point struct {
    X, Y int
}

p1 := Point{1, 2}
p2 := Point{1, 2}
p3 := Point{1, 3}

fmt.Println(p1 == p2)  // true
fmt.Println(p1 == p3)  // false

7.2 不可比较的结构体 #

包含切片、映射、函数的结构体不可比较：

type Data struct {
    Numbers []int
}

d1 := Data{Numbers: []int{1, 2, 3}}
d2 := Data{Numbers: []int{1, 2, 3}}

fmt.Println(d1 == d2)  // 错误：结构体包含不可比较字段

八、实际应用 #

8.1 条件判断 #

age := 18

if age >= 18 {
    fmt.Println("成年人")
} else {
    fmt.Println("未成年人")
}

8.2 循环条件 #

i := 0
for i < 10 {
    fmt.Println(i)
    i++
}

8.3 查找元素 #

func contains(numbers []int, target int) bool {
    for _, n := range numbers {
        if n == target {
            return true
        }
    }
    return false
}

fmt.Println(contains([]int{1, 2, 3}, 2))  // true

8.4 排序判断 #

func isSorted(numbers []int) bool {
    for i := 0; i < len(numbers)-1; i++ {
        if numbers[i] > numbers[i+1] {
            return false
        }
    }
    return true
}

fmt.Println(isSorted([]int{1, 2, 3, 4}))  // true
fmt.Println(isSorted([]int{1, 3, 2, 4}))  // false

九、常见错误 #

9.1 类型不匹配 #

var a int = 10
var b int32 = 10
fmt.Println(a == b)  // 错误

// 解决
fmt.Println(a == int(b))

9.2 浮点数精度 #

a := 0.1 + 0.2
fmt.Println(a == 0.3)  // false

// 解决：使用误差比较

9.3 比较不可比较类型 #

var s1 []int = []int{1, 2, 3}
var s2 []int = []int{1, 2, 3}
fmt.Println(s1 == s2)  // 错误：切片只能与nil比较

// 解决：使用reflect.DeepEqual
fmt.Println(reflect.DeepEqual(s1, s2))  // true

十、总结 #

关系运算符要点：

运算符	说明	适用类型
==	等于	所有可比较类型
!=	不等于	所有可比较类型
>, <	大于/小于	数值、字符串
>=, <=	大于等于/小于等于	数值、字符串

关键点：

返回布尔值：比较结果为true或false
类型一致：比较数类型必须相同
浮点数：注意精度问题
字符串：按字典序比较
不可比较类型：切片、映射、函数只能与nil比较