Golang入门笔记（7）—— 函数 func

       函数是什么？ 函数：为完成某一功能的程序的语句指令的集合。

   

        为什么要使用函数？ 为了提高代码的复用，减少代码的冗余，提高代码维护性——避免每次都编码一段类似代码。

        基本语法：

func functionName(形参列表...)(返回值的类型列表){
    执行语句...
    return + 返回值列表
}

         其中，如果返回值类型是一个，可省略第二个小括弧，代码如下：

package main
 
import "fmt"
 
func main() {
	sum := calculate(10, 20) //实参。
	fmt.Println(sum)
}
 
func calculate(num1 int, num2 int) int { //形参
	sum := 0
	sum += num1
	sum += num2
	return sum
}

        注意事项：       

•          函数名：

1.遵循标识符命名规范——驼峰命名法，要能见名知意。

2.首字符不能是数字。

3.如果首字母大写该函数可以被本包文件和其他包文件使用；如果首字母小写只能被本包文件使用，其他包不能使用。

4. Go语言中，函数不支持重载。所以同一block中，函数名不可重复声明，否则会 报 redecleared in this block 的错误。

•         形参列表：

1. 用于接收外部传入的参数，其参数的个数，可以0个，也可以是n个。

2.支持可变参数，即函数参数的数量可根据实际情况弹性伸缩 。（ps 后面等熟悉了函数后，末尾会专门介绍）

•         返回值列表：

返回值类型列表：

        1.可以返回0个数据类型，可以返回n个数据类型。

返回0个数据类型

func main() {
	calculate(10, 20)
}
 
//函数定义中无返回值类型列表
func calculate(num1 int, num2 int)  {
	sum := 0
	sum += num1
	sum += num2
	fmt.Println(sum)
}

返回n个数据类型

package main
 
func main() {
    //需要2个变量接受此函数返回的多个类型的数据
	r1, r2 := calculate(10, 20)
	println(r1, r2)
}
 
//返回多个数据类型的函数
func calculate(num1 int, num2 int) (int, int) {
	sum := 0
	sum += num1
	sum += num2
 
	var result int = num1 - num2
	return sum, result
}

        2. 对于不关注的返回，可以使用_忽略。比如：

//可以用 下划线 ，忽略不关注的返回值。
	r1, _ := calculate(10, 20)
	println(r1)

函数执行内存分析：

        先看一段代码：思考执行结果为什么会这样？

package main
 
import "fmt"
 
func main() {
	num1 := 10
	num2 := 20
	exchange(num1, num2)
	fmt.Printf("num1 = %v , num2 = %v", num1, num2) //num1 = 10,num2 = 20
}
 
func exchange(num1 int, num2 int) {
	var t int
	t = num1
	num1 = num2
	num2 = t
}

        知识预热：

        栈区：用来存储程序执行过程中函数内部定义的信息和局部变量值。 最内层函数后进先出，最内层函数先执行后，释放内存，向上层传递结果。 函数return返回值将函数执行的结果保存下来，返回给调用者。

        上面这个函数，在内存中的函数执行过程，如下图所示：

                   以上函数的内存活动的主要发生在逻辑栈上，根据如上图的内存分析就可得出问题所在。

可变参数案例：

        相信在这里，大家已经大致了解了函数了，这里 详细看一下 可变参数的案例。

package main
 
func main() {
	res := calculate("*", 1, 2, 3, 4)
	println(res)
}
 
func calculate(op string, num ...int) int {
	res := 1
	if "*" == op {
		for i := 0; i < len(num); i++ {
			res *= num[i]
		}
	}
	return res
}

       注意：可变参数，要是必须是最后一个参数，这是一个通用的语言语法规范，js-ecmascript6版本 和 java 也都是如此。

•         函数的参数的传递方式：

        基本数据类型和数组默认都是值传递，即进行值得拷贝，在函数内修改，不会影响到原来的值。

package main
 
import "fmt"
 
func main() {
	num := 1
	changeValue(num)
	println(num)
}
 
func changeValue(num int) {
	num = 1000
	fmt.Println(" changeValuetest num  --> ", num)
}

       此种情况为什么会出现这样的结果，大概的原理和上面的内存分析模型几乎差不多的。       

         对于以值传递方式的数据类型，如果希望在函数内的变量能修改函数外的变量，可以传入变量的地址&，函数内以指针的方式操作变量。从效果上看类似 引用传递。

package main
 
import "fmt"
 
func main() {
	num := 1
	println("num地址", &num)
	changeValue(&num) //调用函数的时候，传入num的地址。
	println(num)
}
 
func changeValue(num *int) { // 定义了一个int类型的指针
	//用*访问到这个地址的内存。
	*num = 1000
	fmt.Println(" changeValuetest num  --> ", num)
}

        Go语言中的指针操作非常简单，只需要记住两个符号：&（取地址）和*（根据地址取值）。每个变量在运行时都拥有一个地址，这个地址代表变量在内存中的位置。区别于C/C++中的指针，Go语言中的指针不能进行 偏移和运算，是安全指针。指针类型的空值是 nil -----> 引用类型的空值都是nil类型。

	var x int = 10
	var ptr *int = &x
	*ptr = 21
	println(x)

        关于更多指针的知识，详见：Golang指针解释，一劳永逸_哔哩哔哩_bilibili

以上代码的内存分析图：

Go函数也是一种数据类型
        这点和javascript一样，可以赋值给一个变量，则该变量就是一个函数类型的变量，通过该变量可以调用该函数。正式由于函数是一个数据类型的特性，在Go的世界中，函数可以作为形参传递并且调用。这不禁让我想到Javascript 的cb()函数的使用，以及 java 通过抽象一个接口，做一个匿名内部类等方式有得一拼。

package main
 
import "fmt"
 
func main() {
 
	a := say
	fmt.Printf("a 得类型是 %T,say 函数得类型是 %T \n", a, say)
 
	a("your")
	say("my")
}
 
func say(whose string) {
	println("this is " + whose + "callback, just test this feature. ")
}
 

        根据这种特性，编写回调函数。

package main
 
func main() {
 
	a := calculate
	var res int = test(a, 1, 2, 3, 4, 5)
	println(res)
}
 
func calculate(op string, num ...int) int {
	res := 1
	if "*" == op {
		for i := 0; i < len(num); i++ {
			res *= num[i]
		}
	}
	return res
}
 
func test(cb func(string, ...int) int, nums ...int) int {
	return cb("*", nums...) // 根据javascript 的 rest 的语法，瞎试的竟然也成了。
}

        编写以上代码的心得体会：

* func 函数当参数传递的时候，细节点，要传入定义好的参数类型和返回值类型。 

* 当遇到可变参数的时候，如这里的 num...  ， 可变参数的代表变量要和三个点 在一起打包传递，这样来声明这个是一组可变的参数值。

自定义数据类型（给数据类型别名）：

package main
 
import "fmt"
 
func main() {
	//自定义数据类型，给类型起了别名。
	type myInt int
	var num1 myInt = 30
	fmt.Println("num1", num1)
	var a int = 20
	//a = num1 // cannot use num1 (variable of type myInt) as type int in assignment
	a = int(num1) // 别名通过 int() 进行强转为原来的类型。
	println(a)
}

自定义函数类型

// 优化前
func test(cb func(string, ...int) int, nums ...int) int {
	return cb("*", nums...) // 根据javascript 的 rest 的语法，瞎试的竟然也成了。
}
 
 
 
//优化后，使用 自定义的函数类型，使得代码更加简洁
type operateFunction func(string, ...int) int
 
func test(cb operateFunction, nums ...int) int {
	return cb("*", nums...) // 根据javascript 的 rest 的语法，瞎试的竟然也成了。
}

支持函数返回值的命名操作：

package main
 
func main() {
 
}
 
// 返回值的列表顺序必须要和返回值的类型，一一对于，不可弄乱。
func test01(num1 int, num2 int) (int, int) {
	sum := num1 + num2
	sub := num1 - num2
	return sum, sub
}
 
// 通过返回列表声明的变量 字符 ，可以进行映射。可以不用管顺序，减少编码错误。
func test02(num1 int, num2 int) (sub int, sum int) {
	sum = num1 + num2
	sub = num1 - num2
	return
}

        细节好多，多多练习。