优惠的网站快排公司电话单位网址怎么编

1.简介

函数是组织好的、可重复使用的，用于执行指定任务的代码块，为了完成某一个功能的程序指令的集合，称为函数。go语言中支持：函数、匿名函数和闭包。

2.函数的定义

func 函数名 (形参列表) (返回值列表){

函数体 

return 返回值列表

}

其中：

• 函数名：由字母、数字、下划线组成。但函数名第一个字母不能是数字。在同一个包内，函数名也不能重名。
• 形参列表：参数由参数变量和参数变量的类型组成，做个参数之前是用逗号分割。
• 返回值：返回值由返回之变量和其类型组成，也可以只写返回值的类型，多个返回值必须用（）包裹，并用逗号分隔。
• 函数体：实现指定功能的代码块。

3.基本用法 

3.1函数的基本用法

函数的参数和返回值都是可选的，例如我们可以实现一个即不需要参数也不需要返回值的函数：

func sayHello() {fmt.Println("sayhello")
}

 

3.2求两个数的和

func sumFn(a int, b int) int {return a + b
}

 调用：

func main() {sum := sumFn(10, 13)fmt.Println(sum)
}

 注意：调用的函数有返回值时，可以不接受其返回值。

3.3函数简写（求两个数的差）

函数的参数中如果相邻变量的类型相同，则可以省略类型，例如下面代码中，subFn函数有两个参数，这两个参数的类型相同，因此可以省略a的类型，因为b后面有类型说明，a参数也是该类型。

func subFn(a, b int) int {return a - b
}

3.4可变参数 

可变参数是指函数的参数数量是不固定，go语言中的可变参数通过在参数后面加...来标识的。

注意：可变参数通常要作为函数的最后一个参数。可变参数是一个切片。

func changFn(a int, x ...int) int {fmt.Printf("%v--%T\n", x, x)var sum = afor _, v := range x {sum += v}return sum
}

调用

func main() {changSum := changFn(1, 2, 3, 4, 5, 6)fmt.Println(changSum)
}

结果：

[2 3 4 5 6]--[]int
21

3.5函数返回值 

go语言中通过return关键字向外输出返回值。上面代码已经体验函数单个返回值的用法了。

go语言中的函数还支持多返回值，函数如果有多个返回值时必须用（）将所有的返回值包裹起来。

func moreFn(a, b int) (int, int) {sum := a + bsub := a - breturn sum, sub
}
func main() {	 msum, msub := moreFn(20, 13)fmt.Println(msum, msub)
}

 还支持返回值命名，函数定义时可以给返回值命名，并在函数体中直接使用这些变量，最后通过return关键字返回。例如：

func moreFn2(a, b int) (sum, sub int) {sum = a + bsub = a - breturn
}
func main() {msum, msub := moreFn2(20, 17)fmt.Println(msum, msub)
}

4.函数变量作用域 

全局变量：全局变量是定义在函数外部的变量，它在程序整个运行周期内都有效。全局作用域。

局部变量：局部变量是在函数内部定义的变量，函数内定义的变量无法在函数外部使用。局部变量。

注意：如果全局变量和局部变量重名了，优先访问局部变量。

var a = "全局变量"func run() {var b="局部变量"fmt.Println("run--a=", a)fmt.Println("run--b=",b)}
func main() {run()fmt.Println("main--a=", a)//i是局部变量，只能在for内部使用for i := 0; i < 10; i++ {fmt.Println(i)}
}

5.练习

5.1封装整数类型的切片排序方法

要求：选择排序，从小到大。

func sortIntAsc(slice []int) []int {for i := 0; i < len(slice); i++ {for j := i + 1; j < len(slice); j++ {if slice[i] > slice[j] {slice[i], slice[j] = slice[j], slice[i]}}}return slice
}
func main() {sliceA := []int{23, 1, 5, 67, 13, 22}fmt.Println(sortIntAsc(sliceA))fmt.Println(sliceA)
}

结果：因为切片是引用类型的数据，所以两次结果是一致的。

[1 5 13 22 23 67]
[1 5 13 22 23 67]

5.2要求把map按照key的顺序进行打印

例如：

var m1 map[string]string
m1 = make(map[string]string)
m1["username"] = "张三"
m1["age"] = "18"
m1["height"] = "1.8"
m1["sex"] = "男"

打印结果：age=>18height=>1.8sex=>男username=>张三

func sortMap(m map[string]string) string {var slice []stringfor key, _ := range m {slice = append(slice, key)}sort.Strings(slice)var str stringfor _, s := range slice {str += fmt.Sprintf("%v=>%v", s, m[s])}return str
}
func main() {var m1 map[string]stringm1 = make(map[string]string)m1["username"] = "张三"m1["age"] = "18"m1["height"] = "1.8"m1["sex"] = "男"str := sortMap(m1)fmt.Println(str)
}

6.函数类型与变量

定义函数类型：我们可以使用type关键字来定义一个函数类型，具体格式如下

type 类型名称 func(参数类型，参数类型。。。) 返回值类型

例如

type  calculation func(int,int) int

上面语句定义了一个calculation类型，它是一种函数类型，这种函数类型接受两个int类型的参数并且返回一个int类型的返回值。

package mainimport "fmt"// 定义函数类型
type calculation func(int, int) intfunc add(a, b int) int {return a + b
}
func sub(a, b int) int {return a - b
}
func main() {var c calculationc = addfmt.Printf("%T\n", c)fmt.Println(c(2, 4))f := subfmt.Printf("%T\n", f)fmt.Println(f(10, 2))
}

结果：

main.calculation
6
func(int, int) int
8

 由上面结果可知，add和sub函数都满足接收两个int类型的参数并且都返回一个int类型的值，所以可以把赋值给calculation类型的变量。

7.把函数作为参数

package mainimport "fmt"// 定义函数类型
type calculation func(int, int) intfunc add(a, b int) int {return a + b
}
func sub(a, b int) int {return a - b
}
func fn1(a, b int, do calculation) int {return do(a, b)
}
func fn2(a, b int, do func(int, int) int) int {return do(a, b)
}
func main() {fmt.Println(fn1(1, 2, add))fmt.Println(fn2(12, 2, sub))
}

结果：

3
10

8.把函数当作返回值

package mainimport "fmt"// 定义函数类型
type calculation func(int, int) intfunc add(a, b int) int {return a + b
}
func sub(a, b int) int {return a - b
}
func cal(s string) calculation {switch s {case "+":return addcase "-":return subcase "*":return func(i int, i2 int) int {return i * i2}default:return nil}
}
func main() {sum := cal("+")fmt.Println(sum(1, 2))fmt.Println(cal("-")(12, 10))fmt.Println(cal("*")(3, 10))
}

结果：

3
2
30

9.匿名函数

函数当然还可以作为返回值，但是在Go语言中函数内部不能再像之前那样定义函数了，只 能定义匿名函数。匿名函数就是没有函数名的函数，匿名函数的定义格式如下：

func(参数)(返回值){ 函数体 }

匿名函数因为没有函数名，所以没办法像普通函数那样调用，所以匿名函数需要保存到某个 变量或者作为立即执行函数:

package mainimport "fmt"func main() {func() {fmt.Println("hello word")}()//将匿名函数保存到变量add := func(x, y int) {fmt.Println(x + y)}add(10, 20) //通过变量调用匿名函数//自执行函数：匿名函数定义完加()直接执行func(x, y int) {fmt.Println(x + y)}(10, 20)}

结果：

hello word
30
30

10.闭包

闭包可以理解成“定义在一个函数内部的函数“。在本质上，闭包是将函数内部和函数外部 连接起来的桥梁。或者说是函数和其引用环境的组合体。首先我们来看一个例子：

package mainimport "fmt"func adder() func(int) int {var x intreturn func(y int) int {x += yreturn x}
}
func main() {var f = adder()fmt.Println(f(10)) //10fmt.Println(f(20)) //30fmt.Println(f(30)) //60f1 := adder()fmt.Println(f1(40)) //40fmt.Println(f1(50)) //90
}

结果：

10
30
60
40
90

由结果可知：变量f是一个函数并且它引用了其外部作用域中的x变量，此时f就是一个闭包。在f的生 命周期内，变量x也一直有效。