对于GoLang函数的定义或者说理解：
函数是结构化编程中最小的模块单元，日常开发过程中，将复杂的算法过程分解为若干个小任务(代码块)，使程序的结构性更清晰，程序可读性提升，易于后期维护和让别人读懂你的代码。
另外为了更好的重用你的代码，可以把重复性的任务抽象成一个函数。
Go语言中使用关键词func来定义一个函数，并且左花括号不能另起一行，比如：
func hello(){ //左花括号不能另起一行
println("hello")
}Go语言中定义和应用函数时，有如下需要注意的点：
函数无须前置声明
不支持命名嵌套定义，支持匿名嵌套
函数只能判断是否为nil，不支持其它比较操作
支持多返回值
支持命名返回值
支持返回局部变量指针
支持匿名函数和闭包
func hello()
{ //左括号不能另起一行
}
func add(x,y int) (sum int){ //命名返回值
sum = x + y
return
}
func vals()(int,int){ //支持多返回值
return 2,3
}
func a(){}
func b(){}
func add(x,y int) (*int){ //支持返回局部变量指针
sum := x + y
return &sum
}
func main(){
println(a==b) //只能判断是否为nil，不支持其它比较操作
func hello() { //不支持命名嵌套定义
println("hello")
}
}具备相同签名(参数和返回值)的函数才视为同一类型函数，比如：
func hello() {
fmt.Println("hello")
}
func say(f func()){
f()
}
func main(){
f := hello
say(f)
}参数：
Go语言中给函数传参时需要注意以下几点：
不支持默认参数
不支持命名实参
参数视作为函数的局部变量
必须按签名顺序传递指定类型和数量的实参
相邻的同类型参数可以合并
支持不定长变参，实质上是slice
func test(x,y int, s string, _ bool){ //相邻的同类型参数可以合并
return
}
func add(x ,y int) int { //参数视作为函数的局部变量
x := 100 //no new variables on left side of :=
var y int = 200 //y redeclared in this block
return x +y
}
func sum(nums ...int) { //变参函数
total := 0
for _, num := range nums {
total += num
}
fmt.Println(total)
}
func main(){
//test(1,2,"s") //not enough arguments in call to test
test(1,2,"s",false)
nums := []int{1, 2, 3}
sum(nums...)
}不管传递的是指针、引用还是其它类型参数，都是值拷贝传递的，区别在于拷贝的目标是目标对象还是拷贝指针而已。
在函数调用之前，编译器会为形参和返回值分配内存空间，并将实参拷贝到形参内存。比如：
func test1(x *int){
fmt.Printf("%p, %v\n",&x ,x)
}
func main(){
a := 0x100
p := &a
fmt.Printf("%p, %v\n", &p, p)
test1(p)
}
输出：
0xc42002c020, 0xc42000a320
0xc42002c030, 0xc42000a320
从结构中看出， 实参和形参指向同一目标，但是传递的指针是被赋值了的如果函数参数和返回值过多，可以将其封装成一个结构体类型，比如：
type serverOption struct{
addr string
port int
path string
timeout time.Duration
}
func newOption() * serverOption{
return &serverOption{
addr:"127.0.0.1",
port:8080,
path:"/var/www",
timeout: time.Second * 5,
}
}
func (s *serverOption)server(){
println("run server")
}
func main(){
s := newOption()
s.port = 80
s.server()
for{}
}变参：
变参本质上是一个切片(slice)，只能接收一到多个同类型参数，且必须放在参数列表尾部，比如：
func add(args ...int) int {
total := 0
for _, v := range args {
total += v
}
return total
}
func main() {
fmt.Println(add(1,2,3))
}变参既然是切片，那是否可以直接传个切片或数组呢？
func test1(s string, a ...int){
fmt.Printf("%T, %v\n", a, a) //[]int, [1 2 3 4]
}
{
a := [4]int{1,2,3,4}
test1("s", a) //cannot use a (type [4]int) as type int in argument to test1
test1("s", a[:] //cannot use a[:] (type []int) as type int in argument to test1
test1("s", a[:]...) //切片展开
}变参既然是切片，那么参数复制的是切片的本身，并不包括底层的数组，因此可以修改原数据，但是可以copy底层数据，防止原数据被修改，比如：
func test1(a ...int){
for i := range a{
a[i] += 100
}
}
func main(){
a := [4]int{1,2,3,4}
// b := make([]int,0)
// copy(b,a[:])
// test1(b[:]...)
test1(a[:]...)
for i := range a{
fmt.Println(a[i])
}
}