golang学习笔记--函数

func main()  {
	var a int = 1
	var b int = 2
	c := add(a, b)
	fmt.Println(c)
	}
func add(a int,b int) (int) {
	return a+b
}

函数调用机制

值传递

package main
import "fmt"
func test(n int)  {
	n += 1
	fmt.Println("test-n = ",n)
}
func main() {
	n := 10 //根据赋值推断类型
	test(n)
	fmt.Println("main-n = ",n)
}

返回值

package main
import "fmt"
func test(n int) (int){
	n += 100
	return n
}
func main() {
	n := 99
	n = test(n)
	fmt.Println("main-n = ",n)
}

多返回值

package main
import "fmt"
func test(n1 int,n2 int) (int,int){
	sum := n1+n2
	sub := n1-n2
	return sub,sum
}
func main() {
	n1 := 99
	n2 := 100
	sum, sub := test(n1, n2)
	//可以用占位符 _ 来忽略某个返回值
	sum1, _ := test(n1, n2)
	fmt.Println("sum=",sum,"\nsub=",sub)
	fmt.Println("sum1=",sum1)
}

递归调用

函数注意事项和细节

package main
import ("fmt")
func up(args...int) (sum int){
	for i:=0;i< len(args);i++{
		sum+=args[i]
	}
	return
}
func main() {
	sum := up(1, 2, 3)
	fmt.Println(sum)
}

init函数

匿名函数

package main
import "fmt"
var (
	//定义全局变量,这里就是全局匿名函数
	f = func(m int,n int) int{
		return m-n
	}
)
func main() {
	//定义匿名函数的同时调用
	a := func(m int,n int) int {
		return m+n
	}(12,24)
	fmt.Println(a)
	//定义匿名函数,赋给变量
	b := func(m int,n int) int {
		return m+n
	}
	fmt.Println(b(1,2))
	//调用全局匿名函数
	c := f(10,5)
	fmt.Println(c)
}

闭包

package main
import "fmt"
func m() func(x int) int {
	//形成闭包
	n := 10
	return func(x int) int {
		n += x
		return n
	}
}
func main() {
	f := m()
	fmt.Println(f(2))
	fmt.Println(f(2))
	fmt.Println(f(2))
}

函数参数传递

---

Go的语法接近C语言，但对于变量的声明有所不同。Go支持垃圾回收功能。Go的并行模型是以东尼·霍尔的通信顺序进程（CSP）为基础，采取类似模型的其他语言包括Occam和Limbo，但它也具有Pi运算的特征，比如通道传输。在1.8版本中开放插件（Plugin）的支持，这意味着现在能从Go中动态加载部分函数。

与C++相比，Go并不包括如枚举、异常处理、继承、泛型、断言、虚函数等功能，但增加了 切片(Slice) 型、并发、管道、垃圾回收、接口（Interface）等特性的语言级支持。Go 2.0版本将支持泛型，对于断言的存在，则持负面态度，同时也为自己不提供类型继承来辩护。

不同于Java，Go内嵌了关联数组（也称为哈希表（Hashes）或字典（Dictionaries）），就像字符串类型一样。