运算符

运算符用于执行各种运算操作，如加减乘除、比较大小、逻辑判断等。本章将详细介绍 Go 语言的运算符。

运算符分类

Go 语言的运算符分为以下几类：

算术运算符

算术运算符用于执行数学运算。

基本运算

package main

import "fmt"

func main() {
    a, b := 10, 3

    fmt.Printf("a + b = %d\n", a+b)
    fmt.Printf("a - b = %d\n", a-b)
    fmt.Printf("a * b = %d\n", a*b)
    fmt.Printf("a / b = %d\n", a/b)
    fmt.Printf("a %% b = %d\n", a%b)
}

输出：

a + b = 13
a - b = 7
a * b = 30
a / b = 3
a % b = 1

整数除法

整数除法会向下取整：

package main

import "fmt"

func main() {
    a, b := 10, 3
    result := a / b
    fmt.Printf("10 / 3 = %d\n", result)

    f1 := 10.0 / 3
    fmt.Printf("10.0 / 3 = %f\n", f1)
}

输出：

10 / 3 = 3
10.0 / 3 = 3.333333

自增自减

package main

import "fmt"

func main() {
    i := 10
    i++
    fmt.Printf("i++ = %d\n", i)

    i--
    fmt.Printf("i-- = %d\n", i)
}

注意：Go 的自增自减只能作为语句，不能作为表达式：

i := 10
j := i++

字符串拼接

+ 运算符可以用于字符串拼接：

package main

import "fmt"

func main() {
    s1 := "Hello"
    s2 := "World"
    result := s1 + ", " + s2 + "!"
    fmt.Println(result)
}

输出：

Hello, World!

比较运算符

比较运算符用于比较两个值，返回布尔值。

示例

package main

import "fmt"

func main() {
    a, b := 10, 5

    fmt.Printf("a == b: %v\n", a == b)
    fmt.Printf("a != b: %v\n", a != b)
    fmt.Printf("a > b: %v\n", a > b)
    fmt.Printf("a < b: %v\n", a < b)
    fmt.Printf("a >= b: %v\n", a >= b)
    fmt.Printf("a <= b: %v\n", a <= b)
}

输出：

a == b: false
a != b: true
a > b: true
a < b: false
a >= b: true
a <= b: false

比较浮点数

浮点数比较要注意精度问题：

package main

import (
    "fmt"
    "math"
)

func main() {
    a := 0.1 + 0.2
    b := 0.3

    fmt.Printf("直接比较: %v\n", a == b)
    fmt.Printf("a = %.17f\n", a)
    fmt.Printf("b = %.17f\n", b)

    diff := math.Abs(a - b)
    fmt.Printf("差值比较: %v\n", diff < 1e-9)
}

输出：

直接比较: false
a = 0.29999999999999999
b = 0.29999999999999999
差值比较: true

逻辑运算符

逻辑运算符用于布尔值的逻辑运算。

逻辑与（&&）

两边都为 true 才返回 true：

package main

import "fmt"

func main() {
    a, b := true, false

    fmt.Printf("true && true = %v\n", true && true)
    fmt.Printf("true && false = %v\n", a && b)
    fmt.Printf("false && false = %v\n", false && false)
}

输出：

true && true = true
true && false = false
false && false = false

逻辑或（||）

有一边为 true 就返回 true：

package main

import "fmt"

func main() {
    a, b := true, false

    fmt.Printf("true || true = %v\n", true || true)
    fmt.Printf("true || false = %v\n", a || b)
    fmt.Printf("false || false = %v\n", false || false)
}

输出：

true || true = true
true || false = true
false || false = false

逻辑非（!）

取反：

package main

import "fmt"

func main() {
    fmt.Printf("!true = %v\n", !true)
    fmt.Printf("!false = %v\n", !false)
}

输出：

!true = false
!false = true

短路求值

逻辑运算符有短路特性：

package main

import "fmt"

func main() {
    a := false
    b := true

    if a && expensiveOperation() {
        fmt.Println("不会执行")
    }

    if b || expensiveOperation() {
        fmt.Println("会执行")
    }
}

func expensiveOperation() bool {
    fmt.Println("执行了耗时操作")
    return true
}

位运算符

位运算符对整数的二进制位进行操作。

按位与（&）

对应位都为 1 才为 1：

package main

import "fmt"

func main() {
    a := 5
    b := 3

    fmt.Printf("5  的二进制: %04b\n", a)
    fmt.Printf("3  的二进制: %04b\n", b)
    fmt.Printf("5&3 的二进制: %04b (十进制: %d)\n", a&b, a&b)
}

输出：

5  的二进制: 0101
3  的二进制: 0011
5&3 的二进制: 0001 (十进制: 1)

按位或（|）

对应位有一个为 1 就为 1：

package main

import "fmt"

func main() {
    a := 5
    b := 3

    fmt.Printf("5  的二进制: %04b\n", a)
    fmt.Printf("3  的二进制: %04b\n", b)
    fmt.Printf("5|3 的二进制: %04b (十进制: %d)\n", a|b, a|b)
}

输出：

5  的二进制: 0101
3  的二进制: 0011
5|3 的二进制: 0111 (十进制: 7)

按位异或（^）

对应位不同为 1，相同为 0：

package main

import "fmt"

func main() {
    a := 5
    b := 3

    fmt.Printf("5  的二进制: %04b\n", a)
    fmt.Printf("3  的二进制: %04b\n", b)
    fmt.Printf("5^3 的二进制: %04b (十进制: %d)\n", a^b, a^b)
}

输出：

5  的二进制: 0101
3  的二进制: 0011
5^3 的二进制: 0110 (十进制: 6)

左移（<<）和右移（>>）

package main

import "fmt"

func main() {
    a := 5

    fmt.Printf("5   的二进制: %04b\n", a)
    fmt.Printf("5<<1 的二进制: %04b (十进制: %d)\n", a<<1, a<<1)
    fmt.Printf("5>>1 的二进制: %04b (十进制: %d)\n", a>>1, a>>1)
}

输出：

5   的二进制: 0101
5<<1 的二进制: 1010 (十进制: 10)
5>>1 的二进制: 0010 (十进制: 2)

位运算应用

判断奇偶：

package main

import "fmt"

func main() {
    n := 7
    if n&1 == 1 {
        fmt.Printf("%d 是奇数\n", n)
    } else {
        fmt.Printf("%d 是偶数\n", n)
    }
}

交换两数：

package main

import "fmt"

func main() {
    a, b := 10, 20
    fmt.Printf("交换前: a=%d, b=%d\n", a, b)

    a = a ^ b
    b = a ^ b
    a = a ^ b

    fmt.Printf("交换后: a=%d, b=%d\n", a, b)
}

赋值运算符

基本赋值

var a int = 10

复合赋值

示例

package main

import "fmt"

func main() {
    a := 10

    a += 5
    fmt.Printf("a += 5: %d\n", a)

    a -= 3
    fmt.Printf("a -= 3: %d\n", a)

    a *= 2
    fmt.Printf("a *= 2: %d\n", a)

    a /= 4
    fmt.Printf("a /= 4: %d\n", a)
}

输出：

a += 5: 15
a -= 3: 12
a *= 2: 24
a /= 4: 6

运算符优先级

运算符优先级从高到低：

示例

package main

import "fmt"

func main() {
    result := 2 + 3*4
    fmt.Printf("2 + 3 * 4 = %d\n", result)

    result = (2 + 3) * 4
    fmt.Printf("(2 + 3) * 4 = %d\n", result)

    result = 10 > 5 && 5 > 3
    fmt.Printf("10 > 5 && 5 > 3 = %v\n", result)
}

输出：

2 + 3 * 4 = 14
(2 + 3) * 4 = 20
10 > 5 && 5 > 3 = true

建议：复杂表达式使用括号明确优先级，提高代码可读性。

总结

本章学习了 Go 语言的运算符：