逻辑运算符 #

一、运算符概述 #

Go语言支持以下逻辑运算符：

运算符 说明 示例
&& 逻辑与 a && b
|| 逻辑或 a || b
! 逻辑非 !a

逻辑运算符操作布尔值，返回布尔值。

二、逻辑与 (&&) #

2.1 基本用法 #

两个操作数都为true时结果为true：

go 
fmt.Println(true && true)    // true
fmt.Println(true && false)   // false
fmt.Println(false && true)   // false
fmt.Println(false && false)  // false

2.2 真值表 #

A B A && B
true true true
true false false
false true false
false false false

2.3 短路求值 #

如果第一个操作数为false，不会计算第二个：

go 
func returnsFalse() bool {
    fmt.Println("不会执行")
    return false
}

result := false && returnsFalse()
fmt.Println(result)  // false

2.4 实际应用 #

go 
age := 25
hasLicense := true

if age >= 18 && hasLicense {
    fmt.Println("可以驾驶")
}

三、逻辑或 (||) #

3.1 基本用法 #

任一操作数为true时结果为true：

go 
fmt.Println(true || true)    // true
fmt.Println(true || false)   // true
fmt.Println(false || true)   // true
fmt.Println(false || false)  // false

3.2 真值表 #

A B A || B
true true true
true false true
false true true
false false false

3.3 短路求值 #

如果第一个操作数为true，不会计算第二个：

go 
func returnsTrue() bool {
    fmt.Println("不会执行")
    return true
}

result := true || returnsTrue()
fmt.Println(result)  // true

3.4 实际应用 #

go 
role := "admin"

if role == "admin" || role == "superuser" {
    fmt.Println("有管理权限")
}

四、逻辑非 (!) #

4.1 基本用法 #

取反操作：

go 
fmt.Println(!true)   // false
fmt.Println(!false)  // true

4.2 真值表 #

A !A
true false
false true

4.3 实际应用 #

go 
isLoggedIn := false

if !isLoggedIn {
    fmt.Println("请先登录")
}

五、组合使用 #

5.1 混合运算 #

go 
a := true
b := false
c := true

result := a && b || c
fmt.Println(result)  // true

result2 := a && (b || c)
fmt.Println(result2)  // true

result3 := (a && b) || c
fmt.Println(result3)  // true

5.2 复杂条件 #

go 
age := 25
hasLicense := true
isDrunk := false

if age >= 18 && hasLicense && !isDrunk {
    fmt.Println("可以驾驶")
}

5.3 德摩根定律 #

go 
// !(A && B) 等价于 !A || !B
// !(A || B) 等价于 !A && !B

a := true
b := false

fmt.Println(!(a && b) == (!a || !b))  // true
fmt.Println(!(a || b) == (!a && !b))  // true

六、短路求值应用 #

6.1 避免空指针 #

go 
var p *Person

if p != nil && p.Name == "Tom" {
    fmt.Println("找到Tom")
}

6.2 默认值设置 #

go 
func getName(name string) string {
    if name == "" {
        return "默认名称"
    }
    return name
}

// 使用短路求值简化
func getName2(name string) string {
    return name != "" && name || "默认名称"  // 不推荐，可读性差
}

6.3 条件执行 #

go 
shouldLog := true
shouldLog && logMessage("操作完成")  // Go不支持这种写法

// 正确写法
if shouldLog {
    logMessage("操作完成")
}

七、实际应用示例 #

7.1 用户验证 #

go 
func validateUser(username, password string) bool {
    return username != "" && password != "" && len(password) >= 6
}

fmt.Println(validateUser("admin", "123456"))  // true
fmt.Println(validateUser("admin", "123"))     // false

7.2 权限检查 #

go 
func hasPermission(user User, resource string) bool {
    return user.Role == "admin" || 
           user.Role == "manager" ||
           contains(user.Permissions, resource)
}

7.3 范围检查 #

go 
func isInRange(value, min, max int) bool {
    return value >= min && value <= max
}

fmt.Println(isInRange(5, 1, 10))   // true
fmt.Println(isInRange(15, 1, 10))  // false

7.4 多条件筛选 #

go 
func filterProducts(products []Product, minPrice, maxPrice float64, inStock bool) []Product {
    var result []Product
    for _, p := range products {
        if p.Price >= minPrice && p.Price <= maxPrice && (p.Stock > 0 || !inStock) {
            result = append(result, p)
        }
    }
    return result
}

八、常见错误 #

8.1 运算符优先级 #

go 
a := true
b := false
c := true

result := a || b && c  // a || (b && c) = true
fmt.Println(result)

result2 := (a || b) && c  // true && true = true
fmt.Println(result2)

8.2 位运算混淆 #

go 
// 逻辑运算符
fmt.Println(true && false)  // false
fmt.Println(true || false)  // true

// 位运算符
fmt.Println(1 & 2)  // 0
fmt.Println(1 | 2)  // 3

8.3 非布尔值 #

Go不支持非布尔值的逻辑运算：

go 
// 错误：不能将非布尔值用于逻辑运算
if 1 && 2 {  // 编译错误
    fmt.Println("true")
}

// 正确
if 1 > 0 && 2 > 0 {
    fmt.Println("true")
}

九、最佳实践 #

9.1 使用括号提高可读性 #

go 
if (a > 0 && b > 0) || (c > 0 && d > 0) {
    fmt.Println("条件满足")
}

9.2 避免复杂表达式 #

go 
isAdult := age >= 18
hasLicense := license != nil
isDrunk := bloodAlcohol > 0

if isAdult && hasLicense && !isDrunk {
    fmt.Println("可以驾驶")
}

9.3 利用短路求值 #

go 
if user != nil && user.IsActive() {
    fmt.Println("用户有效")
}

十、总结 #

逻辑运算符要点：

运算符 说明 短路行为
&& 逻辑与 第一个为false时短路
|| 逻辑或 第一个为true时短路
! 逻辑非 无短路

关键点：

  1. 操作布尔值：只能用于布尔类型
  2. 短路求值：提高效率，避免不必要的计算
  3. 优先级：! > && > ||
  4. 可读性：复杂条件使用括号和中间变量

准备好学习位运算符了吗？让我们进入下一章！

最后更新：2026-03-26