go学习
重点关注
Go 设置阿里源镜像地址
go env -w GOPROXY=https://mirrors.aliyun.com/goproxy/
go env -w GOPROXY=https://goproxy.cn,direct
1、闭包
package main import "fmt" func main() { x, y := 6, 8 defer func(a int) { fmt.Println("defer x, y = ", a, y) //y为闭包引用 }(x) x += 10 y += 100 fmt.Println(x, y) } 运行结果： 16 108 defer x, y = 6 108 最后执行时y值已经改变，不再是8。x的值是传参复制进来，已经确定为6
2、方法和函数
package main import ( "fmt" ) /* 定义结构体 */ type Circle struct { radius float64 } func main() { var c Circle c.radius = 6.00 fmt.Println("圆的周长 = ", c.getCircumference()) } func (c Circle) getCircumference() float64 { //该 method 属于 Circle 类型对象中的方法 return 2 * 3.14 * c.radius //c.radius 即为 Circle 类型对象中的属性 } func getCircumference(c Circle) float64 { //为函数 return 2 * 3.14 * c.radius //c.radius 即为 Circle 类型对象中的属性 }
3、函数赋值和直接调用
package main import "fmt" func main() { // 定义匿名函数并赋值给f变量 f := func(data int) { fmt.Println("hi, this is a closure", data) } // 此时f变量的类型是func(), 可以直接调用 f(6) //直接声明并调用 func(data int) { fmt.Println("hi, this is a closure, directly", data) }(8) }
func myfunc() string { defer func() { //return name 之后才执行 name = "python" }() fmt.Printf("myfunc 函数里的name：%s\n", name) return name }
python所有变量都是指针_一切都是对象，一切都是指针，一切都是东西（python的编程哲学）...
我的感受：
说python起源于c，一点都不过分。而且，处处是指针，处处是对象。不得不佩服作者的创造力，自己曾经也被c语言的指针整的焦头烂额。能不用就不不碰，那内存崩溃是刚刚的。没想象，python的作者把c语言的指针整这么溜，甚至发展成为一门编程语言，还集成在各种Linux系统中。
现在发现，不能用c语言的思路去理解python语言了。网上很多c#和python的比较，但是我要说的是，这两种语言设计思路从最核心，最底层的解决思路是不一样的。c#更像java。而python更像c。
看看，a =5 在c中是非常普通的赋值，我们也通常把这个语句叫做赋值语句，但是在python中，这样的理解就错了。
我们分别查一下他们的内存地址，发现地址是一样的，原来python把这语句看做是对象实例化的语句。就是把一个整数对象实例化变量为a，如果用c来写的话，要 写成：
a= new 5()
是不是很奇怪，一个类，或者对象是不可以用数字来命名的，但是作为对象实例化，或者类的实例化，问题就很好理解了。
可以a = 5，页可以 a=‘aaa‘等。而且这个时候，原来的a的地址回收了。这里的a又重新指向字符串的地址了。
说白了，并不是定义了一个变量，而是定义了一个指针：
c: *a = 5
总而言之：python把一切数据，一切的一切都看作对象，在python中，没有变量，只有指针，要说变量，也是指针变量。
啦啦啦啦啦啦啦啦啦啦……
一、接口定义
概念: Interface类型可以定义一组方法，不需要实现，并且不能包含任何变量，称之为接口。
接口不需要显式的实现，只需要一个变量，含有接口类型中的所有方法，那么这个变量就实现了这个接口，如果一个变显含有了多个interface类型的方法，那么这个变量就实现了多个接口。
接口是一个或多个方法签名的集合。
任何类型的方法集中只要拥有该接口'对应的全部方法'签名。
就表示它 "实现" 了该接口，无须在该类型上显式声明实现了哪个接口。
这称为Structural Typing。
所谓对应方法，是指有相同名称、参数列表 (不包括参数名) 以及返回值。
接口只有方法声明，没有实现，没有数据字段。
接口可以匿名嵌入其他接口，或嵌入到结构中。
对象赋值给接口时，会发生拷贝，而接口内部存储的是指向这个复制品的指针，既无法修改复制品的状态，也无法获取指针。
只有当接口存储的类型和对象都为nil时，接口才等于nil。
接口调用不会做receiver的自动转换。
接口同样支持匿名字段方法。
接口也可实现类似OOP中的多态。
空接口可以作为任何类型数据的容器。
一个类型可实现多个接口。
接口命名习惯以 er 结尾。
1.接口名：使用type将接口定义为自定义的类型名。Go语言的接口在命名时，一般会在单词后面添加er，如有写操作的接口叫Writer，有字符串功能的接口叫Stringer等。接口名最好要能突出该接口的类型含义。
2.方法名：当方法名首字母是大写且这个接口类型名首字母也是大写时，这个方法可以被接口所在的包（package）之外的代码访问。
3.参数列表、返回值列表：参数列表和返回值列表中的参数变量名可以省略。
举个例子：
type writer interface{
Write([]byte) error
}
当你看到这个接口类型的值时，你不知道它是什么，唯一知道的就是可以通过它的Write方法来做一些事情。
空接口
空接口是指没有定义任何方法的接口。因此任何类型都实现了空接口。
空接口类型的变量可以存储任意类型的变量。
package main import "fmt" //空接口 type Test interface func main() { //声明接口 var t Test var a interface{} var b int a = b fmt.Printf("a数据类型:%T\n", a) fmt. Printf("Test数据类型:%T\n", t) } 运行结果 a的类型:int，a的值:0 Test的数据类型:<nil>，t的值:<nil>
package main import "fmt" func main() { // 定义一个空接口x var x interface{} s := "pprof.cn" x = s fmt.Printf("type:%T value:%v\n", x, x) i := 100 x = i fmt.Printf("type:%T value:%v\n", x, x) b := true x = b fmt.Printf("type:%T value:%v\n", x, x) } 运行结果 type:string value:pprof.cn type:int value:100 type:bool value:true
package main import "fmt” type student struct { Name string Age int score float32 } //接口定义:接口是功能的抽象 type Test interface { Print() } //指针类型实现接口 func (p *Student) Print() { fmt.Println("name: ",p.Name) fmt.Print1n("age:", p.Age) fmt.Println("score:", p.Score) } /*值类型实现接口 func (p Student)Print(){ fmt.Println("name: ",p.Name) fmt.Println("age:", p.Age) fmt.Println("score:", p.Score) } */ func main(){ var t Test var stu Student = Student{ Name: "zhangsan", Age: 18, Score:90, } //结构体实现接口功能t = stu值类型使用t - &stu t.print() } 运行结果 Name: zhangsan Age: 18 Score:90
package main import "fmt" //定义一个结构体 type Car struct { name string color string } //定义接口 type Cry interface { call() Sleep() } //使用接口 func (c *Car) call() { fmt.Printf("name:%s\n", c.name) fmt.Printf("color:%s\n", c.color) } func (c *Car) Sleep() { fmt.Println("加油 梦想") } func main() { //定义接口变量 var t Cry var car Car = Car{ name: "audiRs7", color: "black", } t = &car t.call() t.Sleep() } name:audiRs7 color:black 加油 梦想
package main import "fmt" //父类 type Persion struct { Name string Age int8 } type Women struct { Persion Looks string } type Men struct { Persion Money float32 } //定义接口 type Move interface { Sleep() Action() } func (w Women) Action() { fmt.Printf("name:%s\n", w.Name) fmt.Printf("Age:%d\n", w.Age) fmt.Printf("Looks:%s\n", w.Looks) } func (w Women) Sleep() { fmt.Println("正在休息") } func (m Men) Action() { fmt.Printf("name:%s\n", m.Name) fmt.Printf("Age:%d\n", m.Age) fmt.Printf("money:%f\n", m.Money) } func (m Men) Sleep() { fmt.Println("正在休息") } func main() { var t Move var wo Women wo.Name = "zhangsan" wo.Age = 20 wo.Looks = "漂亮" t = wo t.Action() t.Sleep() fmt.Println("-----------------") var m Men m.Name = "zhangsan" m.Age = 20 m.Money = 13433545 t = m t.Action() t.Sleep() } name:zhangsan Age:20 Looks:漂亮 正在休息 ----------------- name:zhangsan Age:20 money:13433545.000000 正在休息
package main import "fmt" type Sayer interface { say() } // Mover 接口 type Mover interface { move() } //dog既可以实现Sayer接口，也可以实现Mover接口。 type dog struct { name string } // 实现Sayer接口 func (d dog) say() { fmt.Printf("%s会叫汪汪汪\n", d.name) } // 实现Mover接口 func (d dog) move() { fmt.Printf("%s会动\n", d.name) } func main() { var x Sayer var y Mover var a = dog{name: "旺财"} x = a y = a x.say() y.move() } 运行结果 旺财会叫汪汪汪 旺财会动
package main import "fmt" //在电脑上定义一个uSB接口，实现鼠标，u盘存储，电扇的功能 //父类 usb type Usb struct { MouseName string Uname string FanName string } type USB interface { mouse() U() Fan() } func (u Usb) mouse() { fmt.Printf("我是鼠标,名字叫:%s\n", u.MouseName) } func (u Usb) U() { fmt.Println("我是u盘\n", u.Uname) } func (u Usb) Fan() { fmt.Println("我是风扇\n", u.FanName) } func main() { var t USB var us Usb us.MouseName = "雷蛇" us.Uname = "666" us.FanName = "风扇" t = us t.mouse() t.Fan() t.U() } 运行结果 我是鼠标,名字叫:雷蛇 我是风扇 风扇 我是u盘 666
package main import ( "fmt" "math/rand" "sort" ) //定义结构体 type Student struct { Name string Age int score float32 } //定义切片 type StudentArray []Student //定义sort接口 func (s StudentArray) Len() int { return len(s) } func (s StudentArray) Less(i, j int) bool { return s[i].Name < s[j].Name } func (s StudentArray) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
func main() { //切片 var Stu StudentArray //生成10个结构体放入切片中 for i := 0; i < 10; i++ { var stu = Student{ Name: fmt.Sprintf("stu%d:", rand.Intn(100)), Age: rand.Intn(100), score: rand.Float32() * 100, } //元素追加 Stu = append(Stu, stu) } //排序 sort.Sort(Stu) //遍历 for _, v := range Stu { fmt.Println(v) } } 运行结果 {stu0: 94 81.36399} {stu25: 40 9.696952} {stu37: 6 20.318687} {stu47: 47 75.2573} {stu59: 81 68.682304} {stu62: 89 31.805817} {stu66: 28 86.249146} {stu74: 11 29.310184} {stu81: 87 66.45601} {stu88: 90 69.67192}
package main import "fmt" //定义读写接口 type Reader interface { read() } type Wirter interface { wirter() } //嵌套接口 type ReaderWirter interface { Reader Wirter } //定义一个结构体 type file struct { wen string xie string } //接口实现（方法定义） func (f *file) read() { fmt.Println("读的功能", f.wen) } func (f *file) wirter() { fmt.Println("写的功能", f.xie) } //读写操作函数（接口作为入参） func Test(rw ReaderWirter) { rw.read() rw.wirter() } func main() {
var f = file{ wen: "你真漂亮", xie: "谢谢", } Test(&f) } 运行结果 读的功能 你真漂亮 写的功能 谢谢
