函数

|
func 函数名(参数列表) (返回值列表) {
    函数体
}

|
func calculateDistance(x1, y1 float64) float64 {
    return math.Sqrt(x1*x1 + y1*y1)
}
fmt.Println(calculateDistance(4, 3)) // 输出 "5"

|
func processData(a, b, c int, name, address string) { /* ... */ }
func processData(a int, b int, c int, name string, address string) { /* ... */ }

|
func add(x int, y int) int { return x + y }
func subtract(x, y int) (result int) { result = x - y; return }
func getFirst(x int, _ int) int { return

|
func processStudentGrade(name string, score int, class string) (string, error, int) {
    // 验证学生姓名
    if len(name) == 0 {
        return "", fmt.Errorf("学生姓名不能为空"), 400
    }
    
    // 验证成绩范围
    if score < 0 ||

|
result, err, status := processStudentGrade("张三", 85, "计算机科学1班")

|
result, _, status := processStudentGrade("李四", 92, "数学系2班") // 忽略错误

|
func processStudentGradeWithLog(name string, score int, class string) (string, error, int) {
    log.Printf("正在处理学生成绩 - 姓名: %s, 成绩: %d, 班级: %s", name, score, class)
    return processStudentGrade(name, score, class)
}

|
log.Println(processStudentGrade("王五", 78, "物理系3班"))
result, err, status := processStudentGrade("赵六", 88, "化学系1班")
log.Println(result, err, status)

|
func calculateStudentStats(name string, scores []int) (average float64,
 highest int, lowest int, err error) {
    if len(scores) == 0 {
        err = fmt.Errorf("成绩列表不能为空")
        return
    }
    
    highest = scores[

|
return average, highest, lowest, err

|
student, ok := studentDatabase.Lookup(studentID)
if !ok {
    // ...数据库中不存在该学生信息...
}

|
if score < 0 || score > 100 {
    return "", fmt.Errorf("成绩必须在0-100之间，当前成绩: %d", score), 400
}

|
file, err := os.Open("students.txt")
if err != nil {
    return nil, fmt.Errorf("打开学生文件时出错: %v", err)
}

|
程序崩溃: 无法保存成绩: 文件系统错误: 磁盘空间不足

|
func waitForDatabaseConnection(url string) error {
    const timeout = 30 * time.Second
    deadline := time.Now().Add(timeout)
    
    for tries := 0; time.Now().Before(deadline); tries++ {
        _, err := testDatabaseConnection(url)
        if err == nil

|
// (在main函数中)
if err := waitForDatabaseConnection(dbURL); err != nil {
    fmt.Fprintf(os.Stderr, "数据库连接失败: %v\n", err)
    os.Exit(1)
}

|
if err := waitForDatabaseConnection(dbURL); err != nil {
    log.Fatalf("数据库连接失败: %v\n", err)
}

|
2006/01/02 15:04:05 数据库连接失败: 连接被拒绝: localhost:5432

|
log.SetPrefix("成绩系统: ")
log.SetFlags(0)

|
if err := backupStudentData(); err != nil {
    log.Printf("数据备份失败: %v; 继续运行但建议检查", err)
}

|
if err := backupStudentData(); err != nil {
    fmt.Fprintf(os.Stderr, "数据备份失败: %v; 继续运行但建议检查\n", err)
}

|
tempDir, err := ioutil.TempDir("", "grades")
if err != nil {
    return fmt.Errorf("创建临时目录失败: %v", err)
}
// ...使用临时目录处理成绩数据...
os.RemoveAll(tempDir) // 忽略错误; 系统会定期清理临时目录

|
package io
 
import "errors"
 
// EOF是当没有更多输入可用时Read返回的错误。
var EOF = errors.New("EOF")

|
file, _ := os.Open("students.txt")
reader := bufio.NewReader(file)
for {
    line, err := reader.ReadString('\n')
    if err == io.EOF {
        break // 读取完成
    }
    if err != nil {
        return fmt.Errorf("读取学生数据失败: 

|
func calculateGrade(score int) string { 
    if score >= 90 { return "优秀" }
    if score >= 80 { return "良好" }
    if score >= 70 { return "中等" }
    if score >= 60 { return "及格" }
    return "不及格"

|
var f func(int) string
f(85) // panic: 调用nil函数

|
var f func(int) string
if f != nil {
    f(85)
}

|
func processScores(scores []int, processor func(int) string) []string {
    var results []string
    for _, score := range scores {
        results = append(results, processor(score))
    }
    return results
}
 
// 不同的处理策略
func gradeProcessor(score

|
// processStudentInfo为每个学生信息调用指定的处理函数
// 这个函数将遍历逻辑与具体的处理逻辑分离
func processStudentInfo(students []Student, processor func(Student) string) []string {
    var results []string
    for _, student := range students {
        results = append(results, processor(student))
    }
    return results
}
 
type Student

|
students := []Student{
    {"张三", 85, "计算机科学1班"},
    {"李四", 92, "数学系2班"},
    {"王五", 78, "物理系3班"},
}
 
gradeReports := processStudentInfo(students, gradeReportProcessor)
classReports := processStudentInfo(students, classReportProcessor)
summaries := processStudentInfo(students, summaryProcessor)

|
// 直接使用匿名函数处理成绩
scores := []int{85, 92, 78, 65, 88}
processed := processScores(scores, func(score int) string {
    if score >= 90 { return "优秀" }
    if score >= 80 { return "良好" }

|
// gradeCounter返回一个函数，该函数在每次调用时返回下一个成绩等级计数器。
func gradeCounter() func() int {
    var count int
    return func() int {
        count++
        return count
    }
}
 
func main() {
    f := gradeCounter()
    fmt.Println(f()) // 输出 "1"
    fmt.Println(

|
// courseRequirements将课程映射到学生必须达到的成绩要求。
var courseRequirements = map[string]int{
    "高级算法": 85,
    "数据结构": 70,
    "编程基础": 60,
    "数学分析": 80,
    "计算机组成": 75,
    "操作系统": 80,
    "数据库系统": 75,
    "网络编程": 

|
func main() {
    for i, course := range courseRecommendationSort(courseRequirements) {
        fmt.Printf("%d:\t%s\n", i+1, course)
    }
}
 
func courseRecommendationSort(m map[string]int) []string {
    var order []string
    seen :=

|
visitAll := func(items []string) {
    // ...
    visitAll(dependents) // 编译错误: 未定义: visitAll
    // ...
}

|
1: 编程基础
2: 数据结构
3: 网络编程
4: 计算机组成
5: 数据库系统
6: 软件工程
7: 数学分析
8: 操作系统
9: 高级算法
10: 人工智能

|
// processStudentGrades处理学生成绩信息并返回格式化的报告
func processStudentGrades(students []Student) []string {
    var reports []string
    
    // 使用匿名函数直接处理每个学生
    processFunc := func(student Student) string {
        grade := calculateGrade(student.Score)
        return fmt.Sprintf("学生: %s, 班级: %s, 成绩: %d, 等级: %s

|
// breadthFirst为worklist中的每个项目调用f。
// f返回的任何项目都会添加到worklist中。
// f最多为每个项目调用一次。
func breadthFirst(f func(item string) []string, worklist []string) {
    seen := make(map[string]bool)
    for len(worklist) > 0 {
        items := worklist
        worklist = nil

|
func calculateAverage(scores ...int) float64 {
    if len(scores) == 0 {
        return 0.0
    }
    total := 0
    for _, score := range scores {
        total += score
    }
    return float64(total) / float64(len(scores))
}

|
fmt.Println(calculateAverage())                    // 输出 "0"
fmt.Println(calculateAverage(85))                 // 输出 "85"
fmt.Println(calculateAverage(85, 92, 78, 96))    // 输出 "87.75"

|
studentScores := []int{85, 92, 78, 96}
fmt.Println(calculateAverage(studentScores...)) // 输出 "87.75"

|
func f(...int) {}
func g([]int) {}
 
fmt.Printf("%T\n", f) // 输出 "func(...int)"
fmt.Printf("%T\n", g) // 输出 "func([]int)"

|
func generateGradeReport(className string, students ...string) string {
    if len(students) == 0 {
        return fmt.Sprintf("班级 %s: 暂无学生信息", className)
    }
    
    report := fmt.Sprintf("班级 %s 成绩报告\n", className)
    report +=

|
func processStudentGrades(filename string) error {
    file, err := os.Open(filename)
    if err != nil {
        return fmt.Errorf("无法打开成绩文件 %s: %v", filename, err)
    }
    // 检查文件是否为成绩文件格式
    reader := bufio.NewReader(file)
    firstLine, err := reader.ReadString(

|
func processStudentGrades(filename string) error {
    file, err := os.Open(filename)
    if err != nil {
        return fmt.Errorf("无法打开成绩文件 %s: %v", filename, err)
    }
    defer file.Close()
    
    reader := bufio.NewReader(file)
    firstLine, err 

|
func readStudentData(filename string) ([]byte, error) {
    f, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    defer f.Close()
    return ioutil.ReadAll(f)
}

|
var mu sync.Mutex
var studentDatabase = make(map[string]Student)
 
func lookupStudent(studentID string) (Student, bool) {
    mu.Lock()
    defer mu.Unlock()
    student, exists := studentDatabase[studentID]
    return student, exists
}

|
func processStudentGradesBatch(studentCount int) {
    defer trace("processStudentGradesBatch")() // 不要忘记额外的括号
    // ...大量工作...
    time.Sleep(5 * time.Second) // 通过睡眠模拟批量处理操作
}
 
func trace(msg string) func() {
    start := time.Now()
    log.Printf("进入 %s"

|
func calculateGrade(score int) string {
    if score >= 90 {
        return "优秀"
    } else if score >= 80 {
        return "良好"
    } else if score >= 70 {
        return "中等"
    } else if score >= 60 {
        return

|
func calculateGrade(score int) (grade string) {
    defer func() { fmt.Printf("calculateGrade(%d) = %s\n", score, grade) }()
    if score >= 90 {
        return "优秀"
    } else if score >= 80 {
        return "良好"
    } else if score >=

|
func calculateGradeWithBonus(score int) (grade string) {
    defer func() { grade += " (有奖励)" }()
    return calculateGrade(score)
}
 
fmt.Println(calculateGradeWithBonus(85)) // 输出 "良好 (有奖励)"

|
for _, filename := range filenames {
    f, err := os.Open(filename)
    if err != nil {
        return err
    }
    defer f.Close() // 注意: 有风险; 可能会耗尽文件描述符
    // ...处理 f...
}

|
for _, filename := range filenames {
    if err := processStudentFile(filename); err != nil {
        return err
    }
}
 
func processStudentFile(filename string) error {
    f, err := os.Open(filename)
    if err != nil {
        return err
    }
    defer

|
// processStudentGrades处理学生成绩数据并返回输出文件的名称和长度。
func processStudentGrades(inputFile string) (outputFile string, n int64, err error) {
    file, err := os.Open(inputFile)
    if err != nil {
        return "", 0, err
    }
    defer file.Close()
    
    output := path.

|
switch grade := calculateGrade(score); grade {
case "优秀": // 处理优秀等级
case "良好": // 处理良好等级
case "中等": // 处理中等等级
case "及格": // 处理及格等级
case "不及格": // 处理不及格等级
default:
    panic(fmt.Sprintf("无效的成绩等级 %q", grade)) // 不应该出现的情况
}

|
func processStudentData(student *Student) {
    if student == nil {
        panic("学生数据为nil") // 不必要!
    }
    student.Score = calculateFinalScore(student)
}

|
package gradevalidator
 
func ValidateGradeFormat(grade string) (bool, error) { /* ... */ }
 
func MustValidateGradeFormat(grade string) bool {
    valid, err := ValidateGradeFormat(grade)
    if err != nil {
        panic(err)
    }
    return valid
}

|
var validGradePattern = MustValidateGradeFormat(`^[0-9]{1,3}$`) // 0-999的成绩格式

|
func main() {
    processStudentGrades(3)
}
 
func processStudentGrades(studentCount int) {
    fmt.Printf("处理学生成绩 %d\n", studentCount/0) // 如果 studentCount == 0 则panic
    defer fmt.Printf("延迟处理 %d\n", studentCount)
    processStudentGrades(studentCount - 1)
}

|
处理学生成绩 3
处理学生成绩 2
处理学生成绩 1
延迟处理 1
延迟处理 2
延迟处理 3

|
panic: runtime error: integer divide by zero
 
main.processStudentGrades(0)
    src/grade_system/panic1/panic.go:14
main.processStudentGrades(1)
    src/grade_system/panic1/panic.go:16
main.processStudentGrades(2)
    src/grade_system/panic1/panic.go:16
main.processStudentGrades(3)
    src/grade_system/panic1/panic.go:16
main.main()
    src/grade_system/panic1/panic.go:10

|
func main() {
    defer printStack()
    processStudentGrades(3)
}
 
func printStack() {
    var buf [4096]byte
    n := runtime.Stack(buf[:], false)
    os.Stdout.Write(buf[:n])
}

|
goroutine 1 [running]:
main.printStack()
    src/grade_system/panic2/panic.go:20
main.processStudentGrades(0)
    src/grade_system/panic2/panic.go:27
main.processStudentGrades(1)
    src/grade_system/panic2/panic.go:29
main.processStudentGrades(2)
    src/grade_system/panic2/panic.go:29
main.processStudentGrades(3)
    src/grade_system/panic2/panic.go:29
main.main()
    src/grade_system/panic2/panic.go:15

|
func ParseGradeData(input string) (gradeData *GradeData, err error) {
    defer func() {
        if p := recover(); p != nil {
            err = fmt.Errorf("成绩数据解析内部错误: %v", p)
        }
    }()
    // ...成绩数据解析器...
}

|
// findUniqueStudent返回学生列表中第一个非空学号的学生信息，
// 如果没有恰好一个，则返回错误。
func findUniqueStudent(students []Student) (student Student, err error) {
    type bailout struct{}
    
    defer func() {
        switch p := recover(); p {
        case nil:
            // 没有panic
        case bailout{}:
            // "预期的"panic
            err =

|
10 + 20 = 30
15 / 3 = 5
5 + 6 = 11, 5 * 6 = 30

|
10 / 2 = 5.00
错误: 除数不能为零
最大值: 9
错误: 切片为空，无法查找最大值

|
sum(1, 2, 3) = 6
sum(10, 20, 30, 40) = 100
max(5, 8, 3, 9, 2) = 9
姓名: 张三
成绩: [85 90 88]
平均分: 87.67
姓名: 李四
成绩: []
平均分: 0.00

|
=== 示例1: defer执行顺序 ===
函数开始
函数执行中
defer 2: 后进先出
defer 1: 函数结束前执行
 
=== 示例2: defer在循环中 ===
循环结束
defer: i = 2
defer: i = 1
defer: i = 0
 
=== 示例3: defer捕获变量值 ===
函数中: x = 20
defer: x = 10
 
=== 示例4: defer与recover ===
准备触发panic
捕获到panic: 这是一个panic
程序继续执行