一、总体内容
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
斐波那契数列
package main import( "fmt" ) func fabnaqi(n int) int{ if n<=1 { return 1 } return fabnaqi(n-1)+fabnaqi(n-2) } func main(){ for i:=1;i<10;i++{ fmt.Println(fabnaqi(i)) } } D:project>go build go_dev/day4/example/example6 D:project>example6.exe 1 2 3 5 8 13 21 34 55
闭包：
闭包：是一个函数和与其相关作用域的结合体
下面的匿名函数中的变量和x绑定了
package main import ( "fmt" ) //闭包 func Adder() func(int)int{ //这里定义的返回值要和下面的匿名函数一样 //下面的整体才是闭包 var x int //默认为0 return func(d int) int{ //这里匿名函数要和上面返回值类型是一样 x+=d return x } } func main(){ f:=Adder() fmt.Println(f(1)) //这里的f就是执行Adder()，然后f(1),这个就是执行匿名函数，并且传入参数 fmt.Println(f(100)) //101 fmt.Println(f(1000)) //1101 }
例2
package main import ( "fmt" "strings" ) func makeSuffixFunc(suffix string) func (string )string{ return func (name string) string{ //这里的闭包的环境变量是和suffix绑定的 if strings.HasPrefix(name,suffix)==false{ return name+suffix } return name } } func main(){ func1:=makeSuffixFunc(".bmp") func2:=makeSuffixFunc(".jpg") fmt.Println(func1("test")) fmt.Println(func2("test")) }
数组
1、数组：是同一种数据类型的固定长度的序列
2、数组定义：var a [len]int 比如：var a [5] int 一旦定义长度就不会变了
3、长度是数组类型的一部分，因此var a[5]int和var a[10]int 是不同的类型
4、数组可以通过下标进行访问，下标是从零开始的，最后一个元素下标是len-1
遍历的方法如下:
下面是遍历数组的两种方法
package main import ( "fmt" ) func main(){ var a[10] int a[0]=100 for i:=0;i<len(a);i++{ fmt.Println(a[i]) } for _,value:=range a{ fmt.Println(value) } }
5、访问越界，如果下标在数组合法范围之外，则触发越界，会panic
如下，就会在编译的时候报错，也就是pinic了
package main import ( "fmt" ) func main(){ var a[10] int j:=10 a[0]=100 a[j]=200 fmt.Println(a) }
6、数组是值类型，因此改变副本的值，不会改变本身的值
在函数里面改变不会改变外部的值，在函数中改变的知识数组的副本
如果要改变函数中的值，需要通过指针的方式来修改
package main import( "fmt" ) func test(arr *[5] int){ (*arr)[0]=1000 } func main(){ var a [5] int test(&a) fmt.Println(a) // [1000 0 0 0 0] }
数组和切片：
1、练习，使用非递归的方式实现斐波那契数列，打印前100个数
package main
import (
"fmt"
)
func fab(n int){
var a[]uint64
a=make([]uint64 ,n)
a[0]=1
a[1]=1
for i:=2;i<n;i++{
a[i]=a[i-1]+a[i-2]
}
for _,v:=range a{
fmt.Println(v)
}
}
func main(){
fab(10)
}
2、数组初始化
a、var age0 [5]int =[5]int {1,2,3,4,5]
b、var age1=[5] int {1,2,3,4,5]
c、var age2=[…]int {1,2,3,4,5}
d、var str=[5]string{3:”hello word”,4:”tom”}
3、多维数组
a、var age[5][3] int //5行 3 列，第一个行，第二个列
b、var f[2][3] int=[…][3]int {{1,2,3},{7,8,9}}
遍历多维数组
package main import ( "fmt" ) func testArry(){ var a[2][5]int=[...][5]int{{1,2,3,4,5},{6,7,8,9,10}} //前面是行，后面是列 for row,v:=range a{ //首先便利梅行 for col,v1:=range v{ //然后遍历每列 fmt.Printf("(%d,%d)=%d ",row,col,v1) //这里的v1是多维数组的遍历对象 } fmt.Println() } } func main(){ testArry() }
注意这里的切片和数组的区别：
a、声明的时候切片没有长度，数组有长度在中括号中，因为切片是变长的，数组的是长度固定的，切片是引用类型，数组是值类型
1、切片：切片是数组的一个引用，因此切片是引用类型
2、切片的长度可以改变，因此切片是一个可变的数组
3、切片遍历方式和数组一样，可以用len()求长度
4、cap可以求出slice最大的容量，0<= len (slice)<=cap (array)，其中array是slice引用的数组
5、切片的定义：var变量名[]切片类型，比如var str []string var arr[] int
package main
import "fmt"
func testSlice(){
var slice [] int
var arr[5]int=[...]int{1,2,3,4,5}
slice=arr[2:5] //数组的切片
fmt.Println(slice)
fmt.Println(len(slice)) //求切片的长度
fmt.Println(cap(slice)) //求切片的容量
slice =slice[0:1] //这个切片引用了另一个切片
fmt.Println(len(slice)) //求新切片的长度
fmt.Println(cap(slice)) //这个还是原来切片的长度
}
func main(){
testSlice()
}
D:project>go build go_dev/day4/example/slicea
D:project>slicea.exe
[3 4 5]
3
3
1
3
方法: 切片初始化只能通过切片的方式
1、切片初始化：var slice [] int=arr[start”end].包含start到end之间的元素名不包含end
2、var slice []int=arr[0:end]可以简写为var slice []int=arr[:end]
3、var slice []int=arr[start:len(arr)] 可以简写为var slice[]int = arr[start:]
4、var slice []int=arr[0,len(arr)] 可以简写为var slice[]int=arr[:]
5、如果要切片最后一个元素去掉，可以这样写
slice=slice[:len(slice)-1]
数组和切片定义之后必须要初始化
下面是切片的内存布局 第一个是x的切片布局指针方式指针数组，
上面的第三个切片的地址指向的是数组的第一个元素的地址，如下：
func testslice1(){ var a=[10]int{1,2,3,4,5} b:=a[1:5] //这是一个切片 fmt.Printf("%p ",b) //打印地址0xc042084008 fmt.Println(&a[2]) //打印地址0xc042084008 } func main(){ testslice1() } 从上面地址可以看到切片地址和第一个元素的地址相同
3、通过make来创建切片
4、用append内置函数操作切片
slice=append(slice,10)
var a=[]int{1,2,3}
var b=[]int{4,5,6}
a=append(a,b…) //这里注意，如果是一个切片的话，append需要后面是…
切片是引用，如果切片的append的大小超过了原来的数组的大小，这个时候就会扩容，可以通过切片和数组的第一个值的地址是否相同来比较
package main import ( "fmt" ) func test(){ var a [2]int=[...]int{1,2} s:=a[1:] fmt.Println(s,&a[1]) s=append(s,10) s=append(s,11) fmt.Printf("%p ",s) //0xc04200e2a0 fmt.Println(s,&a[1]) //0xc0420080d8 } func main(){ test() }
上面切片的地址和数组的第一个元素的地址不同可以看到，这个切片进行了扩容的方式，新开了一块内存和原来的内存不一样了，这个是内部的算法决定的
5、切片遍历
for index,val :range slice{
}
6、切片resize，切片之后可以再进行切片
var a=[] int{1,2,3}
b:=a[1:2]
b=b[0:3]
7、切片的拷贝
s1:=[]int{1,2,3,4}
s2:=make([]int ,10)
copy(s2,s1)
s3:=[]int{1,2,3}
s3=append(s3,s2…)
s3=append(s3,4,5,6)
8、stringhe slice
string底层就是一个byte的数组，因此，也可以进行切片操作
package main import ( "fmt" ) func test(){ s:="hello world" s1:=s[0:5] fmt.Println(s1) //hello } func main(){ test() }
10、如何改变string中的字符串？
string本身是不可变的，因此要改变string中字符，需要如下操作
下面是针对没有中文的情况下：
func test2(){ str:="hello world" s:=[]byte(str) s[0]='o' str=string(s) fmt.Println(str) // oello world } func main(){ test2() } 下面是可以针对中文的情况 func testModify(){ str:="oello world" s:=[]rune(str) s[0]='h' str=string(s) fmt.Println(str) //hello world } func main(){ testModify() }
11、排序和查找操作
排序操作主要在sort包中，导入就可以使用了
import(“sort”)
sort.Ints对整数进行排序，sort.String对字符串进行排序，sort.Float64s对浮点数进行排序
sort.SearchInts(a []int,b int)从数组a中查找b，前提是a必须有序
sort.SearchFloats(a []float64 ,b float64)从数组a中查找b，前提是a必须有序
sort.SearchStrings(a []string,bstring)从数组a中查找b，请安提是a必须有序
下面是对数组进行排序
package main import( "fmt" "sort" ) func test(){ var a=[...]int{1,3,2,21,11,14} //因为这个是数组，所以不能直接排序 sort.Ints(a[:]) //所以这里要针对切片进行排序，因为切片实际引用类型 fmt.Println(a) } func main(){ test() } /* D:project>go build go_dev/day4/example/example15 D:project>example15 [1 2 3 11 14 21] */ 下面是对字符串进行排序 func testString(){ var a=[...]string{"abc","efg","b","A","eee"} sort.Strings(a[:]) fmt.Println(a) //[A abc b eee efg] } func main(){ testString() } 下面是对浮点型进行排序 func testFloat(){ var a=[...]float64{1.1,9.7,2.1} sort.Float64s(a[:]) fmt.Println(a) //[1.1 2.1 9.7] } func main(){ testFloat() } 下面是排序的方法 func testIntsearch(){ var a=[...]int{1,8,38,2,348,4} sort.Ints(a[:]) index:=sort.SearchInts(a[:],2) fmt.Println(index) //得到下标为1 } func main(){ testIntsearch() }
map数据结构
一、简介
key-value的数据结构
a、声明，声明是不会分配内存的，初始化需要make
var map1 map[key type]value type
var a map[string]string
var a map[string]int
var a map[int]string
var a map[string]map[string]string
package main import ( "fmt" ) func test(){ var a map[string]string //声明map，但是这里没有申请内存空间，所以必须初始化 a=make(map[string]string,10) //这里初始化，申请内存空间 a["abc"]="efg" fmt.Println(a) //map[abc:efg] } func main(){ test() } 方式二 package main import ( "fmt" ) func test(){ a:=make(map[string]string,10) //这里声明加上初始化，声明然后分配内存空间 a["abc"]="efg" fmt.Println(a) //map[abc:efg] } func main(){ test() } 方法三：不推荐 package main import ( "fmt" ) func test(){ var a map[string]string=map[string]string{ "key":"value", } //var a map[string]string //声明map，但是这里没有申请内存空间，所以必须初始化 //a:=make(map[string]string,10) //这里初始化，申请内存空间 a["abc"]="efg" fmt.Println(a) //map[abc:efg] } func main(){ test() } 多层map嵌套 func testMap2(){ a:=make(map[string]map[string]string,100) //声明 a["key1"]=make(map[string]string) //初始化 a["key1"]["key2"]="abc" a["key1"]["key3"]="abc" fmt.Println(a) } func main(){ testMap2() test() }
map相关的操作
a[“hello”]=”world” 插入和更新
val,ok:=a[“hello”] 查找
for k,v:=range a { 遍历
}
delete (a,”hello”) 删除
len(a) 长度
func test3() { var a map[string]string = map[string]string{"hello": "world"} a = make(map[string]string, 10) a["hello"] = "world" //插入和更新 val,ok:=a["hello"] //查找 if ok{ fmt.Println(val) } for k,v :=range a { //遍历 fmt.Println(k,v) } } func main(){ test3() }
排序：
map排序，map的排序是无序的：
a、先获取所有key，把key进行排序
b、按照排好的key，进行遍历
package main import( "fmt" "sort" ) func test(){ var a map[int]int //声明 a=make(map[int]int,5) //初始化，加入内存 a[8]=10 a[3]=11 a[2]=10 a[1]=10 a[18]=10 var keys []int //创建一个切片 for k,_:=range a{ keys=append(keys,k) } sort.Ints(keys) for _,v:=range keys{ fmt.Println(v,a[v]) } } func main(){ test() } //D:project>go build go_dev/day4/example/example17 // //D:project>example17.exe //1 10 //2 10 //3 11 //8 10 //18 10 上面思路，由于map是无序的，这里创建一个切片，然后根据切片的方法进行排序
map反转
初始化另外一个map把key、value呼唤即可
package main
import (
"fmt"
)
func test(){
var a map[string] int
var b map[int] string
a=make(map[string]int,5)
b=make(map[int]string,5)
a["abc"]=1
a["efg"]=2
for k,v:=range a{
b[v]=k
}
fmt.Println(a) //map[abc:1 efg:2]
fmt.Println(b) //map[1:abc 2:efg]
}
func main(){
test()
}
原理：这里首先声明两个map，并且初始化，然后进行遍历第一个map，然后第二个map直接添加第一个map的v和k即可
包
1、golang中的包
a、golang目前有150个标准的包，覆盖了几乎所有的基础库
b、golang.org有所有包的文档，没事就翻翻
2、线程同步
a、import(“sync”)
b、互斥锁 var mu sync.Mutex，同一时间只能有一个goroute能进去
c、读写锁，var mu sync.RWMutex
线程和协程，只有读操作的时候不用加锁
1、如果有写操作，需要加锁
2、如果有读写的操作，需要加锁
3、如果只有读的操作，不需要加锁
编译的时候—race可以查看是否有竞争
下面是互斥锁的程序
import ( "fmt" "sync" "math/rand" "time" ) //因为这是一个读写的操作，所以读的时候也要加锁 var lock sync.Mutex func test(){ var a map[int] int a=make(map[int]int,5) a[8]=10 for i :=0;i<2;i++{ go func(b map [int]int){ //下面是写的操作，所以要加锁 lock.Lock() //加锁 b[8]=rand.Intn(100) lock.Unlock() //解锁 }(a) } lock.Lock() //这是读操作，因为程序中有读写，所以加锁 fmt.Println(a) time.Sleep(time.Second) lock.Unlock() //解锁 } func main(){ test() } D:project>go build --race go_dev/day4/example/packagea 这里—race是检测是否有竞争 D:project>packagea.exe //因为有race所以下面检测没有竞争 map[8:81] 上面是互斥锁 应用场景： 写比较多，有少量的读。（写多读少） 加锁后，任何其他试图再次加锁的线程会被阻塞，直到当前进程解锁 如果解锁时有一个以上的线程阻塞，那么所有该锁上的线程都被编程就绪状态， 第一个变为就绪状态的线程又执行加锁操作，那么其他的线程又会进入等待。 在这种方式下，只有一个线程能够访问被互斥锁保护的资源。 互斥锁无论读还是写同一时间只有一个协程在执行
读写锁：
实际就是一种特殊的自旋锁，它把共享资源的访问者划分为读者和写者，读者只对共享资源进行读访问，写者则需要对共享资源进行写操作
使用场景：
写比较少，有大量的读 （读多写少）
写的时候只有一个goroute去写，但是读的时候所有的goroute去读
读写锁有三种状态：读加锁状态、写加锁状态和不加锁状态
一次只有一个线程可以占有写模式的读写锁，但是多个线程可以同时占有读模式的读写锁。（这也是它能够实现高并发的一种手段）
当读写锁在写加锁模式下，任何试图对这个锁进行加锁的线程都会被阻塞，直到写进程对其解锁。
当读写锁在读加锁模式先，任何线程都可以对其进行读加锁操作，但是所有试图进行写加锁操作的线程都会被阻塞，直到所有的读线程都解锁。
所以读写锁非常适合对数据结构读的次数远远大于写的情况
package main import ( "fmt" "sync" "math/rand" "time" ) var rwlock sync.RWMutex //读写锁的定义 func test(){ var a map[int] int a=make(map[int]int,5) //var count int32 a[8]=10 for i:=0;i<2;i++{ go func(b map[int]int){ rwlock.Lock() b[8]=rand.Intn(100) rwlock.Unlock() }(a) } for i:=0;i<100;i++{ go func(b map[int]int){ rwlock.RLock() //加读写锁 fmt.Println(a) rwlock.RUnlock() //解锁 }(a) } time.Sleep(time.Second*3) } func main(){ test() }
原子操作：atomic 包 在sync下面
https://studygolang.com/pkgdoc
这是串行的操作
package main import ( "fmt" "sync" "math/rand" "time" "sync/atomic" ) var rwlock sync.RWMutex //读写锁的定义 func test(){ var a map[int] int a=make(map[int]int,5) var count int32 a[8]=10 for i:=0;i<2;i++{ go func(b map[int]int){ rwlock.Lock() b[8]=rand.Intn(100) rwlock.Unlock() }(a) } for i:=0;i<100;i++{ go func(b map[int]int){ for { rwlock.RLock() //加读写锁 fmt.Println(a) rwlock.RUnlock() //解锁 atomic.AddInt32(&count, 1) //原子操作进行计数 } }(a) } time.Sleep(time.Second*3) fmt.Println(atomic.LoadInt32(&count)) //原子操作进行读出来529500 次 } func main(){ test() }
比较读写锁和互斥锁的性能
下面是读写锁 package main import ( "fmt" "sync" "math/rand" "time" "sync/atomic" ) var rwlock sync.RWMutex //读写锁的定义 func test(){ var a map[int] int a=make(map[int]int,5) var count int32 a[8]=10 for i:=0;i<2;i++{ go func(b map[int]int){ rwlock.Lock() b[8]=rand.Intn(100) time.Sleep(time.Microsecond*10) rwlock.Unlock() }(a) } for i:=0;i<100;i++{ go func(b map[int]int){ for { rwlock.RLock() //加读写锁 time.Sleep(time.Microsecond) rwlock.RUnlock() //解锁 atomic.AddInt32(&count, 1) //原子操作进行计数 } }(a) } time.Sleep(time.Second*3) fmt.Println(atomic.LoadInt32(&count)) //251196 } func main(){ test() } 下面是互斥锁 package main import ( "fmt" "sync" "math/rand" "time" "sync/atomic" ) var lock sync.Mutex //读写锁的定义 func test(){ var a map[int] int a=make(map[int]int,5) var count int32 a[8]=10 for i:=0;i<2;i++{ go func(b map[int]int){ lock.Lock() b[8]=rand.Intn(100) time.Sleep(time.Microsecond*10) lock.Unlock() }(a) } for i:=0;i<100;i++{ go func(b map[int]int){ for { lock.Lock() //rwlock.RLock() //加读写锁 time.Sleep(time.Microsecond) //rwlock.RUnlock() //解锁 lock.Unlock() atomic.AddInt32(&count, 1) //原子操作进行计数 } }(a) } time.Sleep(time.Second*3) fmt.Println(atomic.LoadInt32(&count)) //2460次 } func main(){ test() } 可以看到读写锁的性能是互斥锁的性能的100倍！ 读写锁：读的时候可以有多个协程在操作 互斥锁：无论读还是写，只有一个协程在执行
go get安装第三方包
go get后面跟上github地址