// 长度 vs 容量、 // 长度是目前里面有几个值 // 容量是最多能放多少个值 func main(){ var a =make(chan int,4) a<-1 a<-2 a<-5 fmt.Println(len(a)) //3 fmt.Println(cap(a))// 45 <-a // 取值 fmt.Println(len(a)) // 2 fmt.Println(cap(a)) // 4 }
一.协程
package main import ( "fmt" "time" ) //go 协程 func test() { fmt.Println("hello go") } func main() { //goroutine go test() go test() go test() go test() go test() go test() go test() time.Sleep(time.Second*2) }
二.值的存 和取
package main import ( "fmt" ) // (2)信道 管道 通道 // 信道也是个变量 // 类型：信道运输的类型是int 类型 // 性质：是一种引用的类型 所以需要在初始化的时候就得付初始值 func task2(a chan bool) { fmt.Println("hello go ") // IO 一旦执行完毕，就往信道中放入一个值 a <- true // 存值 fmt.Println("666") } // 入口函数 理解 func main(){ // 必须初始化 var a chan bool = make(chan bool) // 执行函数 go task2(a) // 往里面存值 // <- a// 取值 x:=<-a fmt.Println(x) }
------------恢复内容结束------------
一. 在方法中使用 值 接收器 与 在函数中使用 值 参数
（1）定义用一个外部函数（接收器：接收值）方法中使用值接收器方法
package main import "fmt" // 在方法中使用 值 接收器 与 在函数中使用 值 参数 // 在方法中使用 指针 接收器 与函数再使用 指针 参数 // 结构体 type Person5 struct{ name string age int sex int } // (1)定义用一个外部函数（接收器：接收值）方法中使用值接收器方法 func (a Person5)printName(){ fmt.Println(a.name) fmt.Println(a.age) fmt.Println(a.sex) } func main(){ // 定义一个变量 p:=Person5{name:"tt",age:18,sex:1} // 调用值接收器 p.printName()
（2）方法中使用指针接收器
package main import "fmt" // 函数中使用 指针传值 // (1)定义一个结构体 type Person2 struct { name string age int sex int } // (2)定义一个函数 中功能代码 func (a *Person2)printName(){ // 需要执行的功能 哈 fmt.Println(a.name) fmt.Println(a.age) } // (3)入口函数 func main(){ // 定义结构体的变量 // var t *Person2=&Person2{name:"tt",age:18,sex:2} t:=&Person2{name:"tt",age:18,sex:2} // 值的传递可以省略类型 t.printName() }
（3）函数的值传递和指针传递
函数中使用值参数
// (1)定义结构体 type Person2 struct{ name string age string sex int id int } // (2)定义一个外部功能函数 参数和结构体一一对应 其实还有返回值 func printName(a Person2){ fmt.Println(a.name) fmt.Println(a.age) fmt.Println(a.sex) fmt.Println(a.id) } // (3)入口函数 >>>> url 地址的入口 func main() { // (4)定义结构的变量的初始值 //p:=Person2{} //字符串则是 空 数字 则是0 //fmt.Println(p,"---==") p:=Person2{name:"yy",age:"18",sex:2} // 不设置数字就是0 printName(p) // 函数就是传值 接收器（a Person） p点方法 }
（4）函数中的指针传递参数
package main
import "fmt"
// (4)函数中的指针传递值
// (1)go语言定义结构体
type Person2 struct{
name string
age int
sex int
id int
}
// (2)外部执行功能函数
func printName(a *Person2){
fmt.Println(a.name)
fmt.Println(a.age)
fmt.Println(a.sex)
fmt.Println(a.id)
}
// (3)入口函数
func main(){
// (4)定义变量及初始化
p:=&Person2{age:18,name:"yuyu",sex:1,id:13} // 指名道姓 无关顺序
printName(p) // &p和上面的一样获取地址
}
一.接收器如果不能进行识别需要进行重命名
package main import "fmt" // 在非结构体上的方法 》》》重命名 接收器 type MyInt int func (i *MyInt) add(){ (*i)++ fmt.Println(*i) // 11 } func main() { // 定义一个变量 var a MyInt=10 a.add() // 接收器传值 fmt.Println(a) // 引用11 }
三，接口：是一系类方法的集合
（1）实现方式一：接收器 传值 >>> mian 中点方法进行调用
package main import "fmt" // 接口 继承 封装 多态 ，鸭子类型 重点***** // 接口：一系列方法的集合 // (1)语法： // type 接口名 interface{ // test方法一() // 方法二功能() // } // >>>(1)定义一个鸭子类的接口 type Duck interface{ run() speak() } // 结构体实现该接口(只要实现了接口中的所方法，该结构体实现了Duck接口) // >>>(2)定义一普通胖鸭子类 结构体 type PDuck struct { // 属性 name string age string id int } // (3)接口函数的值的传递 func (p PDuck) run(){ fmt.Println("我是第一只胖鸭子 会run") } func (p PDuck)speak(){ fmt.Println("我是第一只胖鸭子 会speak") } // 定义一只唐老鸭 结构体 type TDuck struct { name string age string wife bool } // 定义TDduct 的方法 不用函数实现 func (p TDuck) run(){ fmt.Println("我是唐老鸭 会run ") fmt.Println(p.name) } // 再定义一个speak 接收器方法 func (p TDuck) speat(){ fmt.Println("我是唐老鸭 会speak") fmt.Println(p.wife,"555") // } // (3)函数入口 func main(){ pD:=PDuck{name:"胖鸭子"} tD:=TDuck{name:"唐老鸭"} // 写一个函数：让鸭子说话，不管是唐老鸭还是胖鸭子 pD.speak() // 我是第一只胖鸭子 会speak 可以调 tD.speat() // 我是唐老鸭 会speak
（2）实现接收器中函数的 run() 和speak() 方法 方法二：定义普通函数 在普通函数体内进行 run() 同时在我们的main中 调用 普通函数
package main import "fmt" // 接口 继承 封装 多态 ，鸭子类型 重点***** // 接口：一系列方法的集合 // (1)语法： // type 接口名 interface{ // test方法一() // 方法二功能() // } // >>>(1)定义一个鸭子类的接口 type Duck interface{ run() speak() } // 结构体实现该接口(只要实现了接口中的所方法，该结构体实现了Duck接口) // >>>(2)定义一普通胖鸭子类 结构体 type PDuck struct { // 属性 name string age string id int } // (3)接口函数的值的传递 func (p PDuck) run(){ fmt.Println("我是第一只胖鸭子 会run") } func (p PDuck)speak(){ fmt.Println("我是第一只胖鸭子 会speak") } // 定义一只唐老鸭 结构体 type TDuck struct { name string age string wife bool } // 定义TDduct 的方法 不用函数实现 func (p TDuck) run(){ fmt.Println("我是唐老鸭 会run ") fmt.Println(p.name) } // 再定义一个speak 接收器方法 func (p TDuck) speat(){ fmt.Println("我是唐老鸭 会speak") fmt.Println(p.wife,"555") // } // (3)函数入口 func main(){ pD:=PDuck{name:"胖鸭子"} tD:=TDuck{name:"唐老鸭"} // 写一个函数：让鸭子说话，不管是唐老鸭还是胖鸭子 //pD.speak() // 我是第一只胖鸭子 会speak 可以调 //tD.speat() // 我是唐老鸭 会speak //// speak(tD,"yyyy") //接收器 不是函数 不能传值 // 同时实现speak speak2(tD) 调用普通函数 speak(pD) // XXX(pD) var d Duck d=pD // d=tD fmt.Println(d,"xxxx") // {唐老鸭 false} xxxx } // （4）函数 的传值 func speak(p PDuck){ p.speak() 调用接收器中的方法 } func speak2(p TDuck){ p.speat() } func XXX(p PDuck){ p.run() // 在一个函数调用另一个函数 fmt.Println(p.name) 调用接收器的方法 }
四、断言 switch 判断子类的属性和方法
package main import "fmt" // 接口 继承 封装 多态 ，鸭子类型 重点***** // 接口：一系列方法的集合 // (1)语法： // type 接口名 interface{ // test方法一() // 方法二功能() // } // >>>(1)定义一个鸭子类的接口 type Duck interface{ run() speak() } // 结构体实现该接口(只要实现了接口中的所方法，该结构体实现了Duck接口) // >>>(2)定义一普通胖鸭子类 结构体 type PDuck struct { // 属性 name string age string id int } // (3)接口函数的值的传递 func (p PDuck) run(){ fmt.Println("我是第一只胖鸭子 会run") } func (p PDuck)speak(){ fmt.Println("我是第一只胖鸭子 会speak") } // 定义一只唐老鸭 结构体 type TDuck struct { name string age string wife bool } // 定义TDduct 的方法 不用函数实现 func (p TDuck) run(){ fmt.Println("我是唐老鸭 会run ") fmt.Println(p.name) } // 再定义一个speak 接收器方法 func (p TDuck) speat(){ fmt.Println("我是唐老鸭 会speak") fmt.Println(p.wife,"555") // } // (3)函数入口 func main(){ pD:=PDuck{name:"胖鸭子"} tD:=TDuck{name:"唐老鸭"} // 写一个函数：让鸭子说话，不管是唐老鸭还是胖鸭子 //pD.speak() // 我是第一只胖鸭子 会speak 可以调 //tD.speat() // 我是唐老鸭 会speak //// speak(tD,"yyyy") //接收器 不是函数 不能传值 // 同时实现speak speak2(tD) 调用普通函数 speak(pD) // XXX(pD) var d Duck d=pD // d=tD fmt.Println(d,"xxxx") // {唐老鸭 false} xxxx } // （4）函数 的传值 func speak(p PDuck){ p.speak() 调用接收器中的方法 } func speak2(p TDuck){ p.speat() } func XXX(p PDuck){ p.run() // 在一个函数调用另一个函数 fmt.Println(p.name) 调用接收器的方法 }
截图suoshi:
空接口
package main import "fmt" // 空接口(一个方法都没有) // 匿名空接口 // 所有的数据类型都实现了空接口 // 类似于一个父类 type Empty interface{ } type TDuck2 struct { name string age int wife bool } // 入口函数 func main(){ test3(1) test3("sss") test3(TDuck2{}) test3(10.233432423) //var a Empty=1 //var b Empty="IOOIO" } //func test(a Empty){ // fmt.Println(a) //} func test3(a interface{}) { switch a.(type) { case int: fmt.Println("int类型") case string: fmt.Println("string") case TDuck2: fmt.Println("老鸭子") default: fmt.Println("啥类型") }
五.异常处理
package main import ( "fmt" ) // 异常处理 // defer 延迟调用 即便程序出现严重错误 也会执行 // panic 就是python中的raise(主动跑出异常) // recover 恢复程序， 继续执行 func main() { //先注册，后调用 //defere ???? fmt.Println("xxx") // defere fmt.Println("yyyy") //f1() // 调用 f2() // 调用 //f3() // 调用 } func f1(){ fmt.Println("f1...") } func f2(){ defer func() { if a:=recover();a!=nil{ // a 如果不等于nil, 表示程序出了异常， a就是异常信息 // a 等于nil 表示没有异常 fmt.Println("代码异常出错；了") }//用于会被执行（相当于finally） }() // 这里执行函数 fmt.Println("f2...") // var a = make([]int,3,3) // fmt.Println(a[4]) panic("主动抛异常") } func f3(){ fmt.Println("f3...") }
六。自定义set map 去重
package main import "fmt" // (1)自定义set() 可以放值 type MySet map[interface{}]bool //func (s MySet)isExist(a interface{}) bool { // return s[a] // 这只是个接口 判断 //} // 定义接口函数 interface{} 其实大可不必要用*号 func (s *MySet) set(a interface{}){ (*s)[a]=true // } //用函数 就是一个普通的接收器函数// 可以查看长度 func (s MySet)len()int { return len(s) } // // 可以打印所有内容 MySet 》》》 类接收器 func (a MySet)printAll(){ for k,v:=range a{// 关键字range + s 变量 fmt.Println(k,v,"000--") } } func main() { // MySet = map[interface{}]bool 这个类型 var a MySet=make(MySet) fmt.Println(a) // 空类型map[] a.set("1") a.set("1") a.set("2") fmt.Println(len(a)) fmt.Println(a) fmt.Println(a.len()) a.printAll() }
七.信道
（1）只写信道
package main import "fmt" // 单向信道只能放或 取 chan 关键字 a:=<-b 取 a<- 存取 箭头 func sendData(sendch chan<-int){ sendch<-10 } func main(){ //只写信道 sendch :=make(chan int) go sendData(sendch) fmt.Println(<-sendch) }
（信道死锁的问题）
package main import "fmt" // 单向信道只能放或 取 //func sendData(sendch chan<-int){ // sendch<-10 //} // //func main(){ // //只写信道 // sendch :=make(chan int) // go sendData(sendch) // fmt.Println(<-sendch) //} // 关闭信道和使用 for range 遍历信道 func task3(ccc chan int){ for i:=0;i<10;i++{ ccc<-i } close(ccc) // 关闭即可 } func main(){ // 类型定义 c:=make(chan int) go task3(c) // 死循环在监听我们的事件 for { v,ok:=<-c // 如果信道关闭，OK就是false if ok==false{ break } fmt.Println("打印",v,ok) } } // 出现死锁：fatal error: all goroutines are asleep - deadlock! // 在for 循环结束后关闭存储任务 即可 解决死锁问题
2.信道缓存 》》》 设定缓存大小
（1）
package main import "fmt" // 信道缓冲 func main(){ // 初始化 var t chan int=make(chan int,1) // 0 前期缓存值 t<-1 // 将1 存入a 信道中 不写默认为0 根本存不进去 b:=<-t fmt.Println("xxx",b) }
（2）容量
package main import ( "fmt" "time" ) // 列子 func write(ddd chan int){ // ddd 就相当于一个容器 for i:=0;i<10;i++{ ddd<-i } close(ddd) } // 入口函数 func main() { // 初始定义类型和信道类型 和 容量 var ddd chan int=make(chan int,5) go write(ddd) // 做io time.Sleep(2*time.Second) for v:=range ddd{ fmt.Println("reader value",v,"from ddd") time.Sleep(2*time.Second) } }
（3）容量和长度
// 长度 vs 容量、 // 长度是目前里面有几个值 // 容量是最多能放多少个值 func main(){ var a =make(chan int,4) a<-1 a<-2 a<-5 fmt.Println(len(a)) //3 fmt.Println(cap(a))// 45 <-a // 取值 fmt.Println(len(a)) // 2 fmt.Println(cap(a)) // 4 }
(4)sync.WaitGroup
package main import ( "fmt" "sync" "time" ) // waitgroup:等待所有go协程执行完成 func task4(wg *sync.WaitGroup,i int){ time.Sleep(time.Second*2) fmt.Println(i) wg.Done() // } func main(){ // sync包下的waitGroup,是个值类型，当参传递，需要地址 var wg sync.WaitGroup // 定义 for i:=0;i<5;i++ { //wg.Add表示标志了起了一个goroutine wg.Add(1) go task4(&wg, i) } // 等待所有协程执行完成 wg.Wait() fmt.Println("都执行完了") }
(5)通过信道实现
//package main // //import ( //"fmt" //"sync" //"time" //) // //// waitgroup:等待所有go协程执行完成 //func task4(wg *sync.WaitGroup,i int){ // time.Sleep(time.Second*2) // fmt.Println(i) // wg.Done() // //} // //func main(){ // // sync包下的waitGroup,是个值类型，当参传递，需要地址 // var wg sync.WaitGroup // 定义 // for i:=0;i<5;i++ { // //wg.Add表示标志了起了一个goroutine // wg.Add(1) // go task4(&wg, i) // } // // 等待所有协程执行完成 // wg.Wait() // fmt.Println("都执行完了") // //} package main import ( "fmt" "time" ) // 通过信道实现 func main(){ var a =make(chan bool) for i:=0;i<5;i++{ go task6(a,i) // 将信道和i 值传送到我们的函数中 } for i:=0;i<5;i++{ <-a // 取值 } fmt.Println("都执行完了") } // 传值传几个接收几个 以及类型 func task6(a chan bool,i int){ time.Sleep(time.Second*2) fmt.Println(i) a<-true // 将值存入我们a 信道中 }
七。中的锁
package main import ( "fmt" "sync" ) // go 中的锁实现数据的安全 // 功能 var x=0 func incrament(wg *sync.WaitGroup,m *sync.Mutex){ // 布置锁 m.Lock() x = x+10 m.Unlock() wg.Done() fmt.Println(x) // 从10开始 } func main(){ var w sync.WaitGroup // 定义变量 var m sync.Mutex // 定义锁 // 值类型 ，传递地址 for i:=0;i<1000;i++{ w.Add(1) go incrament(&w,&m) } w.Wait() fmt.Println("都执行完毕了",x) // 拿到最后的值 }
（2）信道也是保证数据安全？
//package main // //import ( // "fmt" // "sync" //) // //// go 中的锁实现数据的安全 // //// 功能 //var x=0 //func incrament(wg *sync.WaitGroup,m *sync.Mutex){ // // 布置锁 // m.Lock() // x = x+10 // m.Unlock() // wg.Done() // fmt.Println(x) // 从10开始 // //} // // //func main(){ // var w sync.WaitGroup // 定义变量 // var m sync.Mutex // 定义锁 // 值类型 ，传递地址 // for i:=0;i<1000;i++{ // w.Add(1) // go incrament(&w,&m) // // } // w.Wait() // fmt.Println("都执行完毕了",x) // 拿到最后的值 //} // 通过信到实现数据的存值 package main import ( "fmt" "sync" ) var x=0 func increment(w *sync.WaitGroup,ch chan bool){ ch<-true // 进行存储 x=x+10 <-ch w.Done() // 执行 fmt.Println(x,"执行x") } func main(){ var w sync.WaitGroup // 定义一个 ch :=make(chan bool,1) for i:=0;i<5;i++{ w.Add(1) go increment(&w,ch) } w.Wait() fmt.Println("final value ofｘ",x) }