一、总体内容
1、内置函数、递归函数、闭包
2、数组和切片
3、map数据结构
4、package介绍
一、内置函数
注意：值类型用new来分配内存，引用类型用make来分配内存
1、close：主要用来关闭channel
2、len：用来求长度，比如string、array、slice、map、channel
3、new：用来分配内存，主要用来分配值类型，比如int、struct、浮点型。返回的是指针
代码案例
package main
import(
"fmt"
)
func main(){
var i int
fmt.Println(i) //0
j:=new(int) //返回的是地址，也就是指针
*j=100 //因为是指针，所以要这样赋值
fmt.Println(*j) //100
}
4、make：用来分配内存，主要用来分配引用类型。比如chan、map、slice
5、append：用来追加元素到数组、slice中
package main
import(
"fmt"
)
func main(){
var a [] int
a=append(a,10,20,30)
fmt.Println(a) //[10 20 30]
}
合并两个slice
package main
import(
"fmt"
)
func main(){
var a [] int
a=append(a,10,20,30)
a=append(a, a...) //后面的三个点，是展开，这个append是合并
fmt.Println(a)
}
注意这里的三个点的作用是展开
6、panic和recover：用来做错误处理
panic可以快速定位到哪里出错了
捕获异常的原因是因为上线项目之后不能够随便的停止，所以要捕获
package main
import(
"fmt"
"time"
)
func test(){
defer func(){
if err:=recover();err !=nil{ //这里捕获下面的系统的异常
fmt.Println(err) //这里的错误没有指定哪一行出错了。这里可以把堆栈打印出来
//捕获了异常之后下面可以继续写上报警的接口或者写到日志里面
}
}()
b:=0
a:=100/b //这里系统抛了一个异常，上面来捕获
fmt.Println(a)
return
}
func main(){
for {
test()
time.Sleep(time.Second) //这里是休息1秒，参数是一个常量
}
var a [] int
a=append(a,10,20,30)
a=append(a, a...)
fmt.Println(a) //[10 20 30]
}
D:\project>go build go_dev/day4/example/example2
D:\project>example2.exe
runtime error: integer divide by zero
runtime error: integer divide by zero。
还可以自己手动的通过pinic来捕获异常
package main
import(
"fmt"
"errors"
)
func initConfig()(err error){ //这里是命名返回值
return errors.New("init config failed") //初始化error这个实例
}
func test(){
err :=initConfig()
if err !=nil{
panic(err) //panic手动的捕获这个异常，这样就能知道程序的哪里出错了
}
return
}
func main(){
test()
var a [] int
a=append(a,10,20,30)
a=append(a, a...)
fmt.Println(a) //[10 20 30]
}
D:\project>go build go_dev/day4/example/example2
D:\project>example2.exe
panic: init config failed
goroutine 1 [running]:
main.test()
D:/project/src/go_dev/day4/example/example2/main.go:17 +0xb2
main.main()
D:/project/src/go_dev/day4/example/example2/main.go:24 +0x3b
数组：
var a [1]int :这个是确定的长度，为1
var a [] int :这个是切片
new和make的区别
new之后如果是slice等引用类型必须要用make初始化一下才可以用如下：
package main
import(
"fmt"
)
func test(){
s1:=new([] int) //new了这个指针，必须要用make来初始化一下
fmt.Println(s1) //这个返回来一个指针&[]
s2:=make([] int, 2) //这个后面的2是指定容量
fmt.Println(s2) //这个返回来这个数据类型 [0 0 ]
*s1=make([] int,5) //因为s1是一个指针（地址），要想用这个指针必须初始化一下
(*s1)[0]=100 //初始化之后给这个值赋值
fmt.Println(s1) //&[100 0 0 0 0]
s2[0]=100
fmt.Println(s2) //[100 0]
}
func main(){
test()
}
递归函数
一个函数调用自己，就叫做递归
package main
package main
import (
"fmt"
"time"
)
func recusive(n int){
fmt.Println("hello")
time.Sleep(time.Second)
if n>10{ //这个是递归退出的条件
return
}
recusive(n+1) //这个就是递归的自己调用自己
}
func main(){
recusive(0)
}
例子一：计算阶乘
package main import ( "fmt" ) func factor(n int) int { if n==1{ return 1 } return factor(n-1)*n } func main(){ a:=factor(5) fmt.Println(a) } D:\project>go build go_dev/day4/example/example5 D:\project>example5.exe 120