go参数、返回值、变量声明

1.声明函数

（1）常规函数  
func xxx{}
（2）函数里定义匿名函数
func (int a) bool{
	fmt.Printf(" a is %d\n", a)
	return a<3
}
匿名函数的使用

	func test(f func(int)int){
		var a =3
		s:=f(a)
	}
	
	func main(){
		func() {
	    	fmt.Printf("func 1\n")
		}()	
		func(x int) {
	    	fmt.Printf("func 2, x is %d\n", x)
		}(2)
		a := func(x int) int {
		    fmt.Printf("func 3, x is %d\n", x)
		    return 5
	    }
	    a(2)   
	    test(a)
}

（3）函数闭包
闭包主要事项
1.作用域（局部变量与全局变量）
2.闭包的用途 1可以读取函数内部的变量。2让这些变量的值始终保持在内存中
3实例：

package main

import "fmt"

func getSequence() func() int {
 	i:=0
	return func() int {
 		 i+=1
 		return i  
	}
}

func main(){
 /* nextNumber 为一个函数，函数 i 为 0 */
	nextNumber := getSequence()  

 	/* 调用 nextNumber 函数，i 变量自增 1 并返回 */
	fmt.Println(nextNumber())
	fmt.Println(nextNumber())
	fmt.Println(nextNumber())
   
 	/* 创建新的函数 nextNumber1，并查看结果 */
  	nextNumber1 := getSequence()  
 	fmt.Println(nextNumber1())
 	fmt.Println(nextNumber1())
}

**2.参数定义

func xxx(tmp string){}

3.返回值

func xxx(tmp string)(error){}

返回值接收
_:=xxx(“sss”)
err:=xxx(“sss”)
_ 代表忽略返回值

4.变量声明

func xxx(tmp string)(error){
var str string //第一种

// := 是声明并赋值，并且系统自动推断类型，不需要var关键字
d := 100
}

5.重复声明变量

使用简短方式声明变量，左侧必须要有一个新变量，变量也可以重复声明，并且重复声明的变量必须数据类型相同
sss:=“333”
sss,ssss:=“444”,“5555” //正确的
sss,ssss:=22,“5555” //错误的 类型不对

6.匿名变量

func GetName() (Name1, Name2, Name3 string) {
return “1”, “2”, “3”
}
_, _, Name3 := GetName()

7.常量定义

const mask = 1 << 3
const u=3

8.预定义常量iota

const ( // iota被重设为0
c0 = iota // c0 == 0
c1 = iota // c1 == 1
c2 = iota // c2 == 2
)
const ( // iota被重设为0
c0 = iota // c0 == 0
c1 // c1 == 1
c2 // c2 == 2
)
在每一个const关键字出现时被重置为0，然后在下一个const出现之前，每出现一次iota，其所代表的数字会自动增1

8.复数math/cmplx标准库

对于一个复数z = complex(x, y)，就可以通过Go语言内置函数real(z)获得该复数的实
部，也就是x，通过imag(z)获得该复数的虚部，也就是y

9.字符串遍历

Go语言提供了一个关键字range，用于便捷地遍历容器中的元素
（1）.以字节数组的方式遍历
str := “Hello,世界”
n := len(str)
for i := 0; i < n; i++ {
ch := str[i] // 依据下标取字符串中的字符，类型为byte
fmt.Println(i, ch)
}
（2）是以Unicode字符遍历
str := “Hello,世界”
for i,ch:=range str{
fmt.Println(i, ch)//ch的类型为rune
}

10.数组

[3][5]int
(1)数组切片slice
go支持myArray[first:last]这这样的方式来基于数组生成一个数组切片
// 先定义一个数组
var myArray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
// 基于数组创建一个数组切片
var mySlice []int = myArray[:5]
mySlice 值为1 2 3 4 5
(2)创建数组切片
创建一个初始元素个数为5的数组切片，元素初始值为0：
mySlice1 := make([]int, 5)
创建一个初始元素个数为5的数组切片，元素初始值为0，并预留10个元素的存储空间：
mySlice2 := make([]int, 5, 10)
直接创建并初始化包含5个元素的数组切片：
mySlice3 := []int{1, 2, 3, 4, 5}
（3）数组切片重要方法
cap()函数返回的是数组切片分配的空间大小

len()函数返回的是数组切片中当前所存储的元素个数

用append()函数从尾端给mySlice加上3个元素，从而生成一个新的数组切片
mySlice = append(mySlice, 8, 9, 10)
给mySlice后面添加另一个数组切片
mySlice2 := []int{8, 9, 10}
mySlice = append(mySlice, mySlice2…)

切片复制 copy(dest,src)
slice1 := []int{1, 2, 3, 4, 5}
slice2 := []int{5, 4, 3}
copy(slice2, slice1) // 只会复制slice1的前3个元素到slice2中
copy(slice1, slice2) // 只会复制slice2的3个元素到slice1的前3个位置

10.map键值对的未排序集合

type PersonInfo struct {
ID string
Name string
Address string
}

1. 变量声明
   var myMap map[string] PersonInfo
   myMap = make(map[string] PersonInfo, 100)
   2.元素删除
   delete()函数删除map内的元素
   delete(map,key)
   3.元素查找
   value,ok:=myMap[“1111”]
   if ok{
   }

11.关键字注意事项

（1）defer（遵照先进后出的原则）

		defer func() { 
 // 做你复杂的清理工作
} ()

（2）panic()与recover()函数
panic() 会触发 defer
recover() 会捕获panic() 传的错误信息
当捕获的参数不为nil时会执行对应数据

	package main
	func main(){
		fmt.Println("1")
		defer func(){
			fmt.Println("3")
			if err:=recover();err!=nil{
				fmt.Print(err)
			}
			fmt.Println("4")
		}
		f()
	}
	func f(){
		fmt.Println("2")
		panic("panic")
		fmt.Println("5")
		fmt.Println("6")
	}

打印为：123panic4