Golang布尔类型使用与逻辑运算实例

bool

true

false

&&

||

!

bool

true

false

0

null

package main

import "fmt"

func main() {
    // 声明一个布尔变量，默认值为 false
    var isActive bool
    fmt.Println("isActive 的默认值:", isActive) // 输出: false

    // 声明并初始化
    var isReady = true
    fmt.Println("isReady 的值:", isReady) // 输出: true

    // 短声明并初始化
    hasPermission := false
    fmt.Println("hasPermission 的值:", hasPermission) // 输出: false

    // 逻辑运算符的使用
    a := true
    b := false

    // 逻辑与 (AND): 只有当a和b都为true时，结果才为true
    resultAND := a && b
    fmt.Println("a && b:", resultAND) // 输出: false

    // 逻辑或 (OR): 只要a和b中有一个为true，结果就为true
    resultOR := a || b
    fmt.Println("a || b:", resultOR) // 输出: true

    // 逻辑非 (NOT): 反转布尔值
    resultNOT_a := !a
    fmt.Println("!a:", resultNOT_a) // 输出: false

    resultNOT_b := !b
    fmt.Println("!b:", resultNOT_b) // 输出: true

    // 复杂表达式
    canAccess := (isReady && hasPermission) || isActive
    fmt.Println("canAccess:", canAccess) // 输出: false
}

0

1

&&

||

&&

false

false

||

true

true

package main

import "fmt"

func mightPanic() bool {
    fmt.Println("mightPanic() 被调用了")
    // 模拟一个可能导致 panic 的情况
    // var ptr *int = nil
    // fmt.Println(*ptr) // 如果没有短路，这里会 panic
    return true
}

func main() {
    // 示例1: 逻辑与 (&&) 的短路
    // 如果 falseFunc() 返回 false，mightPanic() 就不会被调用
    if falseFunc() && mightPanic() {
        fmt.Println("这个不会被打印")
    }

    fmt.Println("---")

    // 示例2: 逻辑或 (||) 的短路
    // 如果 trueFunc() 返回 true，mightPanic() 就不会被调用
    if trueFunc() || mightPanic() {
        fmt.Println("这个会被打印")
    }
}

func falseFunc() bool {
    fmt.Println("falseFunc() 被调用了")
    return false
}

func trueFunc() bool {
    fmt.Println("trueFunc() 被调用了")
    return true
}

mightPanic()

if

falseFunc()

false

&&

if

trueFunc()

true

||

mightPanic()

nil

nil

if obj != nil && obj.IsActive() { ... }

obj

nil

obj.IsActive()

if-else

for

switch

if-else

if

package main

import (
    "fmt"
    "errors"
)

func processData(data int) (string, error) {
    if data < 0 {
        return "", errors.New("数据不能为负数")
    }
    if data == 0 {
        return "数据为零", nil
    }
    return fmt.Sprintf("处理了数据: %d", data), nil
}

func main() {
    // 经典的 if-else if-else 结构
    score := 85
    if score >= 90 {
        fmt.Println("优秀")
    } else if score >= 60 {
        fmt.Println("及格")
    } else {
        fmt.Println("不及格")
    }

    // 带初始化语句的 if
    if result, err := processData(10); err != nil {
        fmt.Println("处理数据出错:", err)
    } else {
        fmt.Println("数据处理成功:", result)
    }

    if _, err := processData(-5); err != nil { // 错误处理的常见模式
        fmt.Println("处理数据出错:", err)
    }
}

if err != nil

for

for

true

false

package main

import "fmt"

func main() {
    count := 0
    // 循环直到 count 达到 5
    for count < 5 {
        fmt.Println("当前计数:", count)
        count++
    }

    // 也可以是更复杂的布尔表达式
    isLoggedIn := true
    hasRetries := 3
    for isLoggedIn && hasRetries > 0 {
        fmt.Println("尝试操作，剩余重试次数:", hasRetries)
        // 模拟一些操作，可能改变 isLoggedIn 或 hasRetries
        hasRetries--
        if hasRetries == 0 {
            isLoggedIn = false // 模拟操作失败或完成
        }
    }
    fmt.Println("循环结束")
}

for

switch

switch

package main

import "fmt"

func main() {
    age := 25
    isStudent := true
    hasLicense := false

    switch { // 裸 switch，case 后跟布尔表达式
    case age < 18:
        fmt.Println("未成年")
    case age >= 18 && isStudent:
        fmt.Println("成年学生")
    case age >= 18 && !isStudent && hasLicense:
        fmt.Println("成年非学生，有驾照")
    default:
        fmt.Println("其他情况")
    }
}

switch

case

true

case

fallthrough

if-else if