《Go 简易速速上手小册》第2章：控制结构与函数（2024 最新版）（下）

package main
import "fmt"
// User 定义用户结构体
type User struct {
    Name string
    Age  int
}
// 模拟用户数据
var users = []User{
    {"Alice", 30},
    {"Bob", 25},
    {"Carol", 35},
    {"David", 28},
}
func main() {
    var totalAge, maxAge, minAge int
    var youngest, oldest User
    minAge = users[0].Age
    for _, user := range users {
        totalAge += user.Age
        if user.Age > maxAge {
            maxAge = user.Age
            oldest = user
        }
        if user.Age < minAge {
            minAge = user.Age
            youngest = user
        }
    }
    averageAge := float64(totalAge) / float64(len(users))
    fmt.Printf("用户平均年龄: %.2f\n", averageAge)
    fmt.Printf("最年轻的用户: %s (%d岁)\n", youngest.Name, youngest.Age)
    fmt.Printf("最年长的用户: %s (%d岁)\n", oldest.Name, oldest.Age)
}

func groupUsers(users []User) (youngUsers, middleAgedUsers, seniorUsers []User) {
    for _, user := range users {
        switch {
        case user.Age < 30:
            youngUsers = append(youngUsers, user)
        case user.Age <= 50:
            middleAgedUsers = append(middleAgedUsers, user)
        default:
            seniorUsers = append(seniorUsers, user)
        }
    }
    return youngUsers, middleAgedUsers, seniorUsers
}
func main() {
    // 省略上面的平均年龄、最年轻和最年长用户的计算代码
    youngUsers, middleAgedUsers, seniorUsers := groupUsers(users)
    fmt.Printf("年轻用户: %v\n", youngUsers)
    fmt.Printf("中年用户: %v\n", middleAgedUsers)
    fmt.Printf("资深用户: %v\n", seniorUsers)
}

func functionName(param1 type1, param2 type2) returnType {
    // 函数体
    return value
}

func sayHello(name string) {
    fmt.Printf("Hello, %s!\n", name)
}

func divide(a, b float64) (float64, error) {
    if b == 0.0 {
        return 0.0, fmt.Errorf("除数不能为 0")
    }
    return a / b, nil
}

package main
import "fmt"
// FilterFunc 定义了过滤函数的类型
type FilterFunc func(int) bool
// filterNumbers 接受一个整数切片和过滤函数，返回一个新的切片，包含所有符合过滤条件的整数
func filterNumbers(numbers []int, filter FilterFunc) []int {
    var filtered []int
    for _, num := range numbers {
        if filter(num) {
            filtered = append(filtered, num)
        }
    }
    return filtered
}
// 示例过滤条件
func isEven(number int) bool {
    return number%2 == 0
}
func isOdd(number int) bool {
    return number%2 != 0
}
func main() {
    numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    
    // 使用 isEven 过滤条件
    evens := filterNumbers(numbers, isEven)
    fmt.Println("偶数：", evens)
    
    // 使用 isOdd 过滤条件
    odds := filterNumbers(numbers, isOdd)
    fmt.Println("奇数：", odds)
}

func greaterThanFive(number int) bool {
    return number > 5
}
func main() {
    // 省略之前的示例
    // 使用 greaterThanFive 过滤条件
    greaterNums := filterNumbers(numbers, greaterThanFive)
    fmt.Println("大于 5 的数：", greaterNums)
}

package main
import (
    "fmt"
    "unicode/utf8"
)
// reverseString 翻转字符串
func reverseString(s string) string {
    runes := []rune(s)
    for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
        runes[i], runes[j] = runes[j], runes[i]
    }
    return string(runes)
}
// isPalindrome 判断字符串是否为回文
func isPalindrome(s string) bool {
    return s == reverseString(s)
}
func main() {
    input := "level"
    reversed := reverseString(input)
    fmt.Printf("原字符串: %s\n", input)
    fmt.Printf("翻转后: %s\n", reversed)
    fmt.Printf("字符数量: %d\n", utf8.RuneCountInString(input))
    if isPalindrome(input) {
        fmt.Println("字符串是回文")
    } else {
        fmt.Println("字符串不是回文")
    }
}

package main
import (
    "bufio"
    "fmt"
    "math"
    "os"
    "strconv"
    "strings"
)
// calculate 执行数学运算
func calculate(a float64, b float64, operation string) (float64, error) {
    switch operation {
    case "+":
        return a + b, nil
    case "-":
        return a - b, nil
    case "*":
        return a * b, nil
    case "/":
        if b == 0 {
            return 0, fmt.Errorf("除数不能为 0")
        }
        return a / b, nil
    case "^":
        return math.Pow(a, b), nil
    case "sqrt":
        if a < 0 {
            return 0, fmt.Errorf("被开方数不能为负")
        }
        return math.Sqrt(a), nil
    default:
        return 0, fmt.Errorf("未知的运算符")
    }
}
func main() {
    reader := bufio.NewReader(os.Stdin)
    fmt.Println("简单计算器")
    fmt.Print("请输入表达式 (例如 2 + 3 或 sqrt 4): ")
    input, _ := reader.ReadString('\n')
    parts := strings.Fields(input)
    if len(parts) < 2 {
        fmt.Println("输入格式错误")
        return
    }
    operation := parts[1]
    a, err := strconv.ParseFloat(parts[0], 64)
    if err != nil {
        fmt.Println("解析数字错误:", err)
        return
    }
    var b float64
    if operation != "sqrt" { // 平方根运算只需要一个参数
        if len(parts) != 3 {
            fmt.Println("输入格式错误")
            return
        }
        b, err = strconv.ParseFloat(parts[2], 64)
        if err != nil {
            fmt.Println("解析数字错误:", err)
            return
        }
    }
    result, err := calculate(a, b, operation)
    if err != nil {
        fmt.Println("计算错误:", err)
        return
    }
    fmt.Printf("结果: %v\n", result)
}