再看函数，把重复代码收起来

说到本章目标。把重复逻辑收进函数里做到三件事就算过关：会写函数、会传参数、会接返回值。

使用者痛点：在实际项目中。你是否因为同一段业务逻辑散落在多个文件里而花费大量时间去定位、修改，导致代码维护成本飙升？使用函数把这些重复代码收敛，是最直接的解决办法。

常见坑位

• 代码还没重复。就提前拆一堆函数，最终自己都看不懂。
• 函数写好了但忘了在 main 里调用，运行后啥都没发生。
• 参数和返回值方向搞反：把“输入”写成“输出”。说起来，
• 看见多返回值就紧张。就是“一个函数一次带回多个结果”。
• 误以为函数里改了变量，外面大概率会变。Go 默认是值传递，不大概率会变。按理说，

先跑一个最小示例

先跑起来再理解细节。这是最省时间的学习方式，老实说，

package main
import "fmt"
func sayHello {
fmt.Println
}
func main {
sayHello
sayHello
}

看到两行输出就说明你已经会“定义 + 调用”函数了。

带参数的函数

参数可以理解成“你喂给函数的数据”。

package main
import "fmt"
func sayHi {
fmt.Println
}
func main {
sayHi
sayHi
}

这里 name string 的意思是：这个函数接收一个字符串类型的名字。

带返回值的函数

返回值就是“函数做完活后交回来的结果”。按理说，

package main
import "fmt"
func add int {
return a + b
}
func main {
result := add
fmt.Println // 8
}

再看多返回值。Go 的高频写法

Go 很常见的一个特点是：一个函数可以返回多个值。

package main
import "fmt"
func divide {
if b == 0 {
return 0,"不能除以零"
}
return a / b,""
}
func main {
result,msg := divide
fmt.Println // 5
result2。
msg2 := divide
fmt.Println // 0 不能除以零
}

后面你会大量见到这种形式：

value,err := someFunc

前面是结果，后面是错误信息。下一章我们专门讲这个模式。

再看变长参数，参数个数不固定

当你不确定要传几个参数时用 ...。

package main
import "fmt"
func sum int {
total := 0
for _,n := range nums {
total += n
}
return total
}
func main {
fmt.Println) // 6
fmt.Println) // 22
}

nums ...int 在函数内部本质上就是 int这点后面学切片时会越用越顺。

匿名函数的观点是，临时用一次不想起名

匿名函数就是“没有名字的函数”。它们常用于一次性回调或闭包场景。

package main
import "fmt"
func main {
greet := func {
fmt.Println
}
greet
greet
func {
fmt.Println
}
}

闭包这方面。匿名函数能记住外面的变量

package main
import "fmt"
func counter func int {
count := 0
return func int {
count++
return count
}
}
func main {
next := counter
fmt.Println) // 1
fmt.Println) // 2
fmt.Println) // 3
}

这里返回的匿名函数记住了 count,这就是闭包。其实，

使用者痛点：If you find yourself writing same looping logic over and over again across different packages—using a closure can encapsulate that state once and reuse it everywhere.

• 闭包可以访问外层变量。
• 闭包会让外层变量活得更久，别长期挂大对象。

函数还能当参数传来传去

Go 里函数也是“值”。可以传给别的函数，实现高度可组合的代码结构。

package main
import "fmt"
func apply int) int {
result := make)
for _,n := range nums {
result = append)
}
return result
}
func main {
doubled := apply int { return n * 2 })
fmt.Println //
}

值传递和引用类型。一次讲清

User Pain Point:You often wonder *** modifying a slice inside a function also changes original data outside—understanding Go's value semantics clears this confusion.

• # 值传递： 基本类型在调用时会拷贝完整数据，内部修改不会影响外部变量。
• # 引用型结构体头： 切片）虽然本身是值拷贝。但内部指向同一块底层数据，所以对元素的修改在调用者处可见。

过关标准

• 能自己写出并调用一个无参数函数。按理说，
• 能写一个带参数函数。并传入不同数据，按理说，
.
• 能写一个带返回值函数。并正确接收结果，
• 看到 value,err = xxx 不再慌。li> - 能说清 “ 值 ” 和 “slice/map 的表现差异”。